11684952082

Committed 05 Nov 2024 01:15PM UTC coverage: 31.276% (+0.02%) from 31.261%

Build # 11684952082

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9971 from ForumMagnum/master

[EA] Deploy election copy update, LW stuff

Run Details

5072 of 42698 branches covered (11.88%)

Branch coverage included in aggregate %.

40 of 104 new or added lines in 12 files covered. (38.46%)

10 existing lines in 4 files now uncovered.

29752 of 68646 relevant lines covered (43.34%)

173.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.72

/packages/lesswrong/lib/utils/rawDom.tsx

import React, { useEffect, useLayoutEffect, useRef } from "react";
import { isClient } from "../executionEnvironment";


/**
 * Given a Range, which is a pair of text nodes plus offsets, mutate the DOM
 * so that there is a single span which encloses that range (and only that
 * range).
 *
 * This is _almost_ exactly the same as Range.surroundContents
 * (https://developer.mozilla.org/en-US/docs/Web/API/Range/surroundContents)
 * except that it shouldn't fail if the range requires splitting a non-text
 * node.
 */
export function wrapRangeWithSpan(range: Range): HTMLSpanElement|null {
  // Insert an empty span, just before the start of the selection
  const span = document.createElement("span");
  range.insertNode(span);
  range.setStartAfter(span);
  
  // Use Range.extractContents to detach the selected nodes, and put them into
  // the span
  const extractedFragment = range.extractContents()
  span.append(extractedFragment);
  
  return span;
}

/**
 * For in-browser use only. Given a Node which has been detached from the DOM,
 * take ownership of it, and return a React component which will attach that
 * node as a child of itself. That React component may not appear in the
 * document more than once.
 */
export function rawDomNodeToReactComponent(node: Node) {
  if (node.parentElement) {
    throw new Error("Node was not detached");
  }
  
  function DomNodeComponent(props: {}) {
    const containerRef = useRef<HTMLSpanElement|null>(null);
    
    // Insert contents in `useLayoutEffect` so that the screen can't paint with
    // substituted content missing, and so that it precedes any `useEffect`s
    // (most notably the footnote-extraction useEffect in `FootnotePreview`).
    useLayoutEffect(() => {
      if (containerRef.current) {
        // If this has been attached somewhere else, detach it
        if (node.parentElement && node.parentElement !== containerRef.current) {
          node.parentElement.removeChild(node);
        }
        // If this node is detached, attach it to the container
        if (!node.parentElement) {
          containerRef.current.append(node);
        }
      }
    });
    
    return <span ref={containerRef}/>
  }
  
  return DomNodeComponent;
}

/**
 * For in-browser use only. Give an Element in the DOM (which might or might
 * not be detached), detach all its children, wrap them in a <span> if there's
 * more than one, and return a React component containing those children.
 */
export function rawExtractElementChildrenToReactComponent(element: Element) {
  const childNodes = element.childNodes;
  const numChildNodes = childNodes.length;

  if (numChildNodes===0) {
    return React.Fragment;
  } else if (numChildNodes===1) {
    const childNode = element.childNodes[0];
    element.removeChild(childNode);
    return rawDomNodeToReactComponent(childNode);
  } else {
    const span = document.createElement("span");
    const children: Node[] = [];
    for (let i=0; i<numChildNodes; i++) {
      children.push(childNodes[i]);
    }
    for (let node of children) {
      element.removeChild(node);
      span.appendChild(node);
    }
    return rawDomNodeToReactComponent(span);
  }
}

/**
 * Given a Range, split it into ranges which don't cross the boundaries of block
 * elements, each of which starts and ends inside a text node. We do this to
 * inline-react highlights before applying them, to prevent the highlight from
 * breaking list structure or paragraph structure.
 */
