@mtkruto/node 0.1.702 → 0.1.706

package/script/deps/deno.land/x/html_parser@v0.1.3/src/DomHandler.d.ts

@@ -0,0 +1,84 @@
+import { Node, Element, Document, NodeWithChildren, DataNode } from './Node.js';
+export interface DomHandlerOptions {
+    /**
+     * Add a `startIndex` property to nodes.
+     * When the parser is used in a non-streaming fashion, `startIndex` is an integer
+     * indicating the position of the start of the node in the document.
+     *
+     * @default false
+     */
+    withStartIndices?: boolean;
+    /**
+     * Add an `endIndex` property to nodes.
+     * When the parser is used in a non-streaming fashion, `endIndex` is an integer
+     * indicating the position of the end of the node in the document.
+     *
+     * @default false
+     */
+    withEndIndices?: boolean;
+    /**
+     * Replace all whitespace with single spaces.
+     *
+     * **Note:** Enabling this might break your markup.
+     *
+     * @default false
+     * @deprecated
+     */
+    normalizeWhitespace?: boolean;
+    /**
+     * Treat the markup as XML.
+     *
+     * @default false
+     */
+    xmlMode?: boolean;
+}
+interface ParserInterface {
+    startIndex: number | null;
+    endIndex: number | null;
+}
+type Callback = (error: Error | null, dom: Node[]) => void;
+type ElementCallback = (element: Element) => void;
+export declare class DomHandler {
+    /** The elements of the DOM */
+    dom: Node[];
+    /** The root element for the DOM */
+    root: Document;
+    /** Called once parsing has completed. */
+    private readonly callback;
+    /** Settings for the handler. */
+    private readonly options;
+    /** Callback whenever a tag is closed. */
+    private readonly elementCB;
+    /** Indicated whether parsing has been completed. */
+    private done;
+    /** Stack of open tags. */
+    protected tagStack: NodeWithChildren[];
+    /** A data node that is still being written to. */
+    protected lastNode: DataNode | null;
+    /** Reference to the parser instance. Used for location information. */
+    private parser;
+    /**
+     * @param callback Called once parsing has completed.
+     * @param options Settings for the handler.
+     * @param elementCB Callback whenever a tag is closed.
+     */
+    constructor(callback?: Callback | null, options?: DomHandlerOptions | null, elementCB?: ElementCallback);
+    onparserinit(parser: ParserInterface): void;
+    onreset(): void;
+    onend(): void;
+    onerror(error: Error): void;
+    onclosetag(): void;
+    onopentag(name: string, attribs: {
+        [key: string]: string;
+    }): void;
+    ontext(data: string): void;
+    oncomment(data: string): void;
+    oncommentend(): void;
+    oncdatastart(): void;
+    oncdataend(): void;
+    onprocessinginstruction(name: string, data: string): void;
+    protected handleCallback(error: Error | null): void;
+    protected addNode(node: Node): void;
+}
+export default DomHandler;
+//# sourceMappingURL=DomHandler.d.ts.map

