@mtkruto/node 0.1.191 → 0.1.201

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

@@ -1,101 +0,0 @@
-import { isTag } from '../Node.js';
-const emptyArray = [];
-/**
- * Get a node's children.
- *
- * @param elem Node to get the children of.
- * @returns `elem`'s children, or an empty array.
- */
-export function getChildren(elem) {
-    return elem.children ?? emptyArray;
-}
-/**
- * Get a node's parent.
- *
- * @param elem Node to get the parent of.
- * @returns `elem`'s parent node.
- */
-export function getParent(elem) {
-    return elem.parent || null;
-}
-/**
- * Gets an elements siblings, including the element itself.
- *
- * Attempts to get the children through the element's parent first.
- * If we don't have a parent (the element is a root node),
- * we walk the element's `prev` & `next` to get all remaining nodes.
- *
- * @param elem Element to get the siblings of.
- * @returns `elem`'s siblings.
- */
-export function getSiblings(elem) {
-    const parent = getParent(elem);
-    if (parent != null)
-        return getChildren(parent);
-    const siblings = [elem];
-    let { prev, next } = elem;
-    while (prev != null) {
-        siblings.unshift(prev);
-        ({ prev } = prev);
-    }
-    while (next != null) {
-        siblings.push(next);
-        ({ next } = next);
-    }
-    return siblings;
-}
-/**
- * Gets an attribute from an element.
- *
- * @param elem Element to check.
- * @param name Attribute name to retrieve.
- * @returns The element's attribute value, or `undefined`.
- */
-export function getAttributeValue(elem, name) {
-    return elem.attribs?.[name];
-}
-/**
- * Checks whether an element has an attribute.
- *
- * @param elem Element to check.
- * @param name Attribute name to look for.
- * @returns Returns whether `elem` has the attribute `name`.
- */
-export function hasAttrib(elem, name) {
-    return (elem.attribs != null &&
-        Object.prototype.hasOwnProperty.call(elem.attribs, name) &&
-        elem.attribs[name] != null);
-}
-/**
- * Get the tag name of an element.
- *
- * @param elem The element to get the name for.
- * @returns The tag name of `elem`.
- */
-export function getName(elem) {
-    return elem.name;
-}
-/**
- * Returns the next element sibling of a node.
- *
- * @param elem The element to get the next sibling of.
- * @returns `elem`'s next sibling that is a tag.
- */
-export function nextElementSibling(elem) {
-    let { next } = elem;
-    while (next !== null && !isTag(next))
-        ({ next } = next);
-    return next;
-}
-/**
- * Returns the previous element sibling of a node.
- *
- * @param elem The element to get the previous sibling of.
- * @returns `elem`'s previous sibling that is a tag.
- */
-export function prevElementSibling(elem) {
-    let { prev } = elem;
-    while (prev !== null && !isTag(prev))
-        ({ prev } = prev);
-    return prev;
-}

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

@@ -1,83 +0,0 @@
-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;

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

@@ -1,207 +0,0 @@
-"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

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