@mtkruto/node 0.1.201 → 0.1.299

package/esm/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/esm/deps/deno.land/x/html_parser@v0.1.3/src/DomSerializer.js

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

@@ -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/esm/deps/deno.land/x/html_parser@v0.1.3/src/ElementType.js

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

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

@@ -0,0 +1,66 @@
+import DomHandler, { DomHandlerOptions } from './DomHandler.js';
+import { ParserOptions } from './Parser.js';
+declare enum FeedItemMediaMedium {
+    image = 0,
+    audio = 1,
+    video = 2,
+    document = 3,
+    executable = 4
+}
+declare enum FeedItemMediaExpression {
+    sample = 0,
+    full = 1,
+    nonstop = 2
+}
+interface FeedItemMedia {
+    url?: string;
+    fileSize?: number;
+    type?: string;
+    medium: FeedItemMediaMedium | undefined;
+    isDefault: boolean;
+    expression?: FeedItemMediaExpression;
+    bitrate?: number;
+    framerate?: number;
+    samplingrate?: number;
+    channels?: number;
+    duration?: number;
+    height?: number;
+    width?: number;
+    lang?: string;
+}
+interface FeedItem {
+    id?: string;
+    title?: string;
+    link?: string;
+    description?: string;
+    pubDate?: Date;
+    media?: FeedItemMedia[];
+}
+interface Feed {
+    type?: string;
+    id?: string;
+    title?: string;
+    link?: string;
+    description?: string;
+    updated?: Date;
+    author?: string;
+    items?: FeedItem[];
+}
+export declare class FeedHandler extends DomHandler {
+    feed?: Feed;
+    /**
+     *
+     * @param callback
+     * @param options
+     */
+    constructor(callback?: ((error: Error | null) => void) | DomHandlerOptions, options?: DomHandlerOptions);
+    onend(): void;
+}
+/**
+ * Parse a feed.
+ *
+ * @param feed The feed that should be parsed, as a string.
+ * @param options Optionally, options for parsing. When using this option, you should set `xmlMode` to `true`.
+ */
+export declare function parseFeed(feed: string, options?: ParserOptions & DomHandlerOptions): Feed | undefined;
+export {};

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