package/script/deps/deno.land/x/html_parser@v0.1.3/src/DomHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomHandler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/deno.land/x/html_parser@v0.1.3/src/DomHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,IAAI,EACJ,OAAO,EACP,QAAQ,EACR,gBAAgB,EAChB,QAAQ,EAIX,MAAM,WAAW,CAAA;AAKlB,MAAM,WAAW,iBAAiB;IAC9B;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAE1B;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;IAExB;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAE7B;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CACpB;AASD,UAAU,eAAe;IACrB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1B;AAED,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,IAAI,CAAA;AAC1D,KAAK,eAAe,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;AAEjD,qBAAa,UAAU;IACnB,8BAA8B;IACvB,GAAG,EAAE,IAAI,EAAE,CAAK;IAEvB,mCAAmC;IAC5B,IAAI,WAAyB;IAEpC,yCAAyC;IACzC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAE1C,gCAAgC;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAE3C,yCAAyC;IACzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAElD,oDAAoD;IACpD,OAAO,CAAC,IAAI,CAAQ;IAEpB,0BAA0B;IAC1B,SAAS,CAAC,QAAQ,EAAE,gBAAgB,EAAE,CAAc;IAEpD,kDAAkD;IAClD,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAO;IAE1C,uEAAuE;IACvE,OAAO,CAAC,MAAM,CAA+B;IAE7C;;;;OAIG;gBAEC,QAAQ,CAAC,EAAE,QAAQ,GAAG,IAAI,EAC1B,OAAO,CAAC,EAAE,iBAAiB,GAAG,IAAI,EAClC,SAAS,CAAC,EAAE,eAAe;IAiBxB,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI;IAK3C,OAAO,IAAI,IAAI;IAUf,KAAK,IAAI,IAAI;IAOb,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAI3B,UAAU,IAAI,IAAI;IAYlB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,GAAG,IAAI;IAOjE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAwB1B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAW7B,YAAY,IAAI,IAAI;IAIpB,YAAY,IAAI,IAAI;IAUpB,UAAU,IAAI,IAAI;IAIlB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAKhE,SAAS,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,GAAG,IAAI;IAQnD,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;CAwBtC;AAED,eAAe,UAAU,CAAA"}

