@thyn/vite-plugin 0.0.312 → 0.0.314

package/dist/dom.d.ts

@@ -0,0 +1,35 @@
+export declare class Node {
+    nodeType: number;
+    childNodes: Node[];
+    constructor(nodeType: number);
+    get textContent(): string;
+    set textContent(value: string);
+}
+export declare class Text extends Node {
+    private _text;
+    constructor(text: string);
+    get textContent(): string;
+    set textContent(value: string);
+}
+export declare class Element extends Node {
+    tagName: string;
+    attributes: {
+        name: string;
+        value: string;
+    }[];
+    constructor(tagName: string);
+    getAttribute(name: string): string | null;
+    setAttribute(name: string, value: string): void;
+    removeAttribute(name: string): void;
+    hasAttribute(name: string): boolean;
+    get classList(): {
+        add: (className: string) => void;
+    };
+    get children(): Element[];
+    set innerHTML(html: string);
+}
+export declare class DocumentFragment extends Node {
+    constructor();
+    get firstElementChild(): Element | null;
+}
+export declare function parseHTML(html: string): DocumentFragment;

package/dist/dom.js

@@ -0,0 +1,142 @@
+export class Node {
+    constructor(nodeType) {
+        this.childNodes = [];
+        this.nodeType = nodeType;
+    }
+    get textContent() {
+        return this.childNodes.map(node => node.textContent).join('');
+    }
+    set textContent(value) {
+        this.childNodes = [new Text(value)];
+    }
+}
+export class Text extends Node {
+    constructor(text) {
+        super(3); // Node.TEXT_NODE
+        this._text = text;
+    }
+    get textContent() {
+        return this._text;
+    }
+    set textContent(value) {
+        this._text = value;
+    }
+}
+export class Element extends Node {
+    constructor(tagName) {
+        super(1); // Node.ELEMENT_NODE
+        this.attributes = [];
+        this.tagName = tagName;
+    }
+    getAttribute(name) {
+        const attr = this.attributes.find(a => a.name === name);
+        return attr ? attr.value : null;
+    }
+    setAttribute(name, value) {
+        const attr = this.attributes.find(a => a.name === name);
+        if (attr) {
+            attr.value = value;
+        }
+        else {
+            this.attributes.push({ name, value });
+        }
+    }
+    removeAttribute(name) {
+        this.attributes = this.attributes.filter(a => a.name !== name);
+    }
+    hasAttribute(name) {
+        return this.attributes.some(a => a.name === name);
+    }
+    get classList() {
+        return {
+            add: (className) => {
+                const existing = this.getAttribute('class') || '';
+                const classes = existing.split(/\s+/).filter(Boolean);
+                if (!classes.includes(className)) {
+                    classes.push(className);
+                    this.setAttribute('class', classes.join(' '));
+                }
+            }
+        };
+    }
+    get children() {
+        return this.childNodes.filter(node => node.nodeType === 1);
+    }
+    set innerHTML(html) {
+        const fragment = parseHTML(html);
+        this.childNodes = fragment.childNodes;
+    }
+}
+export class DocumentFragment extends Node {
+    constructor() {
+        super(11); // Node.DOCUMENT_FRAGMENT_NODE
+    }
+    get firstElementChild() {
+        return this.childNodes.find(node => node.nodeType === 1) || null;
+    }
+}
+const voidElements = new Set([
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'
+]);
+export function parseHTML(html) {
+    const fragment = new DocumentFragment();
+    const stack = [fragment];
+    const tagRegex = new RegExp('<(?:\\/([a-zA-Z0-9\\-:]+)|([a-zA-Z0-9\\-:]+)((?:[^>"\']|"[^"]*"|\'[^\']*\')*)(\\/)?)>|<!--[\\s\\S]*?-->', 'g');
+    let lastIndex = 0;
+    let match;
+    while ((match = tagRegex.exec(html)) !== null) {
+        const [fullMatch, closeTag, openTag, attrs, selfClosing] = match;
+        const index = match.index;
+        // Process text before the tag
+        if (index > lastIndex) {
+            const textContent = html.slice(lastIndex, index);
+            if (textContent) {
+                stack[stack.length - 1].childNodes.push(new Text(textContent));
+            }
+        }
+        lastIndex = index + fullMatch.length;
+        // Ignore comments
+        if (fullMatch.startsWith('<!--')) {
+            continue;
+        }
+        if (openTag) {
+            const element = new Element(openTag);
+            if (attrs) {
+                // Match attributes: name="value", name='value', name=value, name
+                const attrRegex = /([a-zA-Z0-9\-:@\._#]+)\s*(?:=\s*(?:"([^"]*)"|'([^']*)'|([^"'\s]+)))?/g;
+                let attrMatch;
+                while ((attrMatch = attrRegex.exec(attrs)) !== null) {
+                    const name = attrMatch[1];
+                    const value = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? '';
+                    element.setAttribute(name, value);
+                }
+            }
+            stack[stack.length - 1].childNodes.push(element);
+            const isVoid = voidElements.has(openTag.toLowerCase());
+            const isSelfClosingTag = !!selfClosing;
+            if (!isVoid && !isSelfClosingTag) {
+                stack.push(element);
+            }
+        }
+        else if (closeTag) {
+            // Find the corresponding opening tag in the stack
+            // We search backwards to handle potential malformed HTML gracefully-ish
+            for (let i = stack.length - 1; i > 0; i--) {
+                const node = stack[i];
+                if (node instanceof Element && node.tagName.toLowerCase() === closeTag.toLowerCase()) {
+                    // Found the matching tag, pop everything up to this point
+                    stack.splice(i);
+                    break;
+                }
+            }
+        }
+    }
+    // Process any remaining text
+    if (lastIndex < html.length) {
+        const textContent = html.slice(lastIndex);
+        if (textContent) {
+            stack[stack.length - 1].childNodes.push(new Text(textContent));
+        }
+    }
+    return fragment;
+}

package/dist/html-parser.d.ts

@@ -0,0 +1,31 @@
+interface Node {
+    nodeType: number;
+    nodeName: string;
+    textContent: string;
+    childNodes: Node[];
+}
+interface Element extends Node {
+    tagName: string;
+    attributes: Array<{
+        name: string;
+        value: string;
+    }>;
+    children: Element[];
+    firstElementChild: Element | null;
+    hasAttribute(name: string): boolean;
+    getAttribute(name: string): string | null;
+    setAttribute(name: string, value: string): void;
+    removeAttribute(name: string): void;
+    classList: {
+        add(className: string): void;
+    };
+}
+interface DocumentFragment {
+    childNodes: Node[];
+    firstElementChild: Element | null;
+}
+interface TemplateElement extends Element {
+    content: DocumentFragment;
+}
+export declare function parseHTML(html: string): TemplateElement;
+export {};

package/dist/html-parser.js

@@ -0,0 +1,275 @@
+function parseAttributes(attrStr) {
+    const attrs = [];
+    let i = 0;
+    while (i < attrStr.length) {
+        // Skip whitespace
+        while (i < attrStr.length && /\s/.test(attrStr[i]))
+            i++;
+        if (i >= attrStr.length)
+            break;
+        // Parse attribute name
+        let name = "";
+        while (i < attrStr.length && !/[\s=]/.test(attrStr[i])) {
+            name += attrStr[i];
+            i++;
+        }
+        if (!name)
+            break;
+        // Skip whitespace
+        while (i < attrStr.length && /\s/.test(attrStr[i]))
+            i++;
+        let value = "";
+        if (i < attrStr.length && attrStr[i] === "=") {
+            i++; // skip '='
+            // Skip whitespace
+            while (i < attrStr.length && /\s/.test(attrStr[i]))
+                i++;
+            if (i < attrStr.length) {
+                const quote = attrStr[i];
+                if (quote === '"' || quote === "'") {
+                    i++; // skip opening quote
+                    while (i < attrStr.length && attrStr[i] !== quote) {
+                        value += attrStr[i];
+                        i++;
+                    }
+                    if (i < attrStr.length)
+                        i++; // skip closing quote
+                }
+                else {
+                    // Unquoted value - take until whitespace
+                    while (i < attrStr.length && !/\s/.test(attrStr[i])) {
+                        value += attrStr[i];
+                        i++;
+                    }
+                }
+            }
+        }
+        attrs.push({ name, value });
+    }
+    return attrs;
+}
+function createTextNode(text) {
+    return {
+        nodeType: 3,
+        nodeName: "#text",
+        textContent: text,
+        childNodes: [],
+    };
+}
+function createElement(tagName, attributes = []) {
+    const children = [];
+    const childNodes = [];
+    const element = {
+        nodeType: 1,
+        nodeName: tagName.toUpperCase(),
+        tagName: tagName.toUpperCase(),
+        textContent: "",
+        attributes: [...attributes],
+        children,
+        childNodes,
+        firstElementChild: null,
+        hasAttribute(name) {
+            return this.attributes.some((attr) => attr.name === name);
+        },
+        getAttribute(name) {
+            const attr = this.attributes.find((attr) => attr.name === name);
+            return attr ? attr.value : null;
+        },
+        setAttribute(name, value) {
+            const existing = this.attributes.find((attr) => attr.name === name);
+            if (existing) {
+                existing.value = value;
+            }
+            else {
+                this.attributes.push({ name, value });
+            }
+        },
+        removeAttribute(name) {
+            this.attributes = this.attributes.filter((attr) => attr.name !== name);
+        },
+        classList: {
+            add: (className) => {
+                const existing = element.getAttribute("class");
+                const classes = existing ? existing.split(" ").filter(Boolean) : [];
+                if (!classes.includes(className)) {
+                    classes.push(className);
+                    element.setAttribute("class", classes.join(" "));
+                }
+            },
+        },
+    };
+    return element;
+}
+// Find next tag position, properly handling quoted strings
+function findNextTag(html, startIndex) {
+    let i = startIndex;
+    while (i < html.length) {
+        // Find the next '<'
+        while (i < html.length && html[i] !== '<') {
+            i++;
+        }
+        if (i >= html.length)
+            return null;
+        const tagStart = i;
+        i++; // skip '<'
+        // Check if it's a closing tag
+        const isClose = i < html.length && html[i] === '/';
+        if (isClose)
+            i++;
+        // Parse tag name
+        let tagName = '';
+        while (i < html.length && /[a-zA-Z0-9-]/.test(html[i])) {
+            tagName += html[i];
+            i++;
+        }
+        if (!tagName) {
+            // Not a valid tag, continue searching
+            i = tagStart + 1;
+            continue;
+        }
+        // Parse attributes, respecting quotes
+        let attrs = '';
+        let inQuote = null;
+        let tagEnd = -1;
+        while (i < html.length) {
+            const char = html[i];
+            if (inQuote) {
+                attrs += char;
+                if (char === inQuote) {
+                    inQuote = null;
+                }
+                i++;
+            }
+            else if (char === '"' || char === "'") {
+                attrs += char;
+                inQuote = char;
+                i++;
+            }
+            else if (char === '>') {
+                tagEnd = i + 1; // Include the '>'
+                i++;
+                break;
+            }
+            else {
+                attrs += char;
+                i++;
+            }
+        }
+        if (tagEnd === -1) {
+            // Malformed tag (no closing >), continue searching
+            i = tagStart + 1;
+            continue;
+        }
+        // Check for self-closing
+        const trimmedAttrs = attrs.trim();
+        const isSelfClose = trimmedAttrs.endsWith('/');
+        const finalAttrs = isSelfClose ? trimmedAttrs.slice(0, -1).trim() : trimmedAttrs;
+        return {
+            index: tagStart,
+            endIndex: tagEnd,
+            isClose,
+            tagName,
+            attrs: finalAttrs,
+            isSelfClose
+        };
+    }
+    return null;
+}
+export function parseHTML(html) {
+    const match = html.match(/<template([^>]*)>([\s\S]*)<\/template>/i);
+    if (!match) {
+        throw new Error("No <template> tag found in HTML");
+    }
+    const content = match[2].trim();
+    const stack = [];
+    const textChunks = [];
+    const fragmentChildren = [];
+    const fragmentElements = [];
+    let pos = 0;
+    const flushText = () => {
+        if (textChunks.length > 0) {
+            const text = textChunks.join("");
+            textChunks.length = 0;
+            const textNode = createTextNode(text);
+            if (stack.length > 0) {
+                const parent = stack[stack.length - 1];
+                parent.childNodes.push(textNode);
+            }
+            else {
+                fragmentChildren.push(textNode);
+            }
+        }
+    };
+    while (pos < content.length) {
+        const tagInfo = findNextTag(content, pos);
+        if (!tagInfo) {
+            // No more tags, add remaining as text
+            if (pos < content.length) {
+                textChunks.push(content.slice(pos));
+            }
+            break;
+        }
+        // Add text before this tag
+        if (tagInfo.index > pos) {
+            textChunks.push(content.slice(pos, tagInfo.index));
+        }
+        const { isClose, tagName, attrs, isSelfClose, endIndex } = tagInfo;
+        if (isClose) {
+            flushText();
+            if (stack.length > 0) {
+                const closedElement = stack.pop();
+                if (closedElement.tagName.toLowerCase() !== tagName.toLowerCase()) {
+                    throw new Error(`Mismatched tags: expected </${closedElement.tagName}>, got </${tagName}>`);
+                }
+                // Update parent's firstElementChild if needed
+                const parent = stack.length > 0 ? stack[stack.length - 1] : null;
+                if (parent && !parent.firstElementChild) {
+                    parent.firstElementChild = closedElement;
+                }
+            }
+        }
+        else {
+            flushText();
+            const attributes = parseAttributes(attrs);
+            const element = createElement(tagName, attributes);
+            if (stack.length === 0) {
+                // Top-level element
+                fragmentChildren.push(element);
+                fragmentElements.push(element);
+            }
+            else {
+                const parent = stack[stack.length - 1];
+                parent.children.push(element);
+                parent.childNodes.push(element);
+                if (!parent.firstElementChild) {
+                    parent.firstElementChild = element;
+                }
+            }
+            if (!isSelfClose) {
+                stack.push(element);
+            }
+        }
+        // Move position past this tag
+        pos = endIndex;
+    }
+    // Flush any remaining text
+    if (stack.length === 0) {
+        flushText();
+    }
+    if (stack.length > 0) {
+        throw new Error(`Unclosed tags remain: ${stack.map(e => e.tagName).join(', ')}`);
+    }
+    const fragment = {
+        childNodes: fragmentChildren,
+        firstElementChild: fragmentElements[0] || null,
+    };
+    const templateAttrs = parseAttributes(match[1].trim());
+    const templateElement = {
+        ...createElement("template", templateAttrs),
+        content: fragment,
+    };
+    templateElement.childNodes = [...fragmentChildren];
+    templateElement.children = [...fragmentElements];
+    templateElement.firstElementChild = fragmentElements[0] || null;
+    return templateElement;
+}