From 83354b2b88218090988dd6e526b0a2505b57e0f1 Mon Sep 17 00:00:00 2001 From: RaindropsSys Date: Thu, 6 Apr 2023 22:18:28 +0200 Subject: Updated 5 files and added 1110 files (automated) --- .../parse5/dist/tree-adapters/default.d.ts | 85 +++++++ .../parse5/dist/tree-adapters/default.js | 174 ++++++++++++++ .../parse5/dist/tree-adapters/interface.d.ts | 250 +++++++++++++++++++++ .../parse5/dist/tree-adapters/interface.js | 2 + 4 files changed, 511 insertions(+) create mode 100644 includes/external/addressbook/node_modules/parse5/dist/tree-adapters/default.d.ts create mode 100644 includes/external/addressbook/node_modules/parse5/dist/tree-adapters/default.js create mode 100644 includes/external/addressbook/node_modules/parse5/dist/tree-adapters/interface.d.ts create mode 100644 includes/external/addressbook/node_modules/parse5/dist/tree-adapters/interface.js (limited to 'includes/external/addressbook/node_modules/parse5/dist/tree-adapters') diff --git a/includes/external/addressbook/node_modules/parse5/dist/tree-adapters/default.d.ts b/includes/external/addressbook/node_modules/parse5/dist/tree-adapters/default.d.ts new file mode 100644 index 0000000..547d714 --- /dev/null +++ b/includes/external/addressbook/node_modules/parse5/dist/tree-adapters/default.d.ts @@ -0,0 +1,85 @@ +import { DOCUMENT_MODE, type NS } from '../common/html.js'; +import type { Attribute, Location, ElementLocation } from '../common/token.js'; +import type { TreeAdapter, TreeAdapterTypeMap } from './interface.js'; +export interface Document { + /** The name of the node. */ + nodeName: '#document'; + /** + * Document mode. + * + * @see {@link DOCUMENT_MODE} */ + mode: DOCUMENT_MODE; + /** The node's children. */ + childNodes: ChildNode[]; + /** Comment source code location info. Available if location info is enabled. */ + sourceCodeLocation?: Location | null; +} +export interface DocumentFragment { + /** The name of the node. */ + nodeName: '#document-fragment'; + /** The node's children. */ + childNodes: ChildNode[]; + /** Comment source code location info. Available if location info is enabled. */ + sourceCodeLocation?: Location | null; +} +export interface Element { + /** Element tag name. Same as {@link tagName}. */ + nodeName: string; + /** Element tag name. Same as {@link nodeName}. */ + tagName: string; + /** List of element attributes. */ + attrs: Attribute[]; + /** Element namespace. */ + namespaceURI: NS; + /** Element source code location info, with attributes. Available if location info is enabled. */ + sourceCodeLocation?: ElementLocation | null; + /** Parent node. */ + parentNode: ParentNode | null; + /** The node's children. */ + childNodes: ChildNode[]; +} +export interface CommentNode { + /** The name of the node. */ + nodeName: '#comment'; + /** Parent node. */ + parentNode: ParentNode | null; + /** Comment text. */ + data: string; + /** Comment source code location info. Available if location info is enabled. */ + sourceCodeLocation?: Location | null; +} +export interface TextNode { + nodeName: '#text'; + /** Parent node. */ + parentNode: ParentNode | null; + /** Text content. */ + value: string; + /** Comment source code location info. Available if location info is enabled. */ + sourceCodeLocation?: Location | null; +} +export interface Template extends Element { + nodeName: 'template'; + tagName: 'template'; + /** The content of a `template` tag. */ + content: DocumentFragment; +} +export interface DocumentType { + /** The name of the node. */ + nodeName: '#documentType'; + /** Parent node. */ + parentNode: ParentNode | null; + /** Document type name. */ + name: string; + /** Document type public identifier. */ + publicId: string; + /** Document type system identifier. */ + systemId: string; + /** Comment source code location info. Available if location info is enabled. */ + sourceCodeLocation?: Location | null; +} +export type ParentNode = Document | DocumentFragment | Element | Template; +export type ChildNode = Element | Template | CommentNode | TextNode | DocumentType; +export type Node = ParentNode | ChildNode; +export type DefaultTreeAdapterMap = TreeAdapterTypeMap; +export declare const defaultTreeAdapter: TreeAdapter; +//# sourceMappingURL=default.d.ts.map \ No newline at end of file diff --git a/includes/external/addressbook/node_modules/parse5/dist/tree-adapters/default.js b/includes/external/addressbook/node_modules/parse5/dist/tree-adapters/default.js new file mode 100644 index 0000000..9db7d1c --- /dev/null +++ b/includes/external/addressbook/node_modules/parse5/dist/tree-adapters/default.js @@ -0,0 +1,174 @@ +import { DOCUMENT_MODE } from '../common/html.js'; +function createTextNode(value) { + return { + nodeName: '#text', + value, + parentNode: null, + }; +} +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, + }; + }, + //Tree mutation + appendChild(parentNode, newNode) { + parentNode.childNodes.push(newNode); + newNode.parentNode = parentNode; + }, + insertBefore(parentNode, newNode, referenceNode) { + const insertionIdx = parentNode.childNodes.indexOf(referenceNode); + parentNode.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 idx = node.parentNode.childNodes.indexOf(node); + node.parentNode.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, createTextNode(text)); + }, + insertTextBefore(parentNode, text, referenceNode) { + const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1]; + if (prevNode && defaultTreeAdapter.isTextNode(prevNode)) { + prevNode.value += text; + } + else { + defaultTreeAdapter.insertBefore(parentNode, createTextNode(text), referenceNode); + } + }, + adoptAttributes(recipient, attrs) { + const recipientAttrsMap = new Set(recipient.attrs.map((attr) => attr.name)); + for (let j = 0; j < attrs.length; j++) { + if (!recipientAttrsMap.has(attrs[j].name)) { + recipient.attrs.push(attrs[j]); + } + } + }, + //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 }; + }, +}; +//# sourceMappingURL=default.js.map \ No newline at end of file diff --git a/includes/external/addressbook/node_modules/parse5/dist/tree-adapters/interface.d.ts b/includes/external/addressbook/node_modules/parse5/dist/tree-adapters/interface.d.ts new file mode 100644 index 0000000..8de74ee --- /dev/null +++ b/includes/external/addressbook/node_modules/parse5/dist/tree-adapters/interface.d.ts @@ -0,0 +1,250 @@ +import type { DOCUMENT_MODE, NS } from '../common/html.js'; +import type { Attribute, ElementLocation } from '../common/token.js'; +export interface TreeAdapterTypeMap { + node: Node; + parentNode: ParentNode; + childNode: ChildNode; + document: Document; + documentFragment: DocumentFragment; + element: Element; + commentNode: CommentNode; + textNode: TextNode; + template: Template; + documentType: DocumentType; +} +/** + * Tree adapter is a set of utility functions that provides minimal required abstraction layer beetween parser and a specific AST format. + * Note that `TreeAdapter` is not designed to be a general purpose AST manipulation library. You can build such library + * on top of existing `TreeAdapter` or use one of the existing libraries from npm. + * + * @see The default implementation {@link parse5.treeAdapters.default} + */ +export interface TreeAdapter { + /** + * Copies attributes to the given element. Only attributes that are not yet present in the element are copied. + * + * @param recipient - Element to copy attributes into. + * @param attrs - Attributes to copy. + */ + adoptAttributes(recipient: T['element'], attrs: Attribute[]): void; + /** + * Appends a child node to the given parent node. + * + * @param parentNode - Parent node. + * @param newNode - Child node. + */ + appendChild(parentNode: T['parentNode'], newNode: T['childNode']): void; + /** + * Creates a comment node. + * + * @param data - Comment text. + */ + createCommentNode(data: string): T['commentNode']; + /** + * Creates a document node. + */ + createDocument(): T['document']; + /** + * Creates a document fragment node. + */ + createDocumentFragment(): T['documentFragment']; + /** + * Creates an element node. + * + * @param tagName - Tag name of the element. + * @param namespaceURI - Namespace of the element. + * @param attrs - Attribute name-value pair array. Foreign attributes may contain `namespace` and `prefix` fields as well. + */ + createElement(tagName: string, namespaceURI: NS, attrs: Attribute[]): T['element']; + /** + * Removes a node from its parent. + * + * @param node - Node to remove. + */ + detachNode(node: T['childNode']): void; + /** + * Returns the given element's attributes in an array, in the form of name-value pairs. + * Foreign attributes may contain `namespace` and `prefix` fields as well. + * + * @param element - Element. + */ + getAttrList(element: T['element']): Attribute[]; + /** + * Returns the given node's children in an array. + * + * @param node - Node. + */ + getChildNodes(node: T['parentNode']): T['childNode'][]; + /** + * Returns the given comment node's content. + * + * @param commentNode - Comment node. + */ + getCommentNodeContent(commentNode: T['commentNode']): string; + /** + * Returns [document mode](https://dom.spec.whatwg.org/#concept-document-limited-quirks). + * + * @param document - Document node. + */ + getDocumentMode(document: T['document']): DOCUMENT_MODE; + /** + * Returns the given document type node's name. + * + * @param doctypeNode - Document type node. + */ + getDocumentTypeNodeName(doctypeNode: T['documentType']): string; + /** + * Returns the given document type node's public identifier. + * + * @param doctypeNode - Document type node. + */ + getDocumentTypeNodePublicId(doctypeNode: T['documentType']): string; + /** + * Returns the given document type node's system identifier. + * + * @param doctypeNode - Document type node. + */ + getDocumentTypeNodeSystemId(doctypeNode: T['documentType']): string; + /** + * Returns the first child of the given node. + * + * @param node - Node. + */ + getFirstChild(node: T['parentNode']): T['childNode'] | null; + /** + * Returns the given element's namespace. + * + * @param element - Element. + */ + getNamespaceURI(element: T['element']): NS; + /** + * Returns the given node's source code location information. + * + * @param node - Node. + */ + getNodeSourceCodeLocation(node: T['node']): ElementLocation | undefined | null; + /** + * Returns the given node's parent. + * + * @param node - Node. + */ + getParentNode(node: T['node']): T['parentNode'] | null; + /** + * Returns the given element's tag name. + * + * @param element - Element. + */ + getTagName(element: T['element']): string; + /** + * Returns the given text node's content. + * + * @param textNode - Text node. + */ + getTextNodeContent(textNode: T['textNode']): string; + /** + * Returns the `