package/script/deps/deno.land/x/html_parser@v0.1.3/src/DomHandler.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DomHandler = void 0;
+const Node_js_1 = require("./Node.js");
+const ElementType_js_1 = require("./ElementType.js");
+const reWhitespace = /\s+/g;
+// Default options
+const defaultOpts = {
+    normalizeWhitespace: false,
+    withStartIndices: false,
+    withEndIndices: false,
+};
+class DomHandler {
+    /**
+     * @param callback Called once parsing has completed.
+     * @param options Settings for the handler.
+     * @param elementCB Callback whenever a tag is closed.
+     */
+    constructor(callback, options, elementCB) {
+        /** The elements of the DOM */
+        Object.defineProperty(this, "dom", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        /** The root element for the DOM */
+        Object.defineProperty(this, "root", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Node_js_1.Document(this.dom)
+        });
+        /** Called once parsing has completed. */
+        Object.defineProperty(this, "callback", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Settings for the handler. */
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Callback whenever a tag is closed. */
+        Object.defineProperty(this, "elementCB", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Indicated whether parsing has been completed. */
+        Object.defineProperty(this, "done", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** Stack of open tags. */
+        Object.defineProperty(this, "tagStack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: [this.root]
+        });
+        /** A data node that is still being written to. */
+        Object.defineProperty(this, "lastNode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** Reference to the parser instance. Used for location information. */
+        Object.defineProperty(this, "parser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // Make it possible to skip arguments, for backwards-compatibility
+        if (typeof options === 'function') {
+            elementCB = options;
+            options = defaultOpts;
+        }
+        if (typeof callback === 'object') {
+            options = callback;
+            callback = undefined;
+        }
+        this.callback = callback ?? null;
+        this.options = options ?? defaultOpts;
+        this.elementCB = elementCB ?? null;
+    }
+    onparserinit(parser) {
+        this.parser = parser;
+    }
+    // Resets the handler back to starting state
+    onreset() {
+        this.dom = [];
+        this.root = new Node_js_1.Document(this.dom);
+        this.done = false;
+        this.tagStack = [this.root];
+        this.lastNode = null;
+        this.parser = this.parser ?? null;
+    }
+    // Signals the handler that parsing is done
+    onend() {
+        if (this.done)
+            return;
+        this.done = true;
+        this.parser = null;
+        this.handleCallback(null);
+    }
+    onerror(error) {
+        this.handleCallback(error);
+    }
+    onclosetag() {
+        this.lastNode = null;
+        const elem = this.tagStack.pop();
+        if (this.options.withEndIndices) {
+            elem.endIndex = this.parser.endIndex;
+        }
+        if (this.elementCB)
+            this.elementCB(elem);
+    }
+    onopentag(name, attribs) {
+        const type = this.options.xmlMode ? ElementType_js_1.ElementType.Tag : undefined;
+        const element = new Node_js_1.Element(name, attribs, undefined, type);
+        this.addNode(element);
+        this.tagStack.push(element);
+    }
+    ontext(data) {
+        const { normalizeWhitespace } = this.options;
+        const { lastNode } = this;
+        if (lastNode && lastNode.type === ElementType_js_1.ElementType.Text) {
+            if (normalizeWhitespace) {
+                lastNode.data = (lastNode.data + data).replace(reWhitespace, ' ');
+            }
+            else {
+                lastNode.data += data;
+            }
+        }
+        else {
+            if (normalizeWhitespace) {
+                data = data.replace(reWhitespace, ' ');
+            }
+            const node = new Node_js_1.Text(data);
+            this.addNode(node);
+            this.lastNode = node;
+        }
+    }
+    oncomment(data) {
+        if (this.lastNode && this.lastNode.type === ElementType_js_1.ElementType.Comment) {
+            this.lastNode.data += data;
+            return;
+        }
+        const node = new Node_js_1.Comment(data);
+        this.addNode(node);
+        this.lastNode = node;
+    }
+    oncommentend() {
+        this.lastNode = null;
+    }
+    oncdatastart() {
+        const text = new Node_js_1.Text('');
+        const node = new Node_js_1.NodeWithChildren(ElementType_js_1.ElementType.CDATA, [text]);
+        this.addNode(node);
+        text.parent = node;
+        this.lastNode = text;
+    }
+    oncdataend() {
+        this.lastNode = null;
+    }
+    onprocessinginstruction(name, data) {
+        const node = new Node_js_1.ProcessingInstruction(name, data);
+        this.addNode(node);
+    }
+    handleCallback(error) {
+        if (typeof this.callback === 'function') {
+            this.callback(error, this.dom);
+        }
+        else if (error) {
+            throw error;
+        }
+    }
+    addNode(node) {
+        const parent = this.tagStack[this.tagStack.length - 1];
+        const previousSibling = parent.children[parent.children.length - 1];
+        if (this.options.withStartIndices) {
+            node.startIndex = this.parser.startIndex;
+        }
+        if (this.options.withEndIndices) {
+            node.endIndex = this.parser.endIndex;
+        }
+        parent.children.push(node);
+        if (previousSibling) {
+            node.prev = previousSibling;
+            previousSibling.next = node;
+        }
+        node.parent = parent;
+        this.lastNode = null;
+    }
+}
+exports.DomHandler = DomHandler;
+exports.default = DomHandler;

package/script/deps/deno.land/x/html_parser@v0.1.3/src/DomSerializer.d.ts

@@ -0,0 +1,51 @@
+import type { Node } from './Node.js';
+/**
+ * Mixed-case SVG and MathML tags & attributes
+ * recognized by the HTML parser.
+ *
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign
+ */
+export declare const elementNames: Map<string, string>;
+export declare const attributeNames: Map<string, string>;
+export interface DomSerializerOptions {
+    /**
+     * Print an empty attribute's value.
+     *
+     * @default xmlMode
+     * @example With <code>emptyAttrs: false</code>: <code>&lt;input checked&gt;</code>
+     * @example With <code>emptyAttrs: true</code>: <code>&lt;input checked=""&gt;</code>
+     */
+    emptyAttrs?: boolean;
+    /**
+     * Print self-closing tags for tags without contents.
+     *
+     * @default xmlMode
+     * @example With <code>selfClosingTags: false</code>: <code>&lt;foo&gt;&lt;/foo&gt;</code>
+     * @example With <code>selfClosingTags: true</code>: <code>&lt;foo /&gt;</code>
+     */
+    selfClosingTags?: boolean;
+    /**
+     * Treat the input as an XML document; enables the `emptyAttrs` and `selfClosingTags` options.
+     *
+     * If the value is `"foreign"`, it will try to correct mixed-case attribute names.
+     *
+     * @default false
+     */
+    xmlMode?: boolean | 'foreign';
+    /**
+     * Encode characters that are either reserved in HTML or XML, or are outside of the ASCII range.
+     *
+     * @default true
+     */
+    decodeEntities?: boolean;
+}
+/**
+ * Renders a DOM node or an array of DOM nodes to a string.
+ *
+ * Can be thought of as the equivalent of the `outerHTML` of the passed node(s).
+ *
+ * @param node Node to be rendered.
+ * @param options Changes serialization behavior
+ */
+export default function render(node: Node | ArrayLike<Node>, options?: DomSerializerOptions): string;
+//# sourceMappingURL=DomSerializer.d.ts.map

package/script/deps/deno.land/x/html_parser@v0.1.3/src/DomSerializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomSerializer.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/deno.land/x/html_parser@v0.1.3/src/DomSerializer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAuC,MAAM,WAAW,CAAA;AAG1E;;;;;GAKG;AACH,eAAO,MAAM,YAAY,qBAsCvB,CAAA;AAEF,eAAO,MAAM,cAAc,qBA4DzB,CAAA;AAEF,MAAM,WAAW,oBAAoB;IACjC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CAC3B;AAqED;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,MAAM,CAC1B,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,EAC5B,OAAO,GAAE,oBAAyB,GACnC,MAAM,CAUR"}

package/script/deps/deno.land/x/html_parser@v0.1.3/src/DomSerializer.js

@@ -0,0 +1,301 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attributeNames = exports.elementNames = void 0;
+/*
+ * Module dependencies
+ */
+const ElementType = __importStar(require("./ElementType.js"));
+const mod_js_1 = require("./utils/entities/mod.js");
+/**
+ * Mixed-case SVG and MathML tags & attributes
+ * recognized by the HTML parser.
+ *
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign
+ */
+exports.elementNames = new Map([
+    ['altglyph', 'altGlyph'],
+    ['altglyphdef', 'altGlyphDef'],
+    ['altglyphitem', 'altGlyphItem'],
+    ['animatecolor', 'animateColor'],
+    ['animatemotion', 'animateMotion'],
+    ['animatetransform', 'animateTransform'],
+    ['clippath', 'clipPath'],
+    ['feblend', 'feBlend'],
+    ['fecolormatrix', 'feColorMatrix'],
+    ['fecomponenttransfer', 'feComponentTransfer'],
+    ['fecomposite', 'feComposite'],
+    ['feconvolvematrix', 'feConvolveMatrix'],
+    ['fediffuselighting', 'feDiffuseLighting'],
+    ['fedisplacementmap', 'feDisplacementMap'],
+    ['fedistantlight', 'feDistantLight'],
+    ['fedropshadow', 'feDropShadow'],
+    ['feflood', 'feFlood'],
+    ['fefunca', 'feFuncA'],
+    ['fefuncb', 'feFuncB'],
+    ['fefuncg', 'feFuncG'],
+    ['fefuncr', 'feFuncR'],
+    ['fegaussianblur', 'feGaussianBlur'],
+    ['feimage', 'feImage'],
+    ['femerge', 'feMerge'],
+    ['femergenode', 'feMergeNode'],
+    ['femorphology', 'feMorphology'],
+    ['feoffset', 'feOffset'],
+    ['fepointlight', 'fePointLight'],
+    ['fespecularlighting', 'feSpecularLighting'],
+    ['fespotlight', 'feSpotLight'],
+    ['fetile', 'feTile'],
+    ['feturbulence', 'feTurbulence'],
+    ['foreignobject', 'foreignObject'],
+    ['glyphref', 'glyphRef'],
+    ['lineargradient', 'linearGradient'],
+    ['radialgradient', 'radialGradient'],
+    ['textpath', 'textPath'],
+]);
+exports.attributeNames = new Map([
+    ['definitionurl', 'definitionURL'],
+    ['attributename', 'attributeName'],
+    ['attributetype', 'attributeType'],
+    ['basefrequency', 'baseFrequency'],
+    ['baseprofile', 'baseProfile'],
+    ['calcmode', 'calcMode'],
+    ['clippathunits', 'clipPathUnits'],
+    ['diffuseconstant', 'diffuseConstant'],
+    ['edgemode', 'edgeMode'],
+    ['filterunits', 'filterUnits'],
+    ['glyphref', 'glyphRef'],
+    ['gradienttransform', 'gradientTransform'],
+    ['gradientunits', 'gradientUnits'],
+    ['kernelmatrix', 'kernelMatrix'],
+    ['kernelunitlength', 'kernelUnitLength'],
+    ['keypoints', 'keyPoints'],
+    ['keysplines', 'keySplines'],
+    ['keytimes', 'keyTimes'],
+    ['lengthadjust', 'lengthAdjust'],
+    ['limitingconeangle', 'limitingConeAngle'],
+    ['markerheight', 'markerHeight'],
+    ['markerunits', 'markerUnits'],
+    ['markerwidth', 'markerWidth'],
+    ['maskcontentunits', 'maskContentUnits'],
+    ['maskunits', 'maskUnits'],
+    ['numoctaves', 'numOctaves'],
+    ['pathlength', 'pathLength'],
+    ['patterncontentunits', 'patternContentUnits'],
+    ['patterntransform', 'patternTransform'],
+    ['patternunits', 'patternUnits'],
+    ['pointsatx', 'pointsAtX'],
+    ['pointsaty', 'pointsAtY'],
+    ['pointsatz', 'pointsAtZ'],
+    ['preservealpha', 'preserveAlpha'],
+    ['preserveaspectratio', 'preserveAspectRatio'],
+    ['primitiveunits', 'primitiveUnits'],
+    ['refx', 'refX'],
+    ['refy', 'refY'],
+    ['repeatcount', 'repeatCount'],
+    ['repeatdur', 'repeatDur'],
+    ['requiredextensions', 'requiredExtensions'],
+    ['requiredfeatures', 'requiredFeatures'],
+    ['specularconstant', 'specularConstant'],
+    ['specularexponent', 'specularExponent'],
+    ['spreadmethod', 'spreadMethod'],
+    ['startoffset', 'startOffset'],
+    ['stddeviation', 'stdDeviation'],
+    ['stitchtiles', 'stitchTiles'],
+    ['surfacescale', 'surfaceScale'],
+    ['systemlanguage', 'systemLanguage'],
+    ['tablevalues', 'tableValues'],
+    ['targetx', 'targetX'],
+    ['targety', 'targetY'],
+    ['textlength', 'textLength'],
+    ['viewbox', 'viewBox'],
+    ['viewtarget', 'viewTarget'],
+    ['xchannelselector', 'xChannelSelector'],
+    ['ychannelselector', 'yChannelSelector'],
+    ['zoomandpan', 'zoomAndPan'],
+]);
+const unencodedElements = new Set([
+    'style',
+    'script',
+    'xmp',
+    'iframe',
+    'noembed',
+    'noframes',
+    'plaintext',
+    'noscript',
+]);
+/**
+ * Format attributes
+ */
+function formatAttributes(attributes, opts) {
+    if (!attributes)
+        return;
+    return Object.keys(attributes)
+        .map(key => {
+        const value = attributes[key] ?? '';
+        if (opts.xmlMode === 'foreign') {
+            /* Fix up mixed-case attribute names */
+            key = exports.attributeNames.get(key) ?? key;
+        }
+        if (!opts.emptyAttrs && !opts.xmlMode && value === '') {
+            return key;
+        }
+        return `${key}="${opts.decodeEntities !== false
+            ? (0, mod_js_1.encodeXML)(value)
+            : value.replace(/"/g, '"')}"`;
+    })
+        .join(' ');
+}
+/**
+ * Self-enclosing tags
+ */
+const singleTag = new Set([
+    'area',
+    'base',
+    'basefont',
+    'br',
+    'col',
+    'command',
+    'embed',
+    'frame',
+    'hr',
+    'img',
+    'input',
+    'isindex',
+    'keygen',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr',
+]);
+/**
+ * Renders a DOM node or an array of DOM nodes to a string.
+ *
+ * Can be thought of as the equivalent of the `outerHTML` of the passed node(s).
+ *
+ * @param node Node to be rendered.
+ * @param options Changes serialization behavior
+ */
+function render(node, options = {}) {
+    const nodes = 'length' in node ? node : [node];
+    let output = '';
+    for (let i = 0; i < nodes.length; i++) {
+        output += renderNode(nodes[i], options);
+    }
+    return output;
+}
+exports.default = render;
+function renderNode(node, options) {
+    switch (node.type) {
+        case ElementType.Root:
+            return render(node.children, options);
+        case ElementType.Directive:
+        case ElementType.Doctype:
+            return renderDirective(node);
+        case ElementType.Comment:
+            return renderComment(node);
+        case ElementType.CDATA:
+            return renderCdata(node);
+        case ElementType.Script:
+        case ElementType.Style:
+        case ElementType.Tag:
+            return renderTag(node, options);
+        case ElementType.Text:
+            return renderText(node, options);
+    }
+}
+const foreignModeIntegrationPoints = new Set([
+    'mi',
+    'mo',
+    'mn',
+    'ms',
+    'mtext',
+    'annotation-xml',
+    'foreignObject',
+    'desc',
+    'title',
+]);
+const foreignElements = new Set(['svg', 'math']);
+function renderTag(elem, opts) {
+    // Handle SVG / MathML in HTML
+    if (opts.xmlMode === 'foreign') {
+        /* Fix up mixed-case element names */
+        elem.name = exports.elementNames.get(elem.name) ?? elem.name;
+        /* Exit foreign mode at integration points */
+        if (elem.parent &&
+            foreignModeIntegrationPoints.has(elem.parent.name)) {
+            opts = { ...opts, xmlMode: false };
+        }
+    }
+    if (!opts.xmlMode && foreignElements.has(elem.name)) {
+        opts = { ...opts, xmlMode: 'foreign' };
+    }
+    let tag = `<${elem.name}`;
+    const attribs = formatAttributes(elem.attribs, opts);
+    if (attribs) {
+        tag += ` ${attribs}`;
+    }
+    if (elem.children.length === 0 &&
+        (opts.xmlMode
+            ? // In XML mode or foreign mode, and user hasn't explicitly turned off self-closing tags
+                opts.selfClosingTags !== false
+            : // User explicitly asked for self-closing tags, even in HTML mode
+                opts.selfClosingTags && singleTag.has(elem.name))) {
+        if (!opts.xmlMode)
+            tag += ' ';
+        tag += '/>';
+    }
+    else {
+        tag += '>';
+        if (elem.children.length > 0) {
+            tag += render(elem.children, opts);
+        }
+        if (opts.xmlMode || !singleTag.has(elem.name)) {
+            tag += `</${elem.name}>`;
+        }
+    }
+    return tag;
+}
+function renderDirective(elem) {
+    return `<${elem.data}>`;
+}
+function renderText(elem, opts) {
+    let data = elem.data || '';
+    // If entities weren't decoded, no need to encode them back
+    if (opts.decodeEntities !== false &&
+        !(!opts.xmlMode &&
+            elem.parent &&
+            unencodedElements.has(elem.parent.name))) {
+        data = (0, mod_js_1.encodeXML)(data);
+    }
+    return data;
+}
+function renderCdata(elem) {
+    return `<![CDATA[${elem.children[0].data}]]>`;
+}
+function renderComment(elem) {
+    return `<!--${elem.data}-->`;
+}