@venos-inc/venos 0.1.14 → 0.1.15

package/etc/mcp-server/node_modules/parse5/dist/parser/open-element-stack.d.ts

@@ -0,0 +1,53 @@
+import { TAG_ID as $ } from '../common/html.js';
+import type { TreeAdapter, TreeAdapterTypeMap } from '../tree-adapters/interface.js';
+export interface StackHandler<T extends TreeAdapterTypeMap> {
+    onItemPush: (node: T['parentNode'], tid: number, isTop: boolean) => void;
+    onItemPop: (node: T['parentNode'], isTop: boolean) => void;
+}
+export declare class OpenElementStack<T extends TreeAdapterTypeMap> {
+    private treeAdapter;
+    private handler;
+    items: T['parentNode'][];
+    tagIDs: $[];
+    current: T['parentNode'] | undefined;
+    stackTop: number;
+    tmplCount: number;
+    currentTagId: number | undefined;
+    get currentTmplContentOrNode(): T['parentNode'];
+    constructor(document: T['document'], treeAdapter: TreeAdapter<T>, handler: StackHandler<T>);
+    private _indexOf;
+    private _isInTemplate;
+    private _updateCurrentElement;
+    push(element: T['element'], tagID: $): void;
+    pop(): void;
+    replace(oldElement: T['element'], newElement: T['element']): void;
+    insertAfter(referenceElement: T['element'], newElement: T['element'], newElementID: $): void;
+    popUntilTagNamePopped(tagName: $): void;
+    shortenToLength(idx: number): void;
+    popUntilElementPopped(element: T['element']): void;
+    private popUntilPopped;
+    popUntilNumberedHeaderPopped(): void;
+    popUntilTableCellPopped(): void;
+    popAllUpToHtmlElement(): void;
+    private _indexOfTagNames;
+    private clearBackTo;
+    clearBackToTableContext(): void;
+    clearBackToTableBodyContext(): void;
+    clearBackToTableRowContext(): void;
+    remove(element: T['element']): void;
+    tryPeekProperlyNestedBodyElement(): T['element'] | null;
+    contains(element: T['element']): boolean;
+    getCommonAncestor(element: T['element']): T['element'] | null;
+    isRootHtmlElementCurrent(): boolean;
+    private hasInDynamicScope;
+    hasInScope(tagName: $): boolean;
+    hasInListItemScope(tagName: $): boolean;
+    hasInButtonScope(tagName: $): boolean;
+    hasNumberedHeaderInScope(): boolean;
+    hasInTableScope(tagName: $): boolean;
+    hasTableBodyContextInTableScope(): boolean;
+    hasInSelectScope(tagName: $): boolean;
+    generateImpliedEndTags(): void;
+    generateImpliedEndTagsThoroughly(): void;
+    generateImpliedEndTagsWithExclusion(exclusionId: $): void;
+}

package/etc/mcp-server/node_modules/parse5/dist/parser/open-element-stack.js

