@mtkruto/node 0.1.289 → 0.1.299

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

@@ -0,0 +1,42 @@
+import { Parser, ParserOptions } from './Parser.js';
+export { Parser };
+export type { ParserOptions };
+import { Node, Element, Document } from './Node.js';
+import { DomHandler, DomHandlerOptions } from './DomHandler.js';
+export { DomHandler };
+export type { DomHandlerOptions };
+type Options = ParserOptions & DomHandlerOptions;
+/**
+ * Parses the data, returns the resulting document.
+ *
+ * @param data The data that should be parsed.
+ * @param options Optional options for the parser and DOM builder.
+ */
+export declare function parseDocument(data: string, options?: Options): Document;
+/**
+ * Parses data, returns an array of the root nodes.
+ *
+ * Note that the root nodes still have a `Document` node as their parent.
+ * Use `parseDocument` to get the `Document` node instead.
+ *
+ * @param data The data that should be parsed.
+ * @param options Optional options for the parser and DOM builder.
+ * @deprecated Use `parseDocument` instead.
+ */
+export declare function parseDOM(data: string, options?: Options): Node[];
+/**
+ * Creates a parser instance, with an attached DOM handler.
+ *
+ * @param cb A callback that will be called once parsing has been completed.
+ * @param options Optional options for the parser and DOM builder.
+ * @param elementCb An optional callback that will be called every time a tag has been completed inside of the DOM.
+ */
+export declare function createDomStream(cb: (error: Error | null, dom: Node[]) => void, options?: Options, elementCb?: (element: Element) => void): Parser;
+export { default as Tokenizer } from './Tokenizer.js';
+export type { Callbacks as TokenizerCallbacks } from './Tokenizer.js';
+import * as ElementType from './ElementType.js';
+export { ElementType };
+export * from './FeedHandler.js';
+export * as DomUtils from './utils/mod.js';
+export { DomHandler as DefaultHandler };
+export { FeedHandler as RssHandler } from './FeedHandler.js';

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

@@ -0,0 +1,52 @@
+import { Parser } from './Parser.js';
+export { Parser };
+import { DomHandler } from './DomHandler.js';
+export { DomHandler };
+// Helper methods
+/**
+ * Parses the data, returns the resulting document.
+ *
+ * @param data The data that should be parsed.
+ * @param options Optional options for the parser and DOM builder.
+ */
+export function parseDocument(data, options) {
+    const handler = new DomHandler(undefined, options);
+    new Parser(handler, options).end(data);
+    return handler.root;
+}
+/**
+ * Parses data, returns an array of the root nodes.
+ *
+ * Note that the root nodes still have a `Document` node as their parent.
+ * Use `parseDocument` to get the `Document` node instead.
+ *
+ * @param data The data that should be parsed.
+ * @param options Optional options for the parser and DOM builder.
+ * @deprecated Use `parseDocument` instead.
+ */
+export function parseDOM(data, options) {
+    return parseDocument(data, options).children;
+}
+/**
+ * Creates a parser instance, with an attached DOM handler.
+ *
+ * @param cb A callback that will be called once parsing has been completed.
+ * @param options Optional options for the parser and DOM builder.
+ * @param elementCb An optional callback that will be called every time a tag has been completed inside of the DOM.
+ */
+export function createDomStream(cb, options, elementCb) {
+    const handler = new DomHandler(cb, options, elementCb);
+    return new Parser(handler, options);
+}
+export { default as Tokenizer } from './Tokenizer.js';
+import * as ElementType from './ElementType.js';
+export { ElementType };
+/*
+ * All of the following exports exist for backwards-compatibility.
+ * They should probably be removed eventually.
+ */
+export * from './FeedHandler.js';
+export * as DomUtils from './utils/mod.js';
+// Old names for Dom- & FeedHandler
+export { DomHandler as DefaultHandler };
+export { FeedHandler as RssHandler } from './FeedHandler.js';

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/decode.d.ts

@@ -0,0 +1,11 @@
+export interface TrieNode {
+    value?: string;
+    legacy?: boolean;
+    base?: number;
+    next?: Map<string, TrieNode>;
+}
+export declare const xmlTrie: TrieNode;
+export declare const decodeXML: (str: string) => string;
+export declare const htmlTrie: TrieNode;
+export declare const decodeHTMLStrict: (str: string) => string;
+export declare const decodeHTML: (str: string) => string;

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/decode.js