export function splitRangeIntoReplaceableSubRanges(range: Range): Range[] {
  // Reduce the range, so that the start and end are guaranteed to be in text
  // nodes
  const reducedRange = reduceRangeToText(range);
  if (!reducedRange) return [];
  
  // Iterate over text nodes. For each pair of consecutive text nodes, check
  // whether they have a non-common ancestor that is a block element. If so,
  // split there.
  let textNodesInRange: Text[] = [];
  for (
    let pos: Text|null = reducedRange.startContainer as Text;
    pos && pos!==reducedRange.endContainer;
    pos=nextTextNodeAfter(pos)
  ) {
    textNodesInRange.push(pos);
  }
  textNodesInRange.push(reducedRange.endContainer as Text);
  
  let subranges: Range[] = [range];
  for (let i=1; i<textNodesInRange.length; i++) {
    if (!nodesCanShareSpan(textNodesInRange[i-1], textNodesInRange[i])) {
      let precedingSubrange = subranges.pop()!;
      let beforeSplit = precedingSubrange.cloneRange();
      let afterSplit = precedingSubrange.cloneRange();
      beforeSplit.setEnd(textNodesInRange[i-1], textNodesInRange[i-1].length);
      afterSplit.setStart(textNodesInRange[i], 0);
      subranges.push(beforeSplit);
      subranges.push(afterSplit);
    }
  }
  
  return subranges;
}

/**
 * Given two nodes, return whether, if extracted for a hover-highlight, they
 * can be placed in the same span, ie, this does not straddle a block boundary.
 */
function nodesCanShareSpan(first: Node, second: Node): boolean {
  const closestCommonAncestor = getClosestCommonAncestor(first, second);
  if (!closestCommonAncestor) return false;
  
  for (let pos: Node|null=first; pos && pos!==closestCommonAncestor; pos=pos.parentElement) {
    if (isBlockElement(pos))
      return false;
  }
  for (let pos: Node|null=second; pos && pos!==closestCommonAncestor; pos=pos.parentElement) {
    if (isBlockElement(pos))
      return false;
  }
  
  return true;
}

function getClosestCommonAncestor(node1: Node, node2: Node): Node|null {
  let pos: Node|null = node1;

  while (pos) {
    if (node2.contains(pos)) {
      return pos;
    }
    pos = pos.parentNode;
  }
  return null;
}

/**
 * Returns whether the given node is a block element (ie, an element which can't
 * be extracted from the DOM and futzed with by inline react hover hihlighting).
 */
function isBlockElement(node: Node) {
  if (node.nodeType !== Node.ELEMENT_NODE)
    return false;
  switch ((node as Element).tagName) {
    // This list of tag names was generated by looking at the allowed tag names
    // in the sanitizer config so it should be reasonably complete
    case "p": case "div": case 'blockquote':
    case "li": case "ol": case "ul": case "nl":
    case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
    case "table": case "tbody": case "tr": case "td": case "th":
    case "section":case "iframe":
      return true;
    default:
      return false;
  }
}

/**
 * Given a Range (a browser DOM API), reduce it to the smallest range that
 * contains the same text. So for example this range:
 *    <p>Paragraph One</p><p>Paragraph Two</p>
 *                 ^-----^
 * would become this range:
 *    <p>Paragraph One</p><p>Paragraph Two</p>
 *                 ^-^
 * The resulting range is guaranteed to have its start and end both be inside
 * text nodes. If the resulting range would have zero size (ie, it doesn't)
 * enclose any text), returns null.
 */
