@playdrop/playdrop-cli 0.12.42 → 0.13.0

package/node_modules/parse5/tokenizer/preprocessor.d.ts

@@ -0,0 +1,36 @@
+import { ERR, type ParserError, type ParserErrorHandler } from '../common/error-codes.js';
+export declare class Preprocessor {
+    private handler;
+    html: string;
+    pos: number;
+    private lastGapPos;
+    private gapStack;
+    private skipNextNewLine;
+    lastChunkWritten: boolean;
+    endOfChunkHit: boolean;
+    bufferWaterline: number;
+    private isEol;
+    private lineStartPos;
+    droppedBufferSize: number;
+    line: number;
+    constructor(handler: {
+        onParseError?: ParserErrorHandler | null;
+    });
+    /** The column on the current line. If we just saw a gap (eg. a surrogate pair), return the index before. */
+    get col(): number;
+    get offset(): number;
+    getError(code: ERR, cpOffset: number): ParserError;
+    private lastErrOffset;
+    private _err;
+    private _addGap;
+    private _processSurrogate;
+    willDropParsedChunk(): boolean;
+    dropParsedChunk(): void;
+    write(chunk: string, isLastChunk: boolean): void;
+    insertHtmlAtCurrentPos(chunk: string): void;
+    startsWith(pattern: string, caseSensitive: boolean): boolean;
+    peek(offset: number): number;
+    advance(): number;
+    private _checkForProblematicCharacters;
+    retreat(count: number): void;
+}