@@ -0,0 +1,191 @@
+import DomHandler from './DomHandler.js';
+import * as DomUtils from './utils/mod.js';
+import { Parser } from './Parser.js';
+var FeedItemMediaMedium;
+(function (FeedItemMediaMedium) {
+    FeedItemMediaMedium[FeedItemMediaMedium["image"] = 0] = "image";
+    FeedItemMediaMedium[FeedItemMediaMedium["audio"] = 1] = "audio";
+    FeedItemMediaMedium[FeedItemMediaMedium["video"] = 2] = "video";
+    FeedItemMediaMedium[FeedItemMediaMedium["document"] = 3] = "document";
+    FeedItemMediaMedium[FeedItemMediaMedium["executable"] = 4] = "executable";
+})(FeedItemMediaMedium || (FeedItemMediaMedium = {}));
+var FeedItemMediaExpression;
+(function (FeedItemMediaExpression) {
+    FeedItemMediaExpression[FeedItemMediaExpression["sample"] = 0] = "sample";
+    FeedItemMediaExpression[FeedItemMediaExpression["full"] = 1] = "full";
+    FeedItemMediaExpression[FeedItemMediaExpression["nonstop"] = 2] = "nonstop";
+})(FeedItemMediaExpression || (FeedItemMediaExpression = {}));
+// TODO: Consume data as it is coming in
+export class FeedHandler extends DomHandler {
+    /**
+     *
+     * @param callback
+     * @param options
+     */
+    constructor(callback, options) {
+        if (typeof callback === 'object') {
+            callback = undefined;
+            options = callback;
+        }
+        super(callback, options);
+        Object.defineProperty(this, "feed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    onend() {
+        const feedRoot = getOneElement(isValidFeed, this.dom);
+        if (!feedRoot) {
+            this.handleCallback(new Error("couldn't find root of feed"));
+            return;
+        }
+        const feed = {};
+        if (feedRoot.name === 'feed') {
+            const childs = feedRoot.children;
+            feed.type = 'atom';
+            addConditionally(feed, 'id', 'id', childs);
+            addConditionally(feed, 'title', 'title', childs);
+            const href = getAttribute('href', getOneElement('link', childs));
+            if (href) {
+                feed.link = href;
+            }
+            addConditionally(feed, 'description', 'subtitle', childs);
+            const updated = fetch('updated', childs);
+            if (updated) {
+                feed.updated = new Date(updated);
+            }
+            addConditionally(feed, 'author', 'email', childs, true);
+            feed.items = getElements('entry', childs).map(item => {
+                const entry = {};
+                const { children } = item;
+                addConditionally(entry, 'id', 'id', children);
+                addConditionally(entry, 'title', 'title', children);
+                const href = getAttribute('href', getOneElement('link', children));
+                if (href) {
+                    entry.link = href;
+                }
+                const description = fetch('summary', children) || fetch('content', children);
+                if (description) {
+                    entry.description = description;
+                }
+                const pubDate = fetch('updated', children);
+                if (pubDate) {
+                    entry.pubDate = new Date(pubDate);
+                }
+                entry.media = getMediaElements(children);
+                return entry;
+            });
+        }
+        else {
+            const childs = getOneElement('channel', feedRoot.children)?.children ?? [];
+            feed.type = feedRoot.name.substr(0, 3);
+            feed.id = '';
+            addConditionally(feed, 'title', 'title', childs);
+            addConditionally(feed, 'link', 'link', childs);
+            addConditionally(feed, 'description', 'description', childs);
+            const updated = fetch('lastBuildDate', childs);
+            if (updated) {
+                feed.updated = new Date(updated);
+            }
+            addConditionally(feed, 'author', 'managingEditor', childs, true);
+            feed.items = getElements('item', feedRoot.children).map((item) => {
+                const entry = {};
+                const { children } = item;
+                addConditionally(entry, 'id', 'guid', children);
+                addConditionally(entry, 'title', 'title', children);
+                addConditionally(entry, 'link', 'link', children);
+                addConditionally(entry, 'description', 'description', children);
+                const pubDate = fetch('pubDate', children);
+                if (pubDate)
+                    entry.pubDate = new Date(pubDate);
+                entry.media = getMediaElements(children);
+                return entry;
+            });
+        }
+        this.feed = feed;
+        this.handleCallback(null);
+    }
+}
+function getMediaElements(where) {
+    return getElements('media:content', where).map(elem => {
+        const media = {
+            medium: elem.attribs.medium,
+            isDefault: !!elem.attribs.isDefault,
+        };
+        if (elem.attribs.url) {
+            media.url = elem.attribs.url;
+        }
+        if (elem.attribs.fileSize) {
+            media.fileSize = parseInt(elem.attribs.fileSize, 10);
+        }
+        if (elem.attribs.type) {
+            media.type = elem.attribs.type;
+        }
+        if (elem.attribs.expression) {
+            media.expression = elem.attribs
+                .expression;
+        }
+        if (elem.attribs.bitrate) {
+            media.bitrate = parseInt(elem.attribs.bitrate, 10);
+        }
+        if (elem.attribs.framerate) {
+            media.framerate = parseInt(elem.attribs.framerate, 10);
+        }
+        if (elem.attribs.samplingrate) {
+            media.samplingrate = parseInt(elem.attribs.samplingrate, 10);
+        }
+        if (elem.attribs.channels) {
+            media.channels = parseInt(elem.attribs.channels, 10);
+        }
+        if (elem.attribs.duration) {
+            media.duration = parseInt(elem.attribs.duration, 10);
+        }
+        if (elem.attribs.height) {
+            media.height = parseInt(elem.attribs.height, 10);
+        }
+        if (elem.attribs.width) {
+            media.width = parseInt(elem.attribs.width, 10);
+        }
+        if (elem.attribs.lang) {
+            media.lang = elem.attribs.lang;
+        }
+        return media;
+    });
+}
+function getElements(tagName, where) {
+    return DomUtils.getElementsByTagName(tagName, where, true);
+}
+function getOneElement(tagName, node) {
+    return DomUtils.getElementsByTagName(tagName, node, true, 1)[0];
+}
+function fetch(tagName, where, recurse = false) {
+    return DomUtils.getText(DomUtils.getElementsByTagName(tagName, where, recurse, 1)).trim();
+}
+function getAttribute(name, elem) {
+    if (!elem) {
+        return null;
+    }
+    const { attribs } = elem;
+    return attribs[name];
+}
+function addConditionally(obj, prop, what, where, recurse = false) {
+    const tmp = fetch(what, where, recurse);
+    if (tmp)
+        obj[prop] = tmp;
+}
+function isValidFeed(value) {
+    return value === 'rss' || value === 'feed' || value === 'rdf:RDF';
+}
+/**
+ * Parse a feed.
+ *
+ * @param feed The feed that should be parsed, as a string.
+ * @param options Optionally, options for parsing. When using this option, you should set `xmlMode` to `true`.
+ */
+export function parseFeed(feed, options = { xmlMode: true }) {
+    const handler = new FeedHandler(options);
+    new Parser(handler, options).end(feed);
+    return handler.feed;
+}