@mtkruto/node 0.1.289 → 0.1.299

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,50 @@
+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;

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}-->`;
+}

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

@@ -0,0 +1,47 @@
+/** 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;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Doctype = exports.CDATA = exports.Tag = exports.Style = exports.Script = exports.Comment = exports.Directive = exports.Text = exports.Root = exports.isTag = exports.ElementType = void 0;
+/** Types of elements found in htmlparser2's DOM */
+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 || (exports.ElementType = ElementType = {}));
+/**
+ * Tests whether an element is a tag or not.
+ *
+ * @param elem Element to test
+ */
+function isTag(elem) {
+    return (elem.type === ElementType.Tag ||
+        elem.type === ElementType.Script ||
+        elem.type === ElementType.Style);
+}
+exports.isTag = isTag;
+// Exports for backwards compatibility
+/** Type for the root element of a document */
+exports.Root = ElementType.Root;
+/** Type for Text */
+exports.Text = ElementType.Text;
+/** Type for <? ... ?> */
+exports.Directive = ElementType.Directive;
+/** Type for <!-- ... --> */
+exports.Comment = ElementType.Comment;
+/** Type for <script> tags */
+exports.Script = ElementType.Script;
+/** Type for <style> tags */
+exports.Style = ElementType.Style;
+/** Type for Any tag */
+exports.Tag = ElementType.Tag;
+/** Type for <![CDATA[ ... ]]> */
+exports.CDATA = ElementType.CDATA;
+/** Type for <!doctype ...> */
+exports.Doctype = ElementType.Doctype;