export function reduceRangeToText(range: Range): Range|null {
  if (!isClient) {
    throw new Error("This function can only run in the browser");
  }
  
  let result = range.cloneRange();
  
  // Adjust the start position forwards
  const startContainer = range.startContainer;
  const startOffset = range.startOffset;
  if (startContainer.nodeType === Node.TEXT_NODE) {
    // Start position is inside a text node
    // startOffset is the number of characters from the start of this text node
    // to the range boundary.
    const textNodeLength = startContainer.textContent?.length ?? 0
    if (textNodeLength === startOffset) {
      // Inside a text node, buf after all of the actual text. Find the next
      // text node in the tree, and set the position to be the start of that
      // one rather than the end of this one.
      const nextTextNode = nextTextNodeAfter(startContainer as Text);
      if (!nextTextNode) return null;
      result.setStart(nextTextNode, 0);
    }
  } else if (startContainer.nodeType === Node.ELEMENT_NODE) {
    // Start position is inside an element node
    // Per https://developer.mozilla.org/en-US/docs/Web/API/Range/startOffset,
    // startOffset is measured in _child nodes_, not characters.
    // Start by going down the tree until we're at a leaf node. Then if that
    // node is not a text node, walk forward until we reach a text node, in
    // which the new start position is offset 0.
    let pos = startContainer.childNodes[startOffset];
    while (pos.hasChildNodes()) {
      pos = pos.childNodes[0];
    }
    if (pos.nodeType === Node.TEXT_NODE) {
      result.setStart(pos, 0);
    } else {
      const nextTextNode = nextTextNodeAfter(pos);
      if (!nextTextNode) return null;
      result.setStart(nextTextNode, 0);
    }
  }
  
  // Now adjust the end position backwards. This is very similar to how we do
  // the start position, except everything goes in the opposite direction.
  const endContainer = range.endContainer;
  const endOffset = range.endOffset;
  if (endContainer.nodeType === Node.TEXT_NODE) {
    // End position is inside a text node
    if (endOffset === 0) {
      // Inside a text node, but before all of the actual text. Find the
      // previous text node in the tree, and set the position to be the end of
      // that one rather than the start of this one.
      const prevTextNode = prevTextNodeBefore(endContainer as Text);
      if (!prevTextNode) return null;
      result.setEnd(prevTextNode, prevTextNode.textContent?.length ?? 0);
    }
  } else {
    // End position is inside a non-text node
    let pos = endContainer.childNodes[endOffset];
    while (pos.hasChildNodes()) {
      pos = pos.childNodes[pos.childNodes.length-1];
    }
    if (pos.nodeType === Node.TEXT_NODE) {
      result.setEnd(pos, pos.textContent?.length ?? 0);
    } else {
      const prevTextNode = prevTextNodeBefore(pos);
      if (!prevTextNode) return null;
      result.setEnd(prevTextNode, prevTextNode.textContent?.length ?? 0);
    }
  }
  
  return result;
}

function nextTextNodeAfter(node: Node): Text|null {
  let pos: Node|null = node;
  do {
    pos = nextLeafNodeAfter(pos);
  } while (pos && pos.nodeType !== Node.TEXT_NODE);
  return pos as Text|null;
}

function prevTextNodeBefore(node: Node): Text|null {
  let pos: Node|null = node;
  do {
    pos = prevLeafNodeBefore(pos);
  } while (pos && pos.nodeType !== Node.TEXT_NODE);
  return pos as Text|null;
}

function nextLeafNodeAfter(node: Node): Node|null {
  if (node.nextSibling) {
    return firstDescendentOf(node.nextSibling);
  } else {
    let pos = node;
    while(pos.parentElement) {
      const nextSibling = nextSiblingNodeAfter(pos.parentElement, pos);
      if (nextSibling) {
        return firstDescendentOf(nextSibling);
      }
      pos = pos.parentElement;
    }
  }
  return null;
}

function prevLeafNodeBefore(node: Node): Node|null {
  if (node.previousSibling) {
    return lastDescendentOf(node.previousSibling);
  } else {
    let pos = node;
    while(pos.parentElement) {
      const prevSibling = prevSiblingNodeBefore(pos.parentElement, pos);
      if (prevSibling) {
        return lastDescendentOf(prevSibling);
      }
      pos = pos.parentElement;
    }
  }
  return null;
}

