diff --git a/src/runtime/internal/dom.ts b/src/runtime/internal/dom.ts index 556178870b..c1909dafe2 100644 --- a/src/runtime/internal/dom.ts +++ b/src/runtime/internal/dom.ts @@ -36,12 +36,12 @@ function init_hydrate(target: NodeEx) { target.hydrate_init = true; type NodeEx2 = NodeEx & {claim_order: number}; - - // We know that all children have claim_order values since the unclaimed have been detached if target is not head + + // We know that all children have claim_order values since the unclaimed have been detached if target is not let children: ArrayLike = target.childNodes as NodeListOf; - - // If target is head, there may be children without claim_order - if (target.nodeName.toLowerCase() === 'head') { + + // If target is , there may be children without claim_order + if (target.nodeName === 'HEAD') { const myChildren = []; for (let i = 0; i < children.length; i++) { const node = children[i]; @@ -51,8 +51,8 @@ function init_hydrate(target: NodeEx) { } children = myChildren; } - - /* + + /* * Reorder claimed children optimally. * We can reorder claimed children optimally by finding the longest subsequence of * nodes that are already claimed in order and only moving the rest. The longest @@ -84,7 +84,7 @@ function init_hydrate(target: NodeEx) { // upper_bound returns first greater value, so we subtract one // with fast path for when we are on the current longest subsequence const seqLen = ((longest > 0 && children[m[longest]].claim_order <= current) ? longest + 1 : upper_bound(1, longest, idx => children[m[idx]].claim_order, current)) - 1; - + p[i] = m[seqLen] + 1; const newLen = seqLen + 1; @@ -132,12 +132,12 @@ export function append(target: NodeEx, node: NodeEx) { if ((target.actual_end_child === undefined) || ((target.actual_end_child !== null) && (target.actual_end_child.parentElement !== target))) { target.actual_end_child = target.firstChild; } - + // Skip nodes of undefined ordering while ((target.actual_end_child !== null) && (target.actual_end_child.claim_order === undefined)) { target.actual_end_child = target.actual_end_child.nextSibling; } - + if (node !== target.actual_end_child) { // We only insert if the ordering of this node should be modified or the parent node is not target if (node.claim_order !== undefined || node.parentNode !== target) { @@ -335,7 +335,7 @@ function init_claim_info(nodes: ChildNodeArray) { function claim_node(nodes: ChildNodeArray, predicate: (node: ChildNodeEx) => node is R, processNode: (node: ChildNodeEx) => ChildNodeEx | undefined, createNode: () => R, dontUpdateLastIndex: boolean = false) { // Try to find nodes in an order such that we lengthen the longest increasing subsequence init_claim_info(nodes); - + const resultNode = (() => { // We first try to find an element after the previous one for (let i = nodes.claim_info.last_index; i < nodes.length; i++) { @@ -448,7 +448,7 @@ export function claim_html_tag(nodes) { if (start_index === end_index) { return new HtmlTag(); } - + init_claim_info(nodes); const html_tag_nodes = nodes.splice(start_index, end_index + 1); detach(html_tag_nodes[0]); diff --git a/src/runtime/internal/utils.ts b/src/runtime/internal/utils.ts index 4d07ffbac8..9a37261723 100644 --- a/src/runtime/internal/utils.ts +++ b/src/runtime/internal/utils.ts @@ -40,16 +40,14 @@ export function safe_not_equal(a, b) { return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function'); } -const relative_to_absolute : ((url: string) => string) & {anchor?: HTMLAnchorElement} = (url: string) => { - if (relative_to_absolute.anchor === undefined) { - relative_to_absolute.anchor = document.createElement('a'); - } - relative_to_absolute.anchor.href = url; - return relative_to_absolute.anchor.href; -}; +let src_url_equal_anchor; export function src_url_equal(element_src, url) { - return element_src === relative_to_absolute(url); + if (!src_url_equal_anchor) { + src_url_equal_anchor = document.createElement('a'); + } + src_url_equal_anchor.href = url; + return element_src === src_url_equal_anchor.href; } export function not_equal(a, b) {