@mtkruto/node 0.5.1 → 0.6.1

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

@@ -1,203 +0,0 @@
-import { Element, Document, NodeWithChildren, Comment, Text, ProcessingInstruction, } from './Node.js';
-import { ElementType } from './ElementType.js';
-const reWhitespace = /\s+/g;
-// Default options
-const defaultOpts = {
-    normalizeWhitespace: false,
-    withStartIndices: false,
-    withEndIndices: false,
-};
-export 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 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 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.Tag : undefined;
-        const element = new 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.Text) {
-            if (normalizeWhitespace) {
-                lastNode.data = (lastNode.data + data).replace(reWhitespace, ' ');
-            }
-            else {
-                lastNode.data += data;
-            }
-        }
-        else {
-            if (normalizeWhitespace) {
-                data = data.replace(reWhitespace, ' ');
-            }
-            const node = new Text(data);
-            this.addNode(node);
-            this.lastNode = node;
-        }
-    }
-    oncomment(data) {
-        if (this.lastNode && this.lastNode.type === ElementType.Comment) {
-            this.lastNode.data += data;
-            return;
-        }
-        const node = new Comment(data);
-        this.addNode(node);
-        this.lastNode = node;
-    }
-    oncommentend() {
-        this.lastNode = null;
-    }
-    oncdatastart() {
-        const text = new Text('');
-        const node = new NodeWithChildren(ElementType.CDATA, [text]);
-        this.addNode(node);
-        text.parent = node;
-        this.lastNode = text;
-    }
-    oncdataend() {
-        this.lastNode = null;
-    }
-    onprocessinginstruction(name, data) {
-        const node = new 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;
-    }
-}
-export default DomHandler;

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

@@ -1,51 +0,0 @@
-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/esm/deps/deno.land/x/html_parser@v0.1.3/src/DomSerializer.d.ts.map