@@ -0,0 +1,324 @@
+import { TAG_ID as $, NS, NUMBERED_HEADERS } from '../common/html.js';
+//Element utils
+const IMPLICIT_END_TAG_REQUIRED = new Set([$.DD, $.DT, $.LI, $.OPTGROUP, $.OPTION, $.P, $.RB, $.RP, $.RT, $.RTC]);
+const IMPLICIT_END_TAG_REQUIRED_THOROUGHLY = new Set([
+    ...IMPLICIT_END_TAG_REQUIRED,
+    $.CAPTION,
+    $.COLGROUP,
+    $.TBODY,
+    $.TD,
+    $.TFOOT,
+    $.TH,
+    $.THEAD,
+    $.TR,
+]);
+const SCOPING_ELEMENTS_HTML = new Set([
+    $.APPLET,
+    $.CAPTION,
+    $.HTML,
+    $.MARQUEE,
+    $.OBJECT,
+    $.TABLE,
+    $.TD,
+    $.TEMPLATE,
+    $.TH,
+]);
+const SCOPING_ELEMENTS_HTML_LIST = new Set([...SCOPING_ELEMENTS_HTML, $.OL, $.UL]);
+const SCOPING_ELEMENTS_HTML_BUTTON = new Set([...SCOPING_ELEMENTS_HTML, $.BUTTON]);
+const SCOPING_ELEMENTS_MATHML = new Set([$.ANNOTATION_XML, $.MI, $.MN, $.MO, $.MS, $.MTEXT]);
+const SCOPING_ELEMENTS_SVG = new Set([$.DESC, $.FOREIGN_OBJECT, $.TITLE]);
+const TABLE_ROW_CONTEXT = new Set([$.TR, $.TEMPLATE, $.HTML]);
+const TABLE_BODY_CONTEXT = new Set([$.TBODY, $.TFOOT, $.THEAD, $.TEMPLATE, $.HTML]);
+const TABLE_CONTEXT = new Set([$.TABLE, $.TEMPLATE, $.HTML]);
+const TABLE_CELLS = new Set([$.TD, $.TH]);
+//Stack of open elements
+export class OpenElementStack {
+    get currentTmplContentOrNode() {
+        return this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : this.current;
+    }
+    constructor(document, treeAdapter, handler) {
+        this.treeAdapter = treeAdapter;
+        this.handler = handler;
+        this.items = [];
+        this.tagIDs = [];
+        this.stackTop = -1;
+        this.tmplCount = 0;
+        this.currentTagId = $.UNKNOWN;
+        this.current = document;
+    }
+    //Index of element
+    _indexOf(element) {
+        return this.items.lastIndexOf(element, this.stackTop);
+    }
+    //Update current element
+    _isInTemplate() {
+        return this.currentTagId === $.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === NS.HTML;
+    }
+    _updateCurrentElement() {
+        this.current = this.items[this.stackTop];
+        this.currentTagId = this.tagIDs[this.stackTop];
+    }
+    //Mutations
+    push(element, tagID) {
+        this.stackTop++;
+        this.items[this.stackTop] = element;
+        this.current = element;
+        this.tagIDs[this.stackTop] = tagID;
+        this.currentTagId = tagID;
+        if (this._isInTemplate()) {
+            this.tmplCount++;
+        }
+        this.handler.onItemPush(element, tagID, true);
+    }
+    pop() {
+        const popped = this.current;
+        if (this.tmplCount > 0 && this._isInTemplate()) {
+            this.tmplCount--;
+        }
+        this.stackTop--;
+        this._updateCurrentElement();
+        this.handler.onItemPop(popped, true);
+    }
+    replace(oldElement, newElement) {
+        const idx = this._indexOf(oldElement);
+        this.items[idx] = newElement;
+        if (idx === this.stackTop) {
+            this.current = newElement;
+        }
+    }
+    insertAfter(referenceElement, newElement, newElementID) {
+        const insertionIdx = this._indexOf(referenceElement) + 1;
+        this.items.splice(insertionIdx, 0, newElement);
+        this.tagIDs.splice(insertionIdx, 0, newElementID);
+        this.stackTop++;
+        if (insertionIdx === this.stackTop) {
+            this._updateCurrentElement();
+        }
+        if (this.current && this.currentTagId !== undefined) {
+            this.handler.onItemPush(this.current, this.currentTagId, insertionIdx === this.stackTop);
+        }
+    }
+    popUntilTagNamePopped(tagName) {
+        let targetIdx = this.stackTop + 1;
+        do {
+            targetIdx = this.tagIDs.lastIndexOf(tagName, targetIdx - 1);
+        } while (targetIdx > 0 && this.treeAdapter.getNamespaceURI(this.items[targetIdx]) !== NS.HTML);
+        this.shortenToLength(Math.max(targetIdx, 0));
+    }
+    shortenToLength(idx) {
+        while (this.stackTop >= idx) {
+            const popped = this.current;
+            if (this.tmplCount > 0 && this._isInTemplate()) {
+                this.tmplCount -= 1;
+            }
+            this.stackTop--;
+            this._updateCurrentElement();
+            this.handler.onItemPop(popped, this.stackTop < idx);
+        }
+    }
+    popUntilElementPopped(element) {
+        const idx = this._indexOf(element);
+        this.shortenToLength(Math.max(idx, 0));
+    }
+    popUntilPopped(tagNames, targetNS) {
+        const idx = this._indexOfTagNames(tagNames, targetNS);
+        this.shortenToLength(Math.max(idx, 0));
+    }
+    popUntilNumberedHeaderPopped() {
+        this.popUntilPopped(NUMBERED_HEADERS, NS.HTML);
+    }
+    popUntilTableCellPopped() {
+        this.popUntilPopped(TABLE_CELLS, NS.HTML);
+    }
+    popAllUpToHtmlElement() {
+        //NOTE: here we assume that the root <html> element is always first in the open element stack, so
+        //we perform this fast stack clean up.
+        this.tmplCount = 0;
+        this.shortenToLength(1);
+    }
+    _indexOfTagNames(tagNames, namespace) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            if (tagNames.has(this.tagIDs[i]) && this.treeAdapter.getNamespaceURI(this.items[i]) === namespace) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    clearBackTo(tagNames, targetNS) {
+        const idx = this._indexOfTagNames(tagNames, targetNS);
+        this.shortenToLength(idx + 1);
+    }
+    clearBackToTableContext() {
+        this.clearBackTo(TABLE_CONTEXT, NS.HTML);
+    }
+    clearBackToTableBodyContext() {
+        this.clearBackTo(TABLE_BODY_CONTEXT, NS.HTML);
+    }
+    clearBackToTableRowContext() {
+        this.clearBackTo(TABLE_ROW_CONTEXT, NS.HTML);
+    }
+    remove(element) {
+        const idx = this._indexOf(element);
+        if (idx >= 0) {
+            if (idx === this.stackTop) {
+                this.pop();
+            }
+            else {
+                this.items.splice(idx, 1);
+                this.tagIDs.splice(idx, 1);
+                this.stackTop--;
+                this._updateCurrentElement();
+                this.handler.onItemPop(element, false);
+            }
+        }
+    }
+    //Search
+    tryPeekProperlyNestedBodyElement() {
+        //Properly nested <body> element (should be second element in stack).
+        return this.stackTop >= 1 && this.tagIDs[1] === $.BODY ? this.items[1] : null;
+    }
+    contains(element) {
+        return this._indexOf(element) > -1;
+    }
+    getCommonAncestor(element) {
+        const elementIdx = this._indexOf(element) - 1;
+        return elementIdx >= 0 ? this.items[elementIdx] : null;
+    }
+    isRootHtmlElementCurrent() {
+        return this.stackTop === 0 && this.tagIDs[0] === $.HTML;
+    }
+    //Element in scope
+    hasInDynamicScope(tagName, htmlScope) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            switch (this.treeAdapter.getNamespaceURI(this.items[i])) {
+                case NS.HTML: {
+                    if (tn === tagName)
+                        return true;
+                    if (htmlScope.has(tn))
+                        return false;
+                    break;
+                }
+                case NS.SVG: {
+                    if (SCOPING_ELEMENTS_SVG.has(tn))
+                        return false;
+                    break;
+                }
+                case NS.MATHML: {
+                    if (SCOPING_ELEMENTS_MATHML.has(tn))
+                        return false;
+                    break;
+                }
+            }
+        }
+        return true;
+    }
+    hasInScope(tagName) {
+        return this.hasInDynamicScope(tagName, SCOPING_ELEMENTS_HTML);
+    }
+    hasInListItemScope(tagName) {
+        return this.hasInDynamicScope(tagName, SCOPING_ELEMENTS_HTML_LIST);
+    }
+    hasInButtonScope(tagName) {
+        return this.hasInDynamicScope(tagName, SCOPING_ELEMENTS_HTML_BUTTON);
+    }
+    hasNumberedHeaderInScope() {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            switch (this.treeAdapter.getNamespaceURI(this.items[i])) {
+                case NS.HTML: {
+                    if (NUMBERED_HEADERS.has(tn))
+                        return true;
+                    if (SCOPING_ELEMENTS_HTML.has(tn))
+                        return false;
+                    break;
+                }
+                case NS.SVG: {
+                    if (SCOPING_ELEMENTS_SVG.has(tn))
+                        return false;
+                    break;
+                }
+                case NS.MATHML: {
+                    if (SCOPING_ELEMENTS_MATHML.has(tn))
+                        return false;
+                    break;
+                }
+            }
+        }
+        return true;
+    }
+    hasInTableScope(tagName) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            if (this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML) {
+                continue;
+            }
+            switch (this.tagIDs[i]) {
+                case tagName: {
+                    return true;
+                }
+                case $.TABLE:
+                case $.HTML: {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    hasTableBodyContextInTableScope() {
+        for (let i = this.stackTop; i >= 0; i--) {
+            if (this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML) {
+                continue;
+            }
+            switch (this.tagIDs[i]) {
+                case $.TBODY:
+                case $.THEAD:
+                case $.TFOOT: {
+                    return true;
+                }
+                case $.TABLE:
+                case $.HTML: {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    hasInSelectScope(tagName) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            if (this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML) {
+                continue;
+            }
+            switch (this.tagIDs[i]) {
+                case tagName: {
+                    return true;
+                }
+                case $.OPTION:
+                case $.OPTGROUP: {
+                    break;
+                }
+                default: {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    //Implied end tags
+    generateImpliedEndTags() {
+        while (this.currentTagId !== undefined && IMPLICIT_END_TAG_REQUIRED.has(this.currentTagId)) {
+            this.pop();
+        }
+    }
+    generateImpliedEndTagsThoroughly() {
+        while (this.currentTagId !== undefined && IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) {
+            this.pop();
+        }
+    }
+    generateImpliedEndTagsWithExclusion(exclusionId) {
+        while (this.currentTagId !== undefined &&
+            this.currentTagId !== exclusionId &&
+            IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) {
+            this.pop();
+        }
+    }
+}

package/etc/mcp-server/node_modules/parse5/dist/serializer/index.d.ts

@@ -0,0 +1,60 @@
+import type { TreeAdapter, TreeAdapterTypeMap } from '../tree-adapters/interface.js';
+import { type DefaultTreeAdapterMap } from '../tree-adapters/default.js';
+export interface SerializerOptions<T extends TreeAdapterTypeMap> {
+    /**
+     * Specifies input tree format.
+     *
+     * @default `treeAdapters.default`
+     */
+    treeAdapter?: TreeAdapter<T>;
+    /**
+     * The [scripting flag](https://html.spec.whatwg.org/multipage/parsing.html#scripting-flag). If set
+     * to `true`, `noscript` element content will not be escaped.
+     *
+     *  @default `true`
+     */
+    scriptingEnabled?: boolean;
+}
+/**
+ * Serializes an AST node to an HTML string.
+ *
+ * @example
+ *
+ * ```js
+ * const parse5 = require('parse5');
+ *
+ * const document = parse5.parse('<!DOCTYPE html><html><head></head><body>Hi there!</body></html>');
+ *
+ * // Serializes a document.
+ * const html = parse5.serialize(document);
+ *
+ * // Serializes the <html> element content.
+ * const str = parse5.serialize(document.childNodes[1]);
+ *
+ * console.log(str); //> '<head></head><body>Hi there!</body>'
+ * ```
+ *
+ * @param node Node to serialize.
+ * @param options Serialization options.
+ */
+export declare function serialize<T extends TreeAdapterTypeMap = DefaultTreeAdapterMap>(node: T['parentNode'], options?: SerializerOptions<T>): string;
+/**
+ * Serializes an AST element node to an HTML string, including the element node.
+ *
+ * @example
+ *
+ * ```js
+ * const parse5 = require('parse5');
+ *
+ * const document = parse5.parseFragment('<div>Hello, <b>world</b>!</div>');
+ *
+ * // Serializes the <div> element.
+ * const str = parse5.serializeOuter(document.childNodes[0]);
+ *
+ * console.log(str); //> '<div>Hello, <b>world</b>!</div>'
+ * ```
+ *
+ * @param node Node to serialize.
+ * @param options Serialization options.
+ */
+export declare function serializeOuter<T extends TreeAdapterTypeMap = DefaultTreeAdapterMap>(node: T['node'], options?: SerializerOptions<T>): string;

package/etc/mcp-server/node_modules/parse5/dist/serializer/index.js

@@ -0,0 +1,168 @@
+import { TAG_NAMES as $, NS, hasUnescapedText } from '../common/html.js';
+import { escapeText, escapeAttribute } from 'entities/escape';
+import { defaultTreeAdapter } from '../tree-adapters/default.js';
+// Sets
+const VOID_ELEMENTS = new Set([
+    $.AREA,
+    $.BASE,
+    $.BASEFONT,
+    $.BGSOUND,
+    $.BR,
+    $.COL,
+    $.EMBED,
+    $.FRAME,
+    $.HR,
+    $.IMG,
+    $.INPUT,
+    $.KEYGEN,
+    $.LINK,
+    $.META,
+    $.PARAM,
+    $.SOURCE,
+    $.TRACK,
+    $.WBR,
+]);
+function isVoidElement(node, options) {
+    return (options.treeAdapter.isElementNode(node) &&
+        options.treeAdapter.getNamespaceURI(node) === NS.HTML &&
+        VOID_ELEMENTS.has(options.treeAdapter.getTagName(node)));
+}
+const defaultOpts = { treeAdapter: defaultTreeAdapter, scriptingEnabled: true };
+/**
+ * Serializes an AST node to an HTML string.
+ *
+ * @example
+ *
+ * ```js
+ * const parse5 = require('parse5');
+ *
+ * const document = parse5.parse('<!DOCTYPE html><html><head></head><body>Hi there!</body></html>');
+ *
+ * // Serializes a document.
+ * const html = parse5.serialize(document);
+ *
+ * // Serializes the <html> element content.
+ * const str = parse5.serialize(document.childNodes[1]);
+ *
+ * console.log(str); //> '<head></head><body>Hi there!</body>'
+ * ```
+ *
+ * @param node Node to serialize.
+ * @param options Serialization options.
+ */
+export function serialize(node, options) {
+    const opts = { ...defaultOpts, ...options };
+    if (isVoidElement(node, opts)) {
+        return '';
+    }
+    return serializeChildNodes(node, opts);
+}
+/**
+ * Serializes an AST element node to an HTML string, including the element node.
+ *
+ * @example
+ *
+ * ```js
+ * const parse5 = require('parse5');
+ *
+ * const document = parse5.parseFragment('<div>Hello, <b>world</b>!</div>');
+ *
+ * // Serializes the <div> element.
+ * const str = parse5.serializeOuter(document.childNodes[0]);
+ *
+ * console.log(str); //> '<div>Hello, <b>world</b>!</div>'
+ * ```
+ *
+ * @param node Node to serialize.
+ * @param options Serialization options.
+ */
+export function serializeOuter(node, options) {
+    const opts = { ...defaultOpts, ...options };
+    return serializeNode(node, opts);
+}
+function serializeChildNodes(parentNode, options) {
+    let html = '';
+    // Get container of the child nodes
+    const container = options.treeAdapter.isElementNode(parentNode) &&
+        options.treeAdapter.getTagName(parentNode) === $.TEMPLATE &&
+        options.treeAdapter.getNamespaceURI(parentNode) === NS.HTML
+        ? options.treeAdapter.getTemplateContent(parentNode)
+        : parentNode;
+    const childNodes = options.treeAdapter.getChildNodes(container);
+    if (childNodes) {
+        for (const currentNode of childNodes) {
+            html += serializeNode(currentNode, options);
+        }
+    }
+    return html;
+}
+function serializeNode(node, options) {
+    if (options.treeAdapter.isElementNode(node)) {
+        return serializeElement(node, options);
+    }
+    if (options.treeAdapter.isTextNode(node)) {
+        return serializeTextNode(node, options);
+    }
+    if (options.treeAdapter.isCommentNode(node)) {
+        return serializeCommentNode(node, options);
+    }
+    if (options.treeAdapter.isDocumentTypeNode(node)) {
+        return serializeDocumentTypeNode(node, options);
+    }
+    // Return an empty string for unknown nodes
+    return '';
+}
+function serializeElement(node, options) {
+    const tn = options.treeAdapter.getTagName(node);
+    return `<${tn}${serializeAttributes(node, options)}>${isVoidElement(node, options) ? '' : `${serializeChildNodes(node, options)}</${tn}>`}`;
+}
+function serializeAttributes(node, { treeAdapter }) {
+    let html = '';
+    for (const attr of treeAdapter.getAttrList(node)) {
+        html += ' ';
+        if (attr.namespace) {
+            switch (attr.namespace) {
+                case NS.XML: {
+                    html += `xml:${attr.name}`;
+                    break;
+                }
+                case NS.XMLNS: {
+                    if (attr.name !== 'xmlns') {
+                        html += 'xmlns:';
+                    }
+                    html += attr.name;
+                    break;
+                }
+                case NS.XLINK: {
+                    html += `xlink:${attr.name}`;
+                    break;
+                }
+                default: {
+                    html += `${attr.prefix}:${attr.name}`;
+                }
+            }
+        }
+        else {
+            html += attr.name;
+        }
+        html += `="${escapeAttribute(attr.value)}"`;
+    }
+    return html;
+}
+function serializeTextNode(node, options) {
+    const { treeAdapter } = options;
+    const content = treeAdapter.getTextNodeContent(node);
+    const parent = treeAdapter.getParentNode(node);
+    const parentTn = parent && treeAdapter.isElementNode(parent) && treeAdapter.getTagName(parent);
+    return parentTn &&
+        treeAdapter.getNamespaceURI(parent) === NS.HTML &&
+        hasUnescapedText(parentTn, options.scriptingEnabled)
+        ? content
+        : escapeText(content);
+}
+function serializeCommentNode(node, { treeAdapter }) {
+    return `<!--${treeAdapter.getCommentNodeContent(node)}-->`;
+}
+function serializeDocumentTypeNode(node, { treeAdapter }) {
+    return `<!DOCTYPE ${treeAdapter.getDocumentTypeNodeName(node)}>`;
+}