package/node_modules/parse5/tokenizer/preprocessor.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Preprocessor = void 0;
+const unicode_js_1 = require("../common/unicode.js");
+const error_codes_js_1 = require("../common/error-codes.js");
+//Const
+const DEFAULT_BUFFER_WATERLINE = 1 << 16;
+//Preprocessor
+//NOTE: HTML input preprocessing
+//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#preprocessing-the-input-stream)
+class Preprocessor {
+    constructor(handler) {
+        this.handler = handler;
+        this.html = '';
+        this.pos = -1;
+        // NOTE: Initial `lastGapPos` is -2, to ensure `col` on initialisation is 0
+        this.lastGapPos = -2;
+        this.gapStack = [];
+        this.skipNextNewLine = false;
+        this.lastChunkWritten = false;
+        this.endOfChunkHit = false;
+        this.bufferWaterline = DEFAULT_BUFFER_WATERLINE;
+        this.isEol = false;
+        this.lineStartPos = 0;
+        this.droppedBufferSize = 0;
+        this.line = 1;
+        //NOTE: avoid reporting errors twice on advance/retreat
+        this.lastErrOffset = -1;
+    }
+    /** The column on the current line. If we just saw a gap (eg. a surrogate pair), return the index before. */
+    get col() {
+        return this.pos - this.lineStartPos + Number(this.lastGapPos !== this.pos);
+    }
+    get offset() {
+        return this.droppedBufferSize + this.pos;
+    }
+    getError(code, cpOffset) {
+        const { line, col, offset } = this;
+        const startCol = col + cpOffset;
+        const startOffset = offset + cpOffset;
+        return {
+            code,
+            startLine: line,
+            endLine: line,
+            startCol,
+            endCol: startCol,
+            startOffset,
+            endOffset: startOffset,
+        };
+    }
+    _err(code) {
+        if (this.handler.onParseError && this.lastErrOffset !== this.offset) {
+            this.lastErrOffset = this.offset;
+            this.handler.onParseError(this.getError(code, 0));
+        }
+    }
+    _addGap() {
+        this.gapStack.push(this.lastGapPos);
+        this.lastGapPos = this.pos;
+    }
+    _processSurrogate(cp) {
+        //NOTE: try to peek a surrogate pair
+        if (this.pos !== this.html.length - 1) {
+            const nextCp = this.html.charCodeAt(this.pos + 1);
+            if ((0, unicode_js_1.isSurrogatePair)(nextCp)) {
+                //NOTE: we have a surrogate pair. Peek pair character and recalculate code point.
+                this.pos++;
+                //NOTE: add a gap that should be avoided during retreat
+                this._addGap();
+                return (0, unicode_js_1.getSurrogatePairCodePoint)(cp, nextCp);
+            }
+        }
+        //NOTE: we are at the end of a chunk, therefore we can't infer the surrogate pair yet.
+        else if (!this.lastChunkWritten) {
+            this.endOfChunkHit = true;
+            return unicode_js_1.CODE_POINTS.EOF;
+        }
+        //NOTE: isolated surrogate
+        this._err(error_codes_js_1.ERR.surrogateInInputStream);
+        return cp;
+    }
+    willDropParsedChunk() {
+        return this.pos > this.bufferWaterline;
+    }
+    dropParsedChunk() {
+        if (this.willDropParsedChunk()) {
+            this.html = this.html.substring(this.pos);
+            this.lineStartPos -= this.pos;
+            this.droppedBufferSize += this.pos;
+            this.pos = 0;
+            this.lastGapPos = -2;
+            this.gapStack.length = 0;
+        }
+    }
+    write(chunk, isLastChunk) {
+        if (this.html.length > 0) {
+            this.html += chunk;
+        }
+        else {
+            this.html = chunk;
+        }
+        this.endOfChunkHit = false;
+        this.lastChunkWritten = isLastChunk;
+    }
+    insertHtmlAtCurrentPos(chunk) {
+        this.html = this.html.substring(0, this.pos + 1) + chunk + this.html.substring(this.pos + 1);
+        this.endOfChunkHit = false;
+    }
+    startsWith(pattern, caseSensitive) {
+        // Check if our buffer has enough characters
+        if (this.pos + pattern.length > this.html.length) {
+            this.endOfChunkHit = !this.lastChunkWritten;
+            return false;
+        }
+        if (caseSensitive) {
+            return this.html.startsWith(pattern, this.pos);
+        }
+        for (let i = 0; i < pattern.length; i++) {
+            const cp = this.html.charCodeAt(this.pos + i) | 0x20;
+            if (cp !== pattern.charCodeAt(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    peek(offset) {
+        const pos = this.pos + offset;
+        if (pos >= this.html.length) {
+            this.endOfChunkHit = !this.lastChunkWritten;
+            return unicode_js_1.CODE_POINTS.EOF;
+        }
+        const code = this.html.charCodeAt(pos);
+        return code === unicode_js_1.CODE_POINTS.CARRIAGE_RETURN ? unicode_js_1.CODE_POINTS.LINE_FEED : code;
+    }
+    advance() {
+        this.pos++;
+        //NOTE: LF should be in the last column of the line
+        if (this.isEol) {
+            this.isEol = false;
+            this.line++;
+            this.lineStartPos = this.pos;
+        }
+        if (this.pos >= this.html.length) {
+            this.endOfChunkHit = !this.lastChunkWritten;
+            return unicode_js_1.CODE_POINTS.EOF;
+        }
+        let cp = this.html.charCodeAt(this.pos);
+        //NOTE: all U+000D CARRIAGE RETURN (CR) characters must be converted to U+000A LINE FEED (LF) characters
+        if (cp === unicode_js_1.CODE_POINTS.CARRIAGE_RETURN) {
+            this.isEol = true;
+            this.skipNextNewLine = true;
+            return unicode_js_1.CODE_POINTS.LINE_FEED;
+        }
+        //NOTE: any U+000A LINE FEED (LF) characters that immediately follow a U+000D CARRIAGE RETURN (CR) character
+        //must be ignored.
+        if (cp === unicode_js_1.CODE_POINTS.LINE_FEED) {
+            this.isEol = true;
+            if (this.skipNextNewLine) {
+                // `line` will be bumped again in the recursive call.
+                this.line--;
+                this.skipNextNewLine = false;
+                this._addGap();
+                return this.advance();
+            }
+        }
+        this.skipNextNewLine = false;
+        if ((0, unicode_js_1.isSurrogate)(cp)) {
+            cp = this._processSurrogate(cp);
+        }
+        //OPTIMIZATION: first check if code point is in the common allowed
+        //range (ASCII alphanumeric, whitespaces, big chunk of BMP)
+        //before going into detailed performance cost validation.
+        const isCommonValidRange = this.handler.onParseError === null ||
+            (cp > 0x1f && cp < 0x7f) ||
+            cp === unicode_js_1.CODE_POINTS.LINE_FEED ||
+            cp === unicode_js_1.CODE_POINTS.CARRIAGE_RETURN ||
+            (cp > 0x9f && cp < 64976);
+        if (!isCommonValidRange) {
+            this._checkForProblematicCharacters(cp);
+        }
+        return cp;
+    }
+    _checkForProblematicCharacters(cp) {
+        if ((0, unicode_js_1.isControlCodePoint)(cp)) {
+            this._err(error_codes_js_1.ERR.controlCharacterInInputStream);
+        }
+        else if ((0, unicode_js_1.isUndefinedCodePoint)(cp)) {
+            this._err(error_codes_js_1.ERR.noncharacterInInputStream);
+        }
+    }
+    retreat(count) {
+        this.pos -= count;
+        while (this.pos < this.lastGapPos) {
+            this.lastGapPos = this.gapStack.pop();
+            this.pos--;
+        }
+        this.isEol = false;
+    }
+}
+exports.Preprocessor = Preprocessor;

package/node_modules/parse5/tree-adapters/default.d.ts

@@ -0,0 +1,84 @@
+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<Node, ParentNode, ChildNode, Document, DocumentFragment, Element, CommentNode, TextNode, Template, DocumentType>;
+export declare const defaultTreeAdapter: TreeAdapter<DefaultTreeAdapterMap>;

package/node_modules/parse5/tree-adapters/default.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTreeAdapter = void 0;
+const html_js_1 = require("../common/html.js");
+exports.defaultTreeAdapter = {
+    //Node construction
+    createDocument() {
+        return {
+            nodeName: '#document',
+            mode: html_js_1.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 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,
+            };
+            exports.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 (exports.defaultTreeAdapter.isTextNode(prevNode)) {
+                prevNode.value += text;
+                return;
+            }
+        }
+        exports.defaultTreeAdapter.appendChild(parentNode, exports.defaultTreeAdapter.createTextNode(text));
+    },
+    insertTextBefore(parentNode, text, referenceNode) {
+        const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1];
+        if (prevNode && exports.defaultTreeAdapter.isTextNode(prevNode)) {
+            prevNode.value += text;
+        }
+        else {
+            exports.defaultTreeAdapter.insertBefore(parentNode, exports.defaultTreeAdapter.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 = Object.assign(Object.assign({}, node.sourceCodeLocation), endLocation);
+    },
+};