@@ -1 +0,0 @@
-{"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/esm/deps/deno.land/x/html_parser@v0.1.3/src/DomSerializer.js

@@ -1,274 +0,0 @@
-/*
- * Module dependencies
- */
-import * as ElementType from './ElementType.js';
-import { encodeXML } from './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
- */
-export const 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'],
-]);
-export const 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 = attributeNames.get(key) ?? key;
-        }
-        if (!opts.emptyAttrs && !opts.xmlMode && value === '') {
-            return key;
-        }
-        return `${key}="${opts.decodeEntities !== false
-            ? 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
- */
-export default 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;
-}
-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 = 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 = encodeXML(data);
-    }
-    return data;
-}
-function renderCdata(elem) {
-    return `<![CDATA[${elem.children[0].data}]]>`;
-}
-function renderComment(elem) {
-    return `<!--${elem.data}-->`;
-}

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/ElementType.d.ts

@@ -1,48 +0,0 @@
-/** Types of elements found in htmlparser2's DOM */
-export declare enum ElementType {
-    /** Type for the root element of a document */
-    Root = "root",
-    /** Type for Text */
-    Text = "text",
-    /** Type for <? ... ?> */
-    Directive = "directive",
-    /** Type for <!-- ... --> */
-    Comment = "comment",
-    /** Type for <script> tags */
-    Script = "script",
-    /** Type for <style> tags */
-    Style = "style",
-    /** Type for Any tag */
-    Tag = "tag",
-    /** Type for <![CDATA[ ... ]]> */
-    CDATA = "cdata",
-    /** Type for <!doctype ...> */
-    Doctype = "doctype"
-}
-/**
- * Tests whether an element is a tag or not.
- *
- * @param elem Element to test
- */
-export declare function isTag(elem: {
-    type: ElementType;
-}): boolean;
-/** Type for the root element of a document */
-export declare const Root = ElementType.Root;
-/** Type for Text */
-export declare const Text = ElementType.Text;
-/** Type for <? ... ?> */
-export declare const Directive = ElementType.Directive;
-/** Type for <!-- ... --> */
-export declare const Comment = ElementType.Comment;
-/** Type for <script> tags */
-export declare const Script = ElementType.Script;
-/** Type for <style> tags */
-export declare const Style = ElementType.Style;
-/** Type for Any tag */
-export declare const Tag = ElementType.Tag;
-/** Type for <![CDATA[ ... ]]> */
-export declare const CDATA = ElementType.CDATA;
-/** Type for <!doctype ...> */
-export declare const Doctype = ElementType.Doctype;
-//# sourceMappingURL=ElementType.d.ts.map

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/ElementType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ElementType.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/deno.land/x/html_parser@v0.1.3/src/ElementType.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,oBAAY,WAAW;IACnB,8CAA8C;IAC9C,IAAI,SAAS;IACb,oBAAoB;IACpB,IAAI,SAAS;IACb,yBAAyB;IACzB,SAAS,cAAc;IACvB,4BAA4B;IAC5B,OAAO,YAAY;IACnB,6BAA6B;IAC7B,MAAM,WAAW;IACjB,4BAA4B;IAC5B,KAAK,UAAU;IACf,uBAAuB;IACvB,GAAG,QAAQ;IACX,iCAAiC;IACjC,KAAK,UAAU;IACf,8BAA8B;IAC9B,OAAO,YAAY;CACtB;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAM1D;AAGD,8CAA8C;AAC9C,eAAO,MAAM,IAAI,mBAAmB,CAAA;AACpC,oBAAoB;AACpB,eAAO,MAAM,IAAI,mBAAmB,CAAA;AACpC,yBAAyB;AACzB,eAAO,MAAM,SAAS,wBAAwB,CAAA;AAC9C,4BAA4B;AAC5B,eAAO,MAAM,OAAO,sBAAsB,CAAA;AAC1C,6BAA6B;AAC7B,eAAO,MAAM,MAAM,qBAAqB,CAAA;AACxC,4BAA4B;AAC5B,eAAO,MAAM,KAAK,oBAAoB,CAAA;AACtC,uBAAuB;AACvB,eAAO,MAAM,GAAG,kBAAkB,CAAA;AAClC,iCAAiC;AACjC,eAAO,MAAM,KAAK,oBAAoB,CAAA;AACtC,8BAA8B;AAC9B,eAAO,MAAM,OAAO,sBAAsB,CAAA"}

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/ElementType.js

@@ -1,51 +0,0 @@
-/** Types of elements found in htmlparser2's DOM */
-export var ElementType;
-(function (ElementType) {
-    /** Type for the root element of a document */
-    ElementType["Root"] = "root";
-    /** Type for Text */
-    ElementType["Text"] = "text";
-    /** Type for <? ... ?> */
-    ElementType["Directive"] = "directive";
-    /** Type for <!-- ... --> */
-    ElementType["Comment"] = "comment";
-    /** Type for <script> tags */
-    ElementType["Script"] = "script";
-    /** Type for <style> tags */
-    ElementType["Style"] = "style";
-    /** Type for Any tag */
-    ElementType["Tag"] = "tag";
-    /** Type for <![CDATA[ ... ]]> */
-    ElementType["CDATA"] = "cdata";
-    /** Type for <!doctype ...> */
-    ElementType["Doctype"] = "doctype";
-})(ElementType || (ElementType = {}));
-/**
- * Tests whether an element is a tag or not.
- *
- * @param elem Element to test
- */
-export function isTag(elem) {
-    return (elem.type === ElementType.Tag ||
-        elem.type === ElementType.Script ||
-        elem.type === ElementType.Style);
-}
-// Exports for backwards compatibility
-/** Type for the root element of a document */
-export const Root = ElementType.Root;
-/** Type for Text */
-export const Text = ElementType.Text;
-/** Type for <? ... ?> */
-export const Directive = ElementType.Directive;
-/** Type for <!-- ... --> */
-export const Comment = ElementType.Comment;
-/** Type for <script> tags */
-export const Script = ElementType.Script;
-/** Type for <style> tags */
-export const Style = ElementType.Style;
-/** Type for Any tag */
-export const Tag = ElementType.Tag;
-/** Type for <![CDATA[ ... ]]> */
-export const CDATA = ElementType.CDATA;
-/** Type for <!doctype ...> */
-export const Doctype = ElementType.Doctype;