function firstDescendentOf(node: Node): Node {
  let pos = node;
  while(pos.hasChildNodes()) {
    pos = pos.childNodes[0];
  }
  return pos;
}

function lastDescendentOf(node: Node): Node {
  let pos = node;
  while(pos.hasChildNodes()) {
    pos = pos.childNodes[pos.childNodes.length-1];
  }
  return pos;
}

function nextSiblingNodeAfter(parentElement: Element, childNode: Node): Node|null {
  let idx = getNodeIndex(parentElement, childNode);
  if (idx === null) {
    return null;
  }
  if (idx+1 < parentElement.childNodes.length) {
    return parentElement.childNodes[idx+1];
  } else {
    return null;
  }
}

function prevSiblingNodeBefore(parentElement: Element, childNode: Node): Node|null {
  let idx = getNodeIndex(parentElement, childNode);
  if (idx === null) {
    return null;
  }
  if (idx > 0) {
    return parentElement.childNodes[idx-1];
  } else {
    return null;
  }
}

function getNodeIndex(parentElement: Element, node: Node): number|null {
  const numChildren = parentElement.childNodes.length;
  for (let i=0; i<numChildren; i++) {
    if (parentElement.childNodes[i] === node)
      return i;
  }
  return null;
}

1	import React, { useEffect, useLayoutEffect, useRef } from "react";	3✔
2	import { isClient } from "../executionEnvironment";	1✔
3
4
5	/**
6	* Given a Range, which is a pair of text nodes plus offsets, mutate the DOM
7	* so that there is a single span which encloses that range (and only that
8	* range).
9	*
10	* This is _almost_ exactly the same as Range.surroundContents
11	* (https://developer.mozilla.org/en-US/docs/Web/API/Range/surroundContents)
12	* except that it shouldn't fail if the range requires splitting a non-text
13	* node.
14	*/
15	export function wrapRangeWithSpan(range: Range): HTMLSpanElement\|null {
16	// Insert an empty span, just before the start of the selection
17	const span = document.createElement("span");	×
18	range.insertNode(span);	×
19	range.setStartAfter(span);	×
20
21	// Use Range.extractContents to detach the selected nodes, and put them into
22	// the span
23	const extractedFragment = range.extractContents()	×
24	span.append(extractedFragment);	×
25
26	return span;	×
27	}
28
29	/**
30	* For in-browser use only. Given a Node which has been detached from the DOM,
31	* take ownership of it, and return a React component which will attach that
32	* node as a child of itself. That React component may not appear in the
33	* document more than once.
34	*/
35	export function rawDomNodeToReactComponent(node: Node) {
36	if (node.parentElement) {	×
37	throw new Error("Node was not detached");	×
38	}
39
40	function DomNodeComponent(props: {}) {
41	const containerRef = useRef<HTMLSpanElement\|null>(null);	×
42
43	// Insert contents in `useLayoutEffect` so that the screen can't paint with
44	// substituted content missing, and so that it precedes any `useEffect`s
45	// (most notably the footnote-extraction useEffect in `FootnotePreview`).
NEW 46	useLayoutEffect(() => {	×
UNCOV 47	if (containerRef.current) {	×
48	// If this has been attached somewhere else, detach it
49	if (node.parentElement && node.parentElement !== containerRef.current) {	×
50	node.parentElement.removeChild(node);	×
51	}
52	// If this node is detached, attach it to the container
53	if (!node.parentElement) {	×
54	containerRef.current.append(node);	×
55	}
56	}
57	});
58
59	return <span ref={containerRef}/>	×
60	}
61
62	return DomNodeComponent;	×
63	}
64
65	/**
66	* For in-browser use only. Give an Element in the DOM (which might or might
67	* not be detached), detach all its children, wrap them in a <span> if there's
68	* more than one, and return a React component containing those children.
69	*/
70	export function rawExtractElementChildrenToReactComponent(element: Element) {
71	const childNodes = element.childNodes;	×
72	const numChildNodes = childNodes.length;	×
73
74	if (numChildNodes===0) {	×
75	return React.Fragment;	×
76	} else if (numChildNodes===1) {	×
77	const childNode = element.childNodes[0];	×
78	element.removeChild(childNode);	×
79	return rawDomNodeToReactComponent(childNode);	×
80	} else {
81	const span = document.createElement("span");	×
82	const children: Node[] = [];	×
83	for (let i=0; i<numChildNodes; i++) {	×
84	children.push(childNodes[i]);	×
85	}
86	for (let node of children) {	×
87	element.removeChild(node);	×
88	span.appendChild(node);	×
89	}
90	return rawDomNodeToReactComponent(span);	×
91	}
92	}
93
94	/**
95	* Given a Range, split it into ranges which don't cross the boundaries of block
96	* elements, each of which starts and ends inside a text node. We do this to
97	* inline-react highlights before applying them, to prevent the highlight from
98	* breaking list structure or paragraph structure.
99	*/
100	export function splitRangeIntoReplaceableSubRanges(range: Range): Range[] {
101	// Reduce the range, so that the start and end are guaranteed to be in text
102	// nodes
103	const reducedRange = reduceRangeToText(range);	×
104	if (!reducedRange) return [];	×
105
106	// Iterate over text nodes. For each pair of consecutive text nodes, check
107	// whether they have a non-common ancestor that is a block element. If so,
108	// split there.
109	let textNodesInRange: Text[] = [];	×
110	for (	×
111	let pos: Text\|null = reducedRange.startContainer as Text;	×
112	pos && pos!==reducedRange.endContainer;	×
113	pos=nextTextNodeAfter(pos)
114	) {
115	textNodesInRange.push(pos);	×
116	}
117	textNodesInRange.push(reducedRange.endContainer as Text);	×
118
119	let subranges: Range[] = [range];	×
120	for (let i=1; i<textNodesInRange.length; i++) {	×
121	if (!nodesCanShareSpan(textNodesInRange[i-1], textNodesInRange[i])) {	×
122	let precedingSubrange = subranges.pop()!;	×
123	let beforeSplit = precedingSubrange.cloneRange();	×
124	let afterSplit = precedingSubrange.cloneRange();	×
125	beforeSplit.setEnd(textNodesInRange[i-1], textNodesInRange[i-1].length);	×
126	afterSplit.setStart(textNodesInRange[i], 0);	×
127	subranges.push(beforeSplit);	×
128	subranges.push(afterSplit);	×
129	}
130	}
131
132	return subranges;	×
133	}
134
135	/**
136	* Given two nodes, return whether, if extracted for a hover-highlight, they
137	* can be placed in the same span, ie, this does not straddle a block boundary.
138	*/
139	function nodesCanShareSpan(first: Node, second: Node): boolean {
140	const closestCommonAncestor = getClosestCommonAncestor(first, second);	×
141	if (!closestCommonAncestor) return false;	×
142
143	for (let pos: Node\|null=first; pos && pos!==closestCommonAncestor; pos=pos.parentElement) {	×
144	if (isBlockElement(pos))	×
145	return false;	×
146	}
147	for (let pos: Node\|null=second; pos && pos!==closestCommonAncestor; pos=pos.parentElement) {	×
148	if (isBlockElement(pos))	×
149	return false;	×
150	}
151
152	return true;	×
153	}
154
155	function getClosestCommonAncestor(node1: Node, node2: Node): Node\|null {
156	let pos: Node\|null = node1;	×
157
158	while (pos) {	×
159	if (node2.contains(pos)) {	×
160	return pos;	×
161	}
162	pos = pos.parentNode;	×
163	}
164	return null;	×
165	}
166
167	/**
168	* Returns whether the given node is a block element (ie, an element which can't
169	* be extracted from the DOM and futzed with by inline react hover hihlighting).
170	*/
171	function isBlockElement(node: Node) {
172	if (node.nodeType !== Node.ELEMENT_NODE)	×
173	return false;	×
174	switch ((node as Element).tagName) {	×
175	// This list of tag names was generated by looking at the allowed tag names
176	// in the sanitizer config so it should be reasonably complete
177	case "p": case "div": case 'blockquote':
178	case "li": case "ol": case "ul": case "nl":
179	case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
180	case "table": case "tbody": case "tr": case "td": case "th":
181	case "section":case "iframe":
182	return true;	×
183	default:
184	return false;	×
185	}
186	}
187
188	/**
189	* Given a Range (a browser DOM API), reduce it to the smallest range that
190	* contains the same text. So for example this range:
191	* <p>Paragraph One</p><p>Paragraph Two</p>
192	* ^-----^
193	* would become this range:
194	* <p>Paragraph One</p><p>Paragraph Two</p>
195	* ^-^
196	* The resulting range is guaranteed to have its start and end both be inside
197	* text nodes. If the resulting range would have zero size (ie, it doesn't)
198	* enclose any text), returns null.
199	*/
200	export function reduceRangeToText(range: Range): Range\|null {
201	if (!isClient) {	×
202	throw new Error("This function can only run in the browser");	×
203	}
204
205	let result = range.cloneRange();	×
206
207	// Adjust the start position forwards
208	const startContainer = range.startContainer;	×
209	const startOffset = range.startOffset;	×
210	if (startContainer.nodeType === Node.TEXT_NODE) {	×
211	// Start position is inside a text node
212	// startOffset is the number of characters from the start of this text node
213	// to the range boundary.
214	const textNodeLength = startContainer.textContent?.length ?? 0	×
215	if (textNodeLength === startOffset) {	×
216	// Inside a text node, buf after all of the actual text. Find the next
217	// text node in the tree, and set the position to be the start of that
218	// one rather than the end of this one.
219	const nextTextNode = nextTextNodeAfter(startContainer as Text);	×
220	if (!nextTextNode) return null;	×
221	result.setStart(nextTextNode, 0);	×
222	}
223	} else if (startContainer.nodeType === Node.ELEMENT_NODE) {	×
224	// Start position is inside an element node
225	// Per https://developer.mozilla.org/en-US/docs/Web/API/Range/startOffset,
226	// startOffset is measured in _child nodes_, not characters.
227	// Start by going down the tree until we're at a leaf node. Then if that
228	// node is not a text node, walk forward until we reach a text node, in
229	// which the new start position is offset 0.
230	let pos = startContainer.childNodes[startOffset];	×
231	while (pos.hasChildNodes()) {	×
232	pos = pos.childNodes[0];	×
233	}
234	if (pos.nodeType === Node.TEXT_NODE) {	×
235	result.setStart(pos, 0);	×
236	} else {
237	const nextTextNode = nextTextNodeAfter(pos);	×
238	if (!nextTextNode) return null;	×
239	result.setStart(nextTextNode, 0);	×
240	}
241	}
242
243	// Now adjust the end position backwards. This is very similar to how we do
244	// the start position, except everything goes in the opposite direction.
245	const endContainer = range.endContainer;	×
246	const endOffset = range.endOffset;	×
247	if (endContainer.nodeType === Node.TEXT_NODE) {	×
248	// End position is inside a text node
249	if (endOffset === 0) {	×
250	// Inside a text node, but before all of the actual text. Find the
251	// previous text node in the tree, and set the position to be the end of
252	// that one rather than the start of this one.
253	const prevTextNode = prevTextNodeBefore(endContainer as Text);	×
254	if (!prevTextNode) return null;	×
255	result.setEnd(prevTextNode, prevTextNode.textContent?.length ?? 0);	×
256	}
257	} else {
258	// End position is inside a non-text node
259	let pos = endContainer.childNodes[endOffset];	×
260	while (pos.hasChildNodes()) {	×
261	pos = pos.childNodes[pos.childNodes.length-1];	×
262	}
263	if (pos.nodeType === Node.TEXT_NODE) {	×
264	result.setEnd(pos, pos.textContent?.length ?? 0);	×
265	} else {
266	const prevTextNode = prevTextNodeBefore(pos);	×
267	if (!prevTextNode) return null;	×
268	result.setEnd(prevTextNode, prevTextNode.textContent?.length ?? 0);	×
269	}
270	}
271
272	return result;	×
273	}
274
275	function nextTextNodeAfter(node: Node): Text\|null {
276	let pos: Node\|null = node;	×
277	do {	×
278	pos = nextLeafNodeAfter(pos);	×
279	} while (pos && pos.nodeType !== Node.TEXT_NODE);	×
280	return pos as Text\|null;	×
281	}
282
283	function prevTextNodeBefore(node: Node): Text\|null {
284	let pos: Node\|null = node;	×
285	do {	×
286	pos = prevLeafNodeBefore(pos);	×
287	} while (pos && pos.nodeType !== Node.TEXT_NODE);	×
288	return pos as Text\|null;	×
289	}
290
291	function nextLeafNodeAfter(node: Node): Node\|null {
292	if (node.nextSibling) {	×
293	return firstDescendentOf(node.nextSibling);	×
294	} else {
295	let pos = node;	×
296	while(pos.parentElement) {	×
297	const nextSibling = nextSiblingNodeAfter(pos.parentElement, pos);	×
298	if (nextSibling) {	×
299	return firstDescendentOf(nextSibling);	×
300	}
301	pos = pos.parentElement;	×
302	}
303	}
304	return null;	×
305	}
306
307	function prevLeafNodeBefore(node: Node): Node\|null {
308	if (node.previousSibling) {	×
309	return lastDescendentOf(node.previousSibling);	×
310	} else {
311	let pos = node;	×
312	while(pos.parentElement) {	×
313	const prevSibling = prevSiblingNodeBefore(pos.parentElement, pos);	×
314	if (prevSibling) {	×
315	return lastDescendentOf(prevSibling);	×
316	}
317	pos = pos.parentElement;	×
318	}
319	}
320	return null;	×
321	}
322
323	function firstDescendentOf(node: Node): Node {
324	let pos = node;	×
325	while(pos.hasChildNodes()) {	×
326	pos = pos.childNodes[0];	×
327	}
328	return pos;	×
329	}
330
331	function lastDescendentOf(node: Node): Node {
332	let pos = node;	×
333	while(pos.hasChildNodes()) {	×
334	pos = pos.childNodes[pos.childNodes.length-1];	×
335	}
336	return pos;	×
337	}
338
339	function nextSiblingNodeAfter(parentElement: Element, childNode: Node): Node\|null {
340	let idx = getNodeIndex(parentElement, childNode);	×
341	if (idx === null) {	×
342	return null;	×
343	}
344	if (idx+1 < parentElement.childNodes.length) {	×
345	return parentElement.childNodes[idx+1];	×
346	} else {
347	return null;	×
348	}
349	}
350
351	function prevSiblingNodeBefore(parentElement: Element, childNode: Node): Node\|null {
352	let idx = getNodeIndex(parentElement, childNode);	×
353	if (idx === null) {	×
354	return null;	×
355	}
356	if (idx > 0) {	×
357	return parentElement.childNodes[idx-1];	×
358	} else {
359	return null;	×
360	}
361	}
362
363	function getNodeIndex(parentElement: Element, node: Node): number\|null {
364	const numChildren = parentElement.childNodes.length;	×
365	for (let i=0; i<numChildren; i++) {	×
366	if (parentElement.childNodes[i] === node)	×
367	return i;	×
368	}
369	return null;	×
370	}

ForumMagnum / ForumMagnum / 11684952082

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous