@playdrop/playdrop-cli 0.12.41 → 0.13.0

package/node_modules/parse5/common/unicode.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEQUENCES = exports.CODE_POINTS = exports.REPLACEMENT_CHARACTER = void 0;
+exports.isSurrogate = isSurrogate;
+exports.isSurrogatePair = isSurrogatePair;
+exports.getSurrogatePairCodePoint = getSurrogatePairCodePoint;
+exports.isControlCodePoint = isControlCodePoint;
+exports.isUndefinedCodePoint = isUndefinedCodePoint;
+const UNDEFINED_CODE_POINTS = new Set([
+    65534, 65535, 131070, 131071, 196606, 196607, 262142, 262143, 327678, 327679, 393214,
+    393215, 458750, 458751, 524286, 524287, 589822, 589823, 655358, 655359, 720894,
+    720895, 786430, 786431, 851966, 851967, 917502, 917503, 983038, 983039, 1048574,
+    1048575, 1114110, 1114111,
+]);
+exports.REPLACEMENT_CHARACTER = '\uFFFD';
+var CODE_POINTS;
+(function (CODE_POINTS) {
+    CODE_POINTS[CODE_POINTS["EOF"] = -1] = "EOF";
+    CODE_POINTS[CODE_POINTS["NULL"] = 0] = "NULL";
+    CODE_POINTS[CODE_POINTS["TABULATION"] = 9] = "TABULATION";
+    CODE_POINTS[CODE_POINTS["CARRIAGE_RETURN"] = 13] = "CARRIAGE_RETURN";
+    CODE_POINTS[CODE_POINTS["LINE_FEED"] = 10] = "LINE_FEED";
+    CODE_POINTS[CODE_POINTS["FORM_FEED"] = 12] = "FORM_FEED";
+    CODE_POINTS[CODE_POINTS["SPACE"] = 32] = "SPACE";
+    CODE_POINTS[CODE_POINTS["EXCLAMATION_MARK"] = 33] = "EXCLAMATION_MARK";
+    CODE_POINTS[CODE_POINTS["QUOTATION_MARK"] = 34] = "QUOTATION_MARK";
+    CODE_POINTS[CODE_POINTS["AMPERSAND"] = 38] = "AMPERSAND";
+    CODE_POINTS[CODE_POINTS["APOSTROPHE"] = 39] = "APOSTROPHE";
+    CODE_POINTS[CODE_POINTS["HYPHEN_MINUS"] = 45] = "HYPHEN_MINUS";
+    CODE_POINTS[CODE_POINTS["SOLIDUS"] = 47] = "SOLIDUS";
+    CODE_POINTS[CODE_POINTS["DIGIT_0"] = 48] = "DIGIT_0";
+    CODE_POINTS[CODE_POINTS["DIGIT_9"] = 57] = "DIGIT_9";
+    CODE_POINTS[CODE_POINTS["SEMICOLON"] = 59] = "SEMICOLON";
+    CODE_POINTS[CODE_POINTS["LESS_THAN_SIGN"] = 60] = "LESS_THAN_SIGN";
+    CODE_POINTS[CODE_POINTS["EQUALS_SIGN"] = 61] = "EQUALS_SIGN";
+    CODE_POINTS[CODE_POINTS["GREATER_THAN_SIGN"] = 62] = "GREATER_THAN_SIGN";
+    CODE_POINTS[CODE_POINTS["QUESTION_MARK"] = 63] = "QUESTION_MARK";
+    CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_A"] = 65] = "LATIN_CAPITAL_A";
+    CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_Z"] = 90] = "LATIN_CAPITAL_Z";
+    CODE_POINTS[CODE_POINTS["RIGHT_SQUARE_BRACKET"] = 93] = "RIGHT_SQUARE_BRACKET";
+    CODE_POINTS[CODE_POINTS["GRAVE_ACCENT"] = 96] = "GRAVE_ACCENT";
+    CODE_POINTS[CODE_POINTS["LATIN_SMALL_A"] = 97] = "LATIN_SMALL_A";
+    CODE_POINTS[CODE_POINTS["LATIN_SMALL_Z"] = 122] = "LATIN_SMALL_Z";
+})(CODE_POINTS || (exports.CODE_POINTS = CODE_POINTS = {}));
+exports.SEQUENCES = {
+    DASH_DASH: '--',
+    CDATA_START: '[CDATA[',
+    DOCTYPE: 'doctype',
+    SCRIPT: 'script',
+    PUBLIC: 'public',
+    SYSTEM: 'system',
+};
+//Surrogates
+function isSurrogate(cp) {
+    return cp >= 55296 && cp <= 57343;
+}
+function isSurrogatePair(cp) {
+    return cp >= 56320 && cp <= 57343;
+}
+function getSurrogatePairCodePoint(cp1, cp2) {
+    return (cp1 - 55296) * 1024 + 9216 + cp2;
+}
+//NOTE: excluding NULL and ASCII whitespace
+function isControlCodePoint(cp) {
+    return ((cp !== 0x20 && cp !== 0x0a && cp !== 0x0d && cp !== 0x09 && cp !== 0x0c && cp >= 0x01 && cp <= 0x1f) ||
+        (cp >= 0x7f && cp <= 0x9f));
+}
+function isUndefinedCodePoint(cp) {
+    return (cp >= 64976 && cp <= 65007) || UNDEFINED_CODE_POINTS.has(cp);
+}

package/node_modules/parse5/index.d.ts

@@ -0,0 +1,71 @@
+import { type ParserOptions } from './parser/index.js';
+import type { DefaultTreeAdapterMap } from './tree-adapters/default.js';
+import type { TreeAdapterTypeMap } from './tree-adapters/interface.js';
+export { type DefaultTreeAdapterMap, defaultTreeAdapter } from './tree-adapters/default.js';
+import type * as DefaultTreeAdapter from './tree-adapters/default.js';
+export declare namespace DefaultTreeAdapterTypes {
+    type Document = DefaultTreeAdapter.Document;
+    type DocumentFragment = DefaultTreeAdapter.DocumentFragment;
+    type Element = DefaultTreeAdapter.Element;
+    type CommentNode = DefaultTreeAdapter.CommentNode;
+    type TextNode = DefaultTreeAdapter.TextNode;
+    type Template = DefaultTreeAdapter.Template;
+    type DocumentType = DefaultTreeAdapter.DocumentType;
+    type ParentNode = DefaultTreeAdapter.ParentNode;
+    type ChildNode = DefaultTreeAdapter.ChildNode;
+    type Node = DefaultTreeAdapter.Node;
+    type DefaultTreeAdapterMap = DefaultTreeAdapter.DefaultTreeAdapterMap;
+}
+export type { TreeAdapter, TreeAdapterTypeMap } from './tree-adapters/interface.js';
+export { type ParserOptions, /** @internal */ Parser } from './parser/index.js';
+export { serialize, serializeOuter, type SerializerOptions } from './serializer/index.js';
+export { ERR as ErrorCodes, type ParserError, type ParserErrorHandler } from './common/error-codes.js';
+/** @internal */
+export * as foreignContent from './common/foreign-content.js';
+export * as html from './common/html.js';
+export * as Token from './common/token.js';
+/** @internal */
+export { Tokenizer, type TokenizerOptions, TokenizerMode, type TokenHandler } from './tokenizer/index.js';
+/**
+ * Parses an HTML string.
+ *
+ * @param html Input HTML string.
+ * @param options Parsing options.
+ * @returns Document
+ *
+ * @example
+ *
+ * ```js
+ * const parse5 = require('parse5');
+ *
+ * const document = parse5.parse('<!DOCTYPE html><html><head></head><body>Hi there!</body></html>');
+ *
+ * console.log(document.childNodes[1].tagName); //> 'html'
+ *```
+ */
+export declare function parse<T extends TreeAdapterTypeMap = DefaultTreeAdapterMap>(html: string, options?: ParserOptions<T>): T['document'];
+/**
+ * Parses an HTML fragment.
+ *
+ * @example
+ *
+ * ```js
+ * const parse5 = require('parse5');
+ *
+ * const documentFragment = parse5.parseFragment('<table></table>');
+ *
+ * console.log(documentFragment.childNodes[0].tagName); //> 'table'
+ *
+ * // Parses the html fragment in the context of the parsed <table> element.
+ * const trFragment = parse5.parseFragment(documentFragment.childNodes[0], '<tr><td>Shake it, baby</td></tr>');
+ *
+ * console.log(trFragment.childNodes[0].childNodes[0].tagName); //> 'td'
+ * ```
+ *
+ * @param fragmentContext Parsing context element. If specified, given fragment will be parsed as if it was set to the context element's `innerHTML` property.
+ * @param html Input HTML fragment string.
+ * @param options Parsing options.
+ * @returns DocumentFragment
+ */
+export declare function parseFragment<T extends TreeAdapterTypeMap = DefaultTreeAdapterMap>(fragmentContext: T['parentNode'] | null, html: string, options: ParserOptions<T>): T['documentFragment'];
+export declare function parseFragment<T extends TreeAdapterTypeMap = DefaultTreeAdapterMap>(html: string, options?: ParserOptions<T>): T['documentFragment'];

package/node_modules/parse5/index.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenizerMode = exports.Tokenizer = exports.Token = exports.html = exports.foreignContent = exports.ErrorCodes = exports.serializeOuter = exports.serialize = exports.Parser = exports.defaultTreeAdapter = void 0;
+exports.parse = parse;
+exports.parseFragment = parseFragment;
+const index_js_1 = require("./parser/index.js");
+var default_js_1 = require("./tree-adapters/default.js");
+Object.defineProperty(exports, "defaultTreeAdapter", { enumerable: true, get: function () { return default_js_1.defaultTreeAdapter; } });
+var index_js_2 = require("./parser/index.js");
+Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return index_js_2.Parser; } });
+var index_js_3 = require("./serializer/index.js");
+Object.defineProperty(exports, "serialize", { enumerable: true, get: function () { return index_js_3.serialize; } });
+Object.defineProperty(exports, "serializeOuter", { enumerable: true, get: function () { return index_js_3.serializeOuter; } });
+var error_codes_js_1 = require("./common/error-codes.js");
+Object.defineProperty(exports, "ErrorCodes", { enumerable: true, get: function () { return error_codes_js_1.ERR; } });
+/** @internal */
+exports.foreignContent = require("./common/foreign-content.js");
+exports.html = require("./common/html.js");
+exports.Token = require("./common/token.js");
+/** @internal */
+var index_js_4 = require("./tokenizer/index.js");
+Object.defineProperty(exports, "Tokenizer", { enumerable: true, get: function () { return index_js_4.Tokenizer; } });
+Object.defineProperty(exports, "TokenizerMode", { enumerable: true, get: function () { return index_js_4.TokenizerMode; } });
+// Shorthands
+/**
+ * Parses an HTML string.
+ *
+ * @param html Input HTML string.
+ * @param options Parsing options.
+ * @returns Document
+ *
+ * @example
+ *
+ * ```js
+ * const parse5 = require('parse5');
+ *
+ * const document = parse5.parse('<!DOCTYPE html><html><head></head><body>Hi there!</body></html>');
+ *
+ * console.log(document.childNodes[1].tagName); //> 'html'
+ *```
+ */
+function parse(html, options) {
+    return index_js_1.Parser.parse(html, options);
+}
+function parseFragment(fragmentContext, html, options) {
+    if (typeof fragmentContext === 'string') {
+        options = html;
+        html = fragmentContext;
+        fragmentContext = null;
+    }
+    const parser = index_js_1.Parser.getFragmentParser(fragmentContext, options);
+    parser.tokenizer.write(html, true);
+    return parser.getFragment();
+}

package/node_modules/parse5/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/node_modules/parse5/parser/formatting-element-list.d.ts

@@ -0,0 +1,36 @@
+import type { TagToken } from '../common/token.js';
+import type { TreeAdapter, TreeAdapterTypeMap } from '../tree-adapters/interface.js';
+export declare enum EntryType {
+    Marker = 0,
+    Element = 1
+}
+interface MarkerEntry {
+    type: EntryType.Marker;
+}
+export interface ElementEntry<T extends TreeAdapterTypeMap> {
+    type: EntryType.Element;
+    element: T['element'];
+    token: TagToken;
+}
+export type Entry<T extends TreeAdapterTypeMap> = MarkerEntry | ElementEntry<T>;
+export declare class FormattingElementList<T extends TreeAdapterTypeMap> {
+    private treeAdapter;
+    entries: Entry<T>[];
+    bookmark: Entry<T> | null;
+    constructor(treeAdapter: TreeAdapter<T>);
+    private _getNoahArkConditionCandidates;
+    private _ensureNoahArkCondition;
+    insertMarker(): void;
+    pushElement(element: T['element'], token: TagToken): void;
+    insertElementAfterBookmark(element: T['element'], token: TagToken): void;
+    removeEntry(entry: Entry<T>): void;
+    /**
+     * Clears the list of formatting elements up to the last marker.
+     *
+     * @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-list-of-active-formatting-elements-up-to-the-last-marker
+     */
+    clearToLastMarker(): void;
+    getElementEntryInScopeWithTagName(tagName: string): ElementEntry<T> | null;
+    getElementEntry(element: T['element']): ElementEntry<T> | undefined;
+}
+export {};

package/node_modules/parse5/parser/formatting-element-list.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormattingElementList = exports.EntryType = void 0;
+//Const
+const NOAH_ARK_CAPACITY = 3;
+var EntryType;
+(function (EntryType) {
+    EntryType[EntryType["Marker"] = 0] = "Marker";
+    EntryType[EntryType["Element"] = 1] = "Element";
+})(EntryType || (exports.EntryType = EntryType = {}));
+const MARKER = { type: EntryType.Marker };
+//List of formatting elements
+class FormattingElementList {
+    constructor(treeAdapter) {
+        this.treeAdapter = treeAdapter;
+        this.entries = [];
+        this.bookmark = null;
+    }
+    //Noah Ark's condition
+    //OPTIMIZATION: at first we try to find possible candidates for exclusion using
+    //lightweight heuristics without thorough attributes check.
+    _getNoahArkConditionCandidates(newElement, neAttrs) {
+        const candidates = [];
+        const neAttrsLength = neAttrs.length;
+        const neTagName = this.treeAdapter.getTagName(newElement);
+        const neNamespaceURI = this.treeAdapter.getNamespaceURI(newElement);
+        for (let i = 0; i < this.entries.length; i++) {
+            const entry = this.entries[i];
+            if (entry.type === EntryType.Marker) {
+                break;
+            }
+            const { element } = entry;
+            if (this.treeAdapter.getTagName(element) === neTagName &&
+                this.treeAdapter.getNamespaceURI(element) === neNamespaceURI) {
+                const elementAttrs = this.treeAdapter.getAttrList(element);
+                if (elementAttrs.length === neAttrsLength) {
+                    candidates.push({ idx: i, attrs: elementAttrs });
+                }
+            }
+        }
+        return candidates;
+    }
+    _ensureNoahArkCondition(newElement) {
+        if (this.entries.length < NOAH_ARK_CAPACITY)
+            return;
+        const neAttrs = this.treeAdapter.getAttrList(newElement);
+        const candidates = this._getNoahArkConditionCandidates(newElement, neAttrs);
+        if (candidates.length < NOAH_ARK_CAPACITY)
+            return;
+        //NOTE: build attrs map for the new element, so we can perform fast lookups
+        const neAttrsMap = new Map(neAttrs.map((neAttr) => [neAttr.name, neAttr.value]));
+        let validCandidates = 0;
+        //NOTE: remove bottommost candidates, until Noah's Ark condition will not be met
+        for (let i = 0; i < candidates.length; i++) {
+            const candidate = candidates[i];
+            // We know that `candidate.attrs.length === neAttrs.length`
+            if (candidate.attrs.every((cAttr) => neAttrsMap.get(cAttr.name) === cAttr.value)) {
+                validCandidates += 1;
+                if (validCandidates >= NOAH_ARK_CAPACITY) {
+                    this.entries.splice(candidate.idx, 1);
+                }
+            }
+        }
+    }
+    //Mutations
+    insertMarker() {
+        this.entries.unshift(MARKER);
+    }
+    pushElement(element, token) {
+        this._ensureNoahArkCondition(element);
+        this.entries.unshift({
+            type: EntryType.Element,
+            element,
+            token,
+        });
+    }
+    insertElementAfterBookmark(element, token) {
+        const bookmarkIdx = this.entries.indexOf(this.bookmark);
+        this.entries.splice(bookmarkIdx, 0, {
+            type: EntryType.Element,
+            element,
+            token,
+        });
+    }
+    removeEntry(entry) {
+        const entryIndex = this.entries.indexOf(entry);
+        if (entryIndex !== -1) {
+            this.entries.splice(entryIndex, 1);
+        }
+    }
+    /**
+     * Clears the list of formatting elements up to the last marker.
+     *
+     * @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-list-of-active-formatting-elements-up-to-the-last-marker
+     */
+    clearToLastMarker() {
+        const markerIdx = this.entries.indexOf(MARKER);
+        if (markerIdx === -1) {
+            this.entries.length = 0;
+        }
+        else {
+            this.entries.splice(0, markerIdx + 1);
+        }
+    }
+    //Search
+    getElementEntryInScopeWithTagName(tagName) {
+        const entry = this.entries.find((entry) => entry.type === EntryType.Marker || this.treeAdapter.getTagName(entry.element) === tagName);
+        return entry && entry.type === EntryType.Element ? entry : null;
+    }
+    getElementEntry(element) {
+        return this.entries.find((entry) => entry.type === EntryType.Element && entry.element === element);
+    }
+}
+exports.FormattingElementList = FormattingElementList;

package/node_modules/parse5/parser/index.d.ts

@@ -0,0 +1,221 @@
+import { Tokenizer, TokenizerMode, type TokenHandler } from '../tokenizer/index.js';
+import { OpenElementStack, type StackHandler } from './open-element-stack.js';
+import { FormattingElementList } from './formatting-element-list.js';
+import { ERR, type ParserErrorHandler } from '../common/error-codes.js';
+import { TAG_ID as $, NS } from '../common/html.js';
+import type { TreeAdapter, TreeAdapterTypeMap } from '../tree-adapters/interface.js';
+import { type Token, type CommentToken, type CharacterToken, type TagToken, type DoctypeToken, type EOFToken, type LocationWithAttributes } from '../common/token.js';
+declare enum InsertionMode {
+    INITIAL = 0,
+    BEFORE_HTML = 1,
+    BEFORE_HEAD = 2,
+    IN_HEAD = 3,
+    IN_HEAD_NO_SCRIPT = 4,
+    AFTER_HEAD = 5,
+    IN_BODY = 6,
+    TEXT = 7,
+    IN_TABLE = 8,
+    IN_TABLE_TEXT = 9,
+    IN_CAPTION = 10,
+    IN_COLUMN_GROUP = 11,
+    IN_TABLE_BODY = 12,
+    IN_ROW = 13,
+    IN_CELL = 14,
+    IN_SELECT = 15,
+    IN_SELECT_IN_TABLE = 16,
+    IN_TEMPLATE = 17,
+    AFTER_BODY = 18,
+    IN_FRAMESET = 19,
+    AFTER_FRAMESET = 20,
+    AFTER_AFTER_BODY = 21,
+    AFTER_AFTER_FRAMESET = 22
+}
+export interface ParserOptions<T extends TreeAdapterTypeMap> {
+    /**
+     * The [scripting flag](https://html.spec.whatwg.org/multipage/parsing.html#scripting-flag). If set
+     * to `true`, `noscript` element content will be parsed as text.
+     *
+     *  @default `true`
+     */
+    scriptingEnabled?: boolean;
+    /**
+     * Enables source code location information. When enabled, each node (except the root node)
+     * will have a `sourceCodeLocation` property. If the node is not an empty element, `sourceCodeLocation` will
+     * be a {@link ElementLocation} object, otherwise it will be {@link Location}.
+     * If the element was implicitly created by the parser (as part of
+     * [tree correction](https://html.spec.whatwg.org/multipage/syntax.html#an-introduction-to-error-handling-and-strange-cases-in-the-parser)),
+     * its `sourceCodeLocation` property will be `undefined`.
+     *
+     * @default `false`
+     */
+    sourceCodeLocationInfo?: boolean;
+    /**
+     * Specifies the resulting tree format.
+     *
+     * @default `treeAdapters.default`
+     */
+    treeAdapter?: TreeAdapter<T>;
+    /**
+     * Callback for parse errors.
+     *
+     * @default `null`
+     */
+    onParseError?: ParserErrorHandler | null;
+}
+export declare class Parser<T extends TreeAdapterTypeMap> implements TokenHandler, StackHandler<T> {
+    /** @internal */
+    fragmentContext: T['element'] | null;
+    /** @internal */
+    scriptHandler: null | ((pendingScript: T['element']) => void);
+    treeAdapter: TreeAdapter<T>;
+    /** @internal */
+    onParseError: ParserErrorHandler | null;
+    protected currentToken: Token | null;
+    options: Required<ParserOptions<T>>;
+    document: T['document'];
+    constructor(options?: ParserOptions<T>, document?: T['document'], 
+    /** @internal */
+    fragmentContext?: T['element'] | null, 
+    /** @internal */
+    scriptHandler?: null | ((pendingScript: T['element']) => void));
+    static parse<T extends TreeAdapterTypeMap>(html: string, options?: ParserOptions<T>): T['document'];
+    static getFragmentParser<T extends TreeAdapterTypeMap>(fragmentContext?: T['parentNode'] | null, options?: ParserOptions<T>): Parser<T>;
+    getFragment(): T['documentFragment'];
+    tokenizer: Tokenizer;
+    stopped: boolean;
+    /** @internal */
+    insertionMode: InsertionMode;
+    /** @internal */
+    originalInsertionMode: InsertionMode;
+    /** @internal */
+    fragmentContextID: $;
+    /** @internal */
+    headElement: null | T['element'];
+    /** @internal */
+    formElement: null | T['element'];
+    /** @internal */
+    openElements: OpenElementStack<T>;
+    /** @internal */
+    activeFormattingElements: FormattingElementList<T>;
+    /** Indicates that the current node is not an element in the HTML namespace */
+    protected currentNotInHTML: boolean;
+    /**
+     * The template insertion mode stack is maintained from the left.
+     * Ie. the topmost element will always have index 0.
+     *
+     * @internal
+     */
+    tmplInsertionModeStack: InsertionMode[];
+    /** @internal */
+    pendingCharacterTokens: CharacterToken[];
+    /** @internal */
+    hasNonWhitespacePendingCharacterToken: boolean;
+    /** @internal */
+    framesetOk: boolean;
+    /** @internal */
+    skipNextNewLine: boolean;
+    /** @internal */
+    fosterParentingEnabled: boolean;
+    /** @internal */
+    _err(token: Token, code: ERR, beforeToken?: boolean): void;
+    /** @internal */
+    onItemPush(node: T['parentNode'], tid: number, isTop: boolean): void;
+    /** @internal */
+    onItemPop(node: T['parentNode'], isTop: boolean): void;
+    protected _setContextModes(current: T['parentNode'] | undefined, tid: number | undefined): void;
+    /** @protected */
+    _switchToTextParsing(currentToken: TagToken, nextTokenizerState: (typeof TokenizerMode)[keyof typeof TokenizerMode]): void;
+    switchToPlaintextParsing(): void;
+    /** @protected */
+    _getAdjustedCurrentElement(): T['element'];
+    /** @protected */
+    _findFormInFragmentContext(): void;
+    protected _initTokenizerForFragmentParsing(): void;
+    /** @protected */
+    _setDocumentType(token: DoctypeToken): void;
+    /** @protected */
+    _attachElementToTree(element: T['element'], location: LocationWithAttributes | null): void;
+    /**
+     * For self-closing tags. Add an element to the tree, but skip adding it
+     * to the stack.
+     */
+    /** @protected */
+    _appendElement(token: TagToken, namespaceURI: NS): void;
+    /** @protected */
+    _insertElement(token: TagToken, namespaceURI: NS): void;
+    /** @protected */
+    _insertFakeElement(tagName: string, tagID: $): void;
+    /** @protected */
+    _insertTemplate(token: TagToken): void;
+    /** @protected */
+    _insertFakeRootElement(): void;
+    /** @protected */
+    _appendCommentNode(token: CommentToken, parent: T['parentNode']): void;
+    /** @protected */
+    _insertCharacters(token: CharacterToken): void;
+    /** @protected */
+    _adoptNodes(donor: T['parentNode'], recipient: T['parentNode']): void;
+    /** @protected */
+    _setEndLocation(element: T['element'], closingToken: Token): void;
+    protected shouldProcessStartTagTokenInForeignContent(token: TagToken): boolean;
+    /** @protected */
+    _processToken(token: Token): void;
+    /** @protected */
+    _isIntegrationPoint(tid: $, element: T['element'], foreignNS?: NS): boolean;
+    /** @protected */
+    _reconstructActiveFormattingElements(): void;
+    /** @protected */
+    _closeTableCell(): void;
+    /** @protected */
+    _closePElement(): void;
+    /** @protected */
+    _resetInsertionMode(): void;
+    /** @protected */
+    _resetInsertionModeForSelect(selectIdx: number): void;
+    /** @protected */
+    _isElementCausesFosterParenting(tn: $): boolean;
+    /** @protected */
+    _shouldFosterParentOnInsertion(): boolean;
+    /** @protected */
+    _findFosterParentingLocation(): {
+        parent: T['parentNode'];
+        beforeElement: T['element'] | null;
+    };
+    /** @protected */
+    _fosterParentElement(element: T['element']): void;
+    /** @protected */
+    _isSpecialElement(element: T['element'], id: $): boolean;
+    /** @internal */
+    onCharacter(token: CharacterToken): void;
+    /** @internal */
+    onNullCharacter(token: CharacterToken): void;
+    /** @internal */
+    onComment(token: CommentToken): void;
+    /** @internal */
+    onDoctype(token: DoctypeToken): void;
+    /** @internal */
+    onStartTag(token: TagToken): void;
+    /**
+     * Processes a given start tag.
+     *
+     * `onStartTag` checks if a self-closing tag was recognized. When a token
+     * is moved inbetween multiple insertion modes, this check for self-closing
+     * could lead to false positives. To avoid this, `_processStartTag` is used
+     * for nested calls.
+     *
+     * @param token The token to process.
+     * @protected
+     */
+    _processStartTag(token: TagToken): void;
+    /** @protected */
+    _startTagOutsideForeignContent(token: TagToken): void;
+    /** @internal */
+    onEndTag(token: TagToken): void;
+    /** @protected */
+    _endTagOutsideForeignContent(token: TagToken): void;
+    /** @internal */
+    onEof(token: EOFToken): void;
+    /** @internal */
+    onWhitespaceCharacter(token: CharacterToken): void;
+}
+export {};