Files
site/node_modules/parse5/dist/tree-adapters/default.js
T
site-admin 3ac81d5a52
deploy / build-and-publish (push) Successful in 1m37s
the editable site (validation-lab)
2026-11-21 08:03:55 +01:00

218 lines
7.6 KiB
JavaScript

import { DOCUMENT_MODE } from '../common/html.js';
/** The position of each name in the attribute lists `adoptAttributes` merged into, kept for the next merge into that list. */
const attrListIndexes = new WeakMap();
export const defaultTreeAdapter = {
//Node construction
createDocument() {
return {
nodeName: '#document',
mode: DOCUMENT_MODE.NO_QUIRKS,
childNodes: [],
};
},
createDocumentFragment() {
return {
nodeName: '#document-fragment',
childNodes: [],
};
},
createElement(tagName, namespaceURI, attrs) {
return {
nodeName: tagName,
tagName,
attrs,
namespaceURI,
childNodes: [],
parentNode: null,
};
},
createCommentNode(data) {
return {
nodeName: '#comment',
data,
parentNode: null,
};
},
createTextNode(value) {
return {
nodeName: '#text',
value,
parentNode: null,
};
},
//Tree mutation
appendChild(parentNode, newNode) {
parentNode.childNodes.push(newNode);
newNode.parentNode = parentNode;
},
insertBefore(parentNode, newNode, referenceNode) {
const { childNodes } = parentNode;
// The reference is usually the last child (fostered content precedes the table), so check that first.
const insertionIdx = childNodes[childNodes.length - 1] === referenceNode
? childNodes.length - 1
: childNodes.indexOf(referenceNode);
childNodes.splice(insertionIdx, 0, newNode);
newNode.parentNode = parentNode;
},
setTemplateContent(templateElement, contentElement) {
templateElement.content = contentElement;
},
getTemplateContent(templateElement) {
return templateElement.content;
},
setDocumentType(document, name, publicId, systemId) {
const doctypeNode = document.childNodes.find((node) => node.nodeName === '#documentType');
if (doctypeNode) {
doctypeNode.name = name;
doctypeNode.publicId = publicId;
doctypeNode.systemId = systemId;
}
else {
const node = {
nodeName: '#documentType',
name,
publicId,
systemId,
parentNode: null,
};
defaultTreeAdapter.appendChild(document, node);
}
},
setDocumentMode(document, mode) {
document.mode = mode;
},
getDocumentMode(document) {
return document.mode;
},
detachNode(node) {
if (node.parentNode) {
const { childNodes } = node.parentNode;
// The parser detaches from the end when it moves children, so check the last child first.
const idx = childNodes[childNodes.length - 1] === node ? childNodes.length - 1 : childNodes.indexOf(node);
childNodes.splice(idx, 1);
node.parentNode = null;
}
},
insertText(parentNode, text) {
if (parentNode.childNodes.length > 0) {
const prevNode = parentNode.childNodes[parentNode.childNodes.length - 1];
if (defaultTreeAdapter.isTextNode(prevNode)) {
prevNode.value += text;
return;
}
}
defaultTreeAdapter.appendChild(parentNode, defaultTreeAdapter.createTextNode(text));
},
insertTextBefore(parentNode, text, referenceNode) {
const { childNodes } = parentNode;
const referenceIdx = childNodes[childNodes.length - 1] === referenceNode
? childNodes.length - 1
: childNodes.indexOf(referenceNode);
const prevNode = childNodes[referenceIdx - 1];
if (prevNode && defaultTreeAdapter.isTextNode(prevNode)) {
prevNode.value += text;
}
else {
defaultTreeAdapter.insertBefore(parentNode, defaultTreeAdapter.createTextNode(text), referenceNode);
}
},
/**
* Keeps the recipient's names between merges as a map from name to position. The map is rebuilt when the list changed
* length or has a repeated name, or when a merged name it holds no longer names the entry at that position. A name that
* other code gives an existing entry between two merges is missed otherwise, and merging it appends it a second time.
*/
adoptAttributes(recipient, attrs) {
// Merging a list into itself adds nothing: every name is already present.
if (attrs.length === 0 || attrs === recipient.attrs)
return;
const cached = attrListIndexes.get(recipient.attrs);
const isIndexed = (cached === null || cached === void 0 ? void 0 : cached.size) === recipient.attrs.length &&
attrs.every(({ name }) => {
var _a;
const index = cached.get(name);
return index === undefined || ((_a = recipient.attrs[index]) === null || _a === void 0 ? void 0 : _a.name) === name;
});
const recipientAttrsMap = isIndexed ? cached : new Map();
if (!isIndexed) {
for (let i = 0; i < recipient.attrs.length; i++) {
const attr = recipient.attrs[i];
// A sparse list is indexed again on every merge, as its size never matches its length.
if (attr !== undefined)
recipientAttrsMap.set(attr.name, i);
}
attrListIndexes.set(recipient.attrs, recipientAttrsMap);
}
const adoptedFrom = recipient.attrs.length;
for (let j = 0; j < attrs.length; j++) {
if (!recipientAttrsMap.has(attrs[j].name)) {
recipient.attrs.push(attrs[j]);
}
}
for (let j = adoptedFrom; j < recipient.attrs.length; j++) {
recipientAttrsMap.set(recipient.attrs[j].name, j);
}
// A list with a repeated name is indexed again on the next merge.
if (recipientAttrsMap.size !== recipient.attrs.length) {
attrListIndexes.delete(recipient.attrs);
}
},
//Tree traversing
getFirstChild(node) {
return node.childNodes[0];
},
getChildNodes(node) {
return node.childNodes;
},
getParentNode(node) {
return node.parentNode;
},
getAttrList(element) {
return element.attrs;
},
//Node data
getTagName(element) {
return element.tagName;
},
getNamespaceURI(element) {
return element.namespaceURI;
},
getTextNodeContent(textNode) {
return textNode.value;
},
getCommentNodeContent(commentNode) {
return commentNode.data;
},
getDocumentTypeNodeName(doctypeNode) {
return doctypeNode.name;
},
getDocumentTypeNodePublicId(doctypeNode) {
return doctypeNode.publicId;
},
getDocumentTypeNodeSystemId(doctypeNode) {
return doctypeNode.systemId;
},
//Node types
isTextNode(node) {
return node.nodeName === '#text';
},
isCommentNode(node) {
return node.nodeName === '#comment';
},
isDocumentTypeNode(node) {
return node.nodeName === '#documentType';
},
isElementNode(node) {
return Object.prototype.hasOwnProperty.call(node, 'tagName');
},
// Source code location
setNodeSourceCodeLocation(node, location) {
node.sourceCodeLocation = location;
},
getNodeSourceCodeLocation(node) {
return node.sourceCodeLocation;
},
updateNodeSourceCodeLocation(node, endLocation) {
node.sourceCodeLocation = { ...node.sourceCodeLocation, ...endLocation };
},
};