@@ -0,0 +1,122 @@
+import entityMap from './maps/entities.js';
+import legacyMap from './maps/legacy.js';
+import xmlMap from './maps/xml.js';
+import decodeCodePoint from './decode_codepoint.js';
+const numStart = (function () {
+    const numStart = new Map();
+    const numRecurse = new Map();
+    const numValue = { next: numRecurse, base: 10 };
+    for (let i = 0; i <= 9; i++) {
+        numStart.set(i.toString(10), numValue);
+        numRecurse.set(i.toString(10), numValue);
+    }
+    const hexRecurse = new Map();
+    const hexValue = { next: hexRecurse, base: 16 };
+    for (let i = 0; i <= 15; i++) {
+        hexRecurse.set(i.toString(16), hexValue);
+        hexRecurse.set(i.toString(16).toUpperCase(), hexValue);
+    }
+    const hexStart = { next: hexRecurse };
+    numStart.set('x', hexStart);
+    numStart.set('X', hexStart);
+    return { next: numStart };
+})();
+function getTrieReplacer(trieStart, legacyEntities) {
+    return (str) => {
+        let ret = '';
+        let lastIdx = 0;
+        let legacyTrieIndex = 0;
+        let idx = 0;
+        function decodeNumeric(base) {
+            const entity = str.substring(
+            // Skip the leading "&#". For hex entities, also skip the leading "x".
+            lastIdx + 2 + (base >>> 4), idx);
+            const parsed = parseInt(entity, base);
+            return decodeCodePoint(parsed);
+        }
+        entityLoop: while ((idx = str.indexOf('&', idx)) >= 0) {
+            ret += str.slice(lastIdx, idx);
+            lastIdx = idx;
+            let trieNode = trieStart;
+            let legacyTrie;
+            while (++idx < str.length) {
+                const c = str.charAt(idx);
+                if (c === ';') {
+                    if (trieNode.value) {
+                        ret += trieNode.value;
+                    }
+                    else if (trieNode.base) {
+                        ret += decodeNumeric(trieNode.base);
+                    }
+                    else
+                        break;
+                    idx += 1;
+                    lastIdx = idx;
+                    continue entityLoop;
+                }
+                else {
+                    const next = trieNode.next?.get(c);
+                    if (next) {
+                        trieNode = next;
+                        if (legacyEntities && next.legacy) {
+                            legacyTrie = next;
+                            legacyTrieIndex = idx;
+                        }
+                    }
+                    else
+                        break;
+                }
+            }
+            if (legacyEntities) {
+                if (legacyTrie) {
+                    ret += legacyTrie.value;
+                    lastIdx = legacyTrieIndex + 1;
+                }
+                else if (trieNode.base) {
+                    ret += decodeNumeric(trieNode.base);
+                    lastIdx = idx;
+                }
+            }
+        }
+        return ret + str.substr(lastIdx);
+    };
+}
+export const xmlTrie = { next: getTrie(xmlMap) };
+export const decodeXML = getTrieReplacer(xmlTrie, false);
+export const htmlTrie = {
+    next: markLegacyEntries(getTrie(entityMap), legacyMap),
+};
+export const decodeHTMLStrict = getTrieReplacer(htmlTrie, false);
+export const decodeHTML = getTrieReplacer(htmlTrie, true);
+function getTrie(map) {
+    const trie = new Map();
+    for (const key of Object.keys(map)) {
+        // Resolve the key
+        let lastMap = trie;
+        for (const char of key.slice(0, -1)) {
+            const next = lastMap.get(char) ?? {};
+            lastMap.set(char, next);
+            lastMap = next.next ??= new Map();
+        }
+        const val = lastMap.get(key.slice(-1)) ?? {};
+        val.value = map[key];
+        lastMap.set(key.slice(-1), val);
+    }
+    // Add numeric values
+    trie.set('#', numStart);
+    return trie;
+}
+function markLegacyEntries(trie, legacy) {
+    for (const key of Object.keys(legacy)) {
+        // Resolve the key
+        let lastMap = { next: trie };
+        for (const char of key) {
+            const next = lastMap.next?.get(char);
+            if (!next)
+                throw new Error(`Could not find ${key} at ${char}`);
+            lastMap = next;
+        }
+        lastMap.legacy = true;
+    }
+    return trie;
+}

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/decode_codepoint.d.ts

@@ -0,0 +1 @@
+export default function decodeCodePoint(codePoint: number): string;

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/decode_codepoint.js

@@ -0,0 +1,24 @@
+import decodeMap from './maps/decode.js';
+// Adapted from https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119
+const fromCodePoint = 
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins
+String.fromCodePoint ||
+    function (codePoint) {
+        let output = '';
+        if (codePoint > 0xffff) {
+            codePoint -= 0x10000;
+            output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);
+            codePoint = 0xdc00 | (codePoint & 0x3ff);
+        }
+        output += String.fromCharCode(codePoint);
+        return output;
+    };
+export default function decodeCodePoint(codePoint) {
+    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
+        return '\uFFFD';
+    }
+    if (codePoint in decodeMap) {
+        codePoint = decodeMap[codePoint];
+    }
+    return fromCodePoint(codePoint);
+}

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/encode.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in XML
+ * documents using XML entities.
+ *
+ * If a character has no equivalent entity, a
+ * numeric hexadecimal reference (eg. `ü`) will be used.
+ */
+export declare const encodeXML: (data: string) => string;
+/**
+ * Encodes all entities and non-ASCII characters in the input.
+ *
+ * This includes characters that are valid ASCII characters in HTML documents.
+ * For example `#` will be encoded as `#`. To get a more compact output,
+ * consider using the `encodeNonAsciiHTML` function.
+ *
+ * If a character has no equivalent entity, a
+ * numeric hexadecimal reference (eg. `ü`) will be used.
+ */
+export declare const encodeHTML: (data: string) => string;
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in HTML
+ * documents using HTML entities.
+ *
+ * If a character has no equivalent entity, a
+ * numeric hexadecimal reference (eg. `ü`) will be used.
+ */
+export declare const encodeNonAsciiHTML: (data: string) => string;
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in XML
+ * documents using numeric hexadecimal reference (eg. `ü`).
+ *
+ * Have a look at `escapeUTF8` if you want a more concise output at the expense
+ * of reduced transportability.
+ *
+ * @param data String to escape.
+ */
+export declare function escape(data: string): string;
+/**
+ * Encodes all characters not valid in XML documents using numeric hexadecimal
+ * reference (eg. `ü`).
+ *
+ * Note that the output will be character-set dependent.
+ *
+ * @param data String to escape.
+ */
+export declare function escapeUTF8(data: string): string;

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/encode.js

@@ -0,0 +1,121 @@
+import xmlMap from './maps/xml.js';
+const inverseXML = getInverseObj(xmlMap);
+const xmlReplacer = getInverseReplacer(inverseXML);
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in XML
+ * documents using XML entities.
+ *
+ * If a character has no equivalent entity, a
+ * numeric hexadecimal reference (eg. `ü`) will be used.
+ */
+export const encodeXML = getASCIIEncoder(inverseXML);
+import htmlMap from './maps/entities.js';
+const inverseHTML = getInverseObj(htmlMap);
+const htmlReplacer = getInverseReplacer(inverseHTML);
+/**
+ * Encodes all entities and non-ASCII characters in the input.
+ *
+ * This includes characters that are valid ASCII characters in HTML documents.
+ * For example `#` will be encoded as `#`. To get a more compact output,
+ * consider using the `encodeNonAsciiHTML` function.
+ *
+ * If a character has no equivalent entity, a
+ * numeric hexadecimal reference (eg. `ü`) will be used.
+ */
+export const encodeHTML = getInverse(inverseHTML, htmlReplacer);
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in HTML
+ * documents using HTML entities.
+ *
+ * If a character has no equivalent entity, a
+ * numeric hexadecimal reference (eg. `ü`) will be used.
+ */
+export const encodeNonAsciiHTML = getASCIIEncoder(inverseHTML);
+function getInverseObj(obj) {
+    return Object.keys(obj)
+        .sort()
+        .reduce((inverse, name) => {
+        inverse[obj[name]] = `&${name};`;
+        return inverse;
+    }, {});
+}
+function getInverseReplacer(inverse) {
+    const single = [];
+    const multiple = [];
+    for (const k of Object.keys(inverse)) {
+        if (k.length === 1) {
+            // Add value to single array
+            single.push(`\\${k}`);
+        }
+        else {
+            // Add value to multiple array
+            multiple.push(k);
+        }
+    }
+    // Add ranges to single characters.
+    single.sort();
+    for (let start = 0; start < single.length - 1; start++) {
+        // Find the end of a run of characters
+        let end = start;
+        while (end < single.length - 1 &&
+            single[end].charCodeAt(1) + 1 === single[end + 1].charCodeAt(1)) {
+            end += 1;
+        }
+        const count = 1 + end - start;
+        // We want to replace at least three characters
+        if (count < 3)
+            continue;
+        single.splice(start, count, `${single[start]}-${single[end]}`);
+    }
+    multiple.unshift(`[${single.join('')}]`);
+    return new RegExp(multiple.join('|'), 'g');
+}
+// /[^\0-\x7F]/gu
+const reNonASCII = /(?:[\x80-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/g;
+const getCodePoint = 
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+String.prototype.codePointAt != null
+    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        (str) => str.codePointAt(0)
+    : // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+        (c) => (c.charCodeAt(0) - 0xd800) * 0x400 +
+            c.charCodeAt(1) -
+            0xdc00 +
+            0x10000;
+function singleCharReplacer(c) {
+    return `&#x${(c.length > 1 ? getCodePoint(c) : c.charCodeAt(0))
+        .toString(16)
+        .toUpperCase()};`;
+}
+function getInverse(inverse, re) {
+    return (data) => data
+        .replace(re, name => inverse[name])
+        .replace(reNonASCII, singleCharReplacer);
+}
+const reEscapeChars = new RegExp(`${xmlReplacer.source}|${reNonASCII.source}`, 'g');
+/**
+ * Encodes all non-ASCII characters, as well as characters not valid in XML
+ * documents using numeric hexadecimal reference (eg. `&#xfc;`).
+ *
+ * Have a look at `escapeUTF8` if you want a more concise output at the expense
+ * of reduced transportability.
+ *
+ * @param data String to escape.
+ */
+export function escape(data) {
+    return data.replace(reEscapeChars, singleCharReplacer);
+}
+/**
+ * Encodes all characters not valid in XML documents using numeric hexadecimal
+ * reference (eg. `&#xfc;`).
+ *
+ * Note that the output will be character-set dependent.
+ *
+ * @param data String to escape.
+ */
+export function escapeUTF8(data) {
+    return data.replace(xmlReplacer, singleCharReplacer);
+}
+function getASCIIEncoder(obj) {
+    return (data) => data.replace(reEscapeChars, c => obj[c] || singleCharReplacer(c));
+}

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/decode.d.ts

@@ -0,0 +1,31 @@
+declare const _default: {
+    '0': number;
+    '128': number;
+    '130': number;
+    '131': number;
+    '132': number;
+    '133': number;
+    '134': number;
+    '135': number;
+    '136': number;
+    '137': number;
+    '138': number;
+    '139': number;
+    '140': number;
+    '142': number;
+    '145': number;
+    '146': number;
+    '147': number;
+    '148': number;
+    '149': number;
+    '150': number;
+    '151': number;
+    '152': number;
+    '153': number;
+    '154': number;
+    '155': number;
+    '156': number;
+    '158': number;
+    '159': number;
+};
+export default _default;

package/esm/deps/deno.land/x/html_parser@v0.1.3/src/utils/entities/maps/decode.js

@@ -0,0 +1,30 @@
+export default {
+    '0': 65533,
+    '128': 8364,
+    '130': 8218,
+    '131': 402,
+    '132': 8222,
+    '133': 8230,
+    '134': 8224,
+    '135': 8225,
+    '136': 710,
+    '137': 8240,
+    '138': 352,
+    '139': 8249,
+    '140': 338,
+    '142': 381,
+    '145': 8216,
+    '146': 8217,
+    '147': 8220,
+    '148': 8221,
+    '149': 8226,
+    '150': 8211,
+    '151': 8212,
+    '152': 732,
+    '153': 8482,
+    '154': 353,
+    '155': 8250,
+    '156': 339,
+    '158': 382,
+    '159': 376,
+};