@derivesome/tree 0.1.1

package/dist/esm/velement.js

@@ -0,0 +1,874 @@
+"use strict";
+// virtual-dom.ts
+// A lightweight virtual DOM implementation for unit testing browser code without a real browser.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VEvent = exports.VDocument = exports.VDocumentFragment = exports.VElement = exports.VStyle = exports.VClassList = exports.VComment = exports.VText = exports.VNode = exports.NodeType = void 0;
+exports.toHTML = toHTML;
+exports.createDocument = createDocument;
+// ---------------------------------------------------------------------------
+// Node type constants (mirrors the real DOM)
+// ---------------------------------------------------------------------------
+var NodeType;
+(function (NodeType) {
+    NodeType[NodeType["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
+    NodeType[NodeType["TEXT_NODE"] = 3] = "TEXT_NODE";
+    NodeType[NodeType["COMMENT_NODE"] = 8] = "COMMENT_NODE";
+    NodeType[NodeType["DOCUMENT_NODE"] = 9] = "DOCUMENT_NODE";
+    NodeType[NodeType["DOCUMENT_TYPE_NODE"] = 10] = "DOCUMENT_TYPE_NODE";
+    NodeType[NodeType["DOCUMENT_FRAGMENT_NODE"] = 11] = "DOCUMENT_FRAGMENT_NODE";
+})(NodeType || (exports.NodeType = NodeType = {}));
+// ---------------------------------------------------------------------------
+// VNode — abstract base for every node
+// ---------------------------------------------------------------------------
+class VNode {
+    parentNode = null;
+    childNodes = [];
+    ownerDocument = null;
+    get firstChild() {
+        return this.childNodes[0] ?? null;
+    }
+    get lastChild() {
+        return this.childNodes[this.childNodes.length - 1] ?? null;
+    }
+    get nextSibling() {
+        if (!this.parentNode)
+            return null;
+        const siblings = this.parentNode.childNodes;
+        const idx = siblings.indexOf(this);
+        return siblings[idx + 1] ?? null;
+    }
+    get previousSibling() {
+        if (!this.parentNode)
+            return null;
+        const siblings = this.parentNode.childNodes;
+        const idx = siblings.indexOf(this);
+        return idx > 0 ? (siblings[idx - 1] ?? null) : null;
+    }
+    get parentElement() {
+        return this.parentNode instanceof VElement ? this.parentNode : null;
+    }
+    // ---- Mutation helpers ----
+    appendChild(child) {
+        this._removeFromParent(child);
+        child.parentNode = this;
+        child.ownerDocument = this.ownerDocument;
+        this.childNodes.push(child);
+        return child;
+    }
+    insertBefore(newChild, refChild) {
+        if (refChild === null)
+            return this.appendChild(newChild);
+        const idx = this.childNodes.indexOf(refChild);
+        if (idx === -1)
+            throw new Error("refChild is not a child of this node");
+        this._removeFromParent(newChild);
+        newChild.parentNode = this;
+        newChild.ownerDocument = this.ownerDocument;
+        this.childNodes.splice(idx, 0, newChild);
+        return newChild;
+    }
+    removeChild(child) {
+        const idx = this.childNodes.indexOf(child);
+        if (idx === -1)
+            throw new Error("Node is not a child of this node");
+        this.childNodes.splice(idx, 1);
+        child.parentNode = null;
+        return child;
+    }
+    replaceChild(newChild, oldChild) {
+        const idx = this.childNodes.indexOf(oldChild);
+        if (idx === -1)
+            throw new Error("oldChild is not a child of this node");
+        this._removeFromParent(newChild);
+        newChild.parentNode = this;
+        newChild.ownerDocument = this.ownerDocument;
+        this.childNodes.splice(idx, 1, newChild);
+        oldChild.parentNode = null;
+        return oldChild;
+    }
+    hasChildNodes() {
+        return this.childNodes.length > 0;
+    }
+    contains(other) {
+        if (!other)
+            return false;
+        let current = other;
+        while (current) {
+            if (current === this)
+                return true;
+            current = current.parentNode;
+        }
+        return false;
+    }
+    cloneNode(deep = false) {
+        return this._clone(deep);
+    }
+    /** Remove a node from its current parent before re-parenting. */
+    _removeFromParent(child) {
+        if (child.parentNode) {
+            child.parentNode.removeChild(child);
+        }
+    }
+}
+exports.VNode = VNode;
+// ---------------------------------------------------------------------------
+// VText
+// ---------------------------------------------------------------------------
+class VText extends VNode {
+    data;
+    nodeType = NodeType.TEXT_NODE;
+    nodeName = "#text";
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    get textContent() {
+        return this.data;
+    }
+    set textContent(value) {
+        this.data = value ?? "";
+    }
+    get nodeValue() {
+        return this.data;
+    }
+    set nodeValue(value) {
+        this.data = value ?? "";
+    }
+    _clone(_deep) {
+        return new VText(this.data);
+    }
+}
+exports.VText = VText;
+// ---------------------------------------------------------------------------
+// VComment
+// ---------------------------------------------------------------------------
+class VComment extends VNode {
+    data;
+    nodeType = NodeType.COMMENT_NODE;
+    nodeName = "#comment";
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    get textContent() {
+        return this.data;
+    }
+    set textContent(value) {
+        this.data = value ?? "";
+    }
+    get nodeValue() {
+        return this.data;
+    }
+    set nodeValue(value) {
+        this.data = value ?? "";
+    }
+    _clone(_deep) {
+        return new VComment(this.data);
+    }
+}
+exports.VComment = VComment;
+// ---------------------------------------------------------------------------
+// Attr map — case-insensitive for HTML-like behaviour
+// ---------------------------------------------------------------------------
+class AttributeMap {
+    _map = new Map();
+    get(name) {
+        return this._map.get(name.toLowerCase()) ?? null;
+    }
+    set(name, value) {
+        this._map.set(name.toLowerCase(), value);
+    }
+    has(name) {
+        return this._map.has(name.toLowerCase());
+    }
+    remove(name) {
+        return this._map.delete(name.toLowerCase());
+    }
+    entries() {
+        return this._map.entries();
+    }
+    get size() {
+        return this._map.size;
+    }
+    clone() {
+        const copy = new AttributeMap();
+        for (const [k, v] of this._map)
+            copy._map.set(k, v);
+        return copy;
+    }
+}
+// ---------------------------------------------------------------------------
+// ClassList — minimal DOMTokenList stand-in
+// ---------------------------------------------------------------------------
+class VClassList {
+    _el;
+    constructor(_el) {
+        this._el = _el;
+    }
+    _tokens() {
+        const raw = this._el.getAttribute("class") ?? "";
+        return raw.split(/\s+/).filter(Boolean);
+    }
+    _write(tokens) {
+        this._el.setAttribute("class", tokens.join(" "));
+    }
+    add(...tokens) {
+        const set = new Set(this._tokens());
+        for (const t of tokens)
+            set.add(t);
+        this._write([...set]);
+    }
+    remove(...tokens) {
+        const set = new Set(this._tokens());
+        for (const t of tokens)
+            set.delete(t);
+        this._write([...set]);
+    }
+    toggle(token, force) {
+        const set = new Set(this._tokens());
+        const shouldAdd = force !== undefined ? force : !set.has(token);
+        if (shouldAdd) {
+            set.add(token);
+        }
+        else {
+            set.delete(token);
+        }
+        this._write([...set]);
+        return shouldAdd;
+    }
+    contains(token) {
+        return this._tokens().includes(token);
+    }
+    replace(oldToken, newToken) {
+        const tokens = this._tokens();
+        const idx = tokens.indexOf(oldToken);
+        if (idx === -1)
+            return false;
+        tokens.splice(idx, 1, newToken);
+        this._write(tokens);
+        return true;
+    }
+    get length() {
+        return this._tokens().length;
+    }
+    toString() {
+        return this._tokens().join(" ");
+    }
+}
+exports.VClassList = VClassList;
+// ---------------------------------------------------------------------------
+// Style — minimal CSSStyleDeclaration stand-in
+// ---------------------------------------------------------------------------
+class VStyle {
+    // @ts-ignore
+    _props = new Map();
+    getPropertyValue(name) {
+        return this._props.get(name) ?? "";
+    }
+    setProperty(name, value) {
+        if (value === null || value === "") {
+            this._props.delete(name);
+        }
+        else {
+            this._props.set(name, value);
+        }
+    }
+    removeProperty(name) {
+        const old = this._props.get(name) ?? "";
+        this._props.delete(name);
+        return old;
+    }
+    get cssText() {
+        return [...this._props.entries()].map(([k, v]) => `${k}: ${v};`).join(" ");
+    }
+    set cssText(value) {
+        this._props.clear();
+        if (!value)
+            return;
+        for (const decl of value.split(";")) {
+            const colon = decl.indexOf(":");
+            if (colon === -1)
+                continue;
+            const prop = decl.slice(0, colon).trim();
+            const val = decl.slice(colon + 1).trim();
+            if (prop)
+                this._props.set(prop, val);
+        }
+    }
+}
+exports.VStyle = VStyle;
+// ---------------------------------------------------------------------------
+// VElement
+// ---------------------------------------------------------------------------
+class VElement extends VNode {
+    nodeType = NodeType.ELEMENT_NODE;
+    tagName;
+    classList;
+    style;
+    _attrs = new AttributeMap();
+    _eventListeners = new Map();
+    _dataset = {};
+    constructor(tagName) {
+        super();
+        this.tagName = tagName.toUpperCase();
+        this.classList = new VClassList(this);
+        this.style = new VStyle();
+        // Return a proxy so element.id, element.className etc. work naturally
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                // Built-in properties first
+                if (prop in target || typeof prop === "symbol") {
+                    return Reflect.get(target, prop, receiver);
+                }
+                // Fallback: treat as an attribute shorthand (e.g. el.id, el.href)
+                if (typeof prop === "string") {
+                    return target.getAttribute(prop) ?? undefined;
+                }
+                return undefined;
+            },
+            set(target, prop, value, receiver) {
+                if (prop in target || typeof prop === "symbol") {
+                    return Reflect.set(target, prop, value, receiver);
+                }
+                if (typeof prop === "string") {
+                    target.setAttribute(prop, String(value));
+                    return true;
+                }
+                return false;
+            },
+        });
+    }
+    get nodeName() {
+        return this.tagName;
+    }
+    // ---- id / className shortcuts ----
+    get id() {
+        return this.getAttribute("id") ?? "";
+    }
+    set id(value) {
+        this.setAttribute("id", value);
+    }
+    get className() {
+        return this.getAttribute("class") ?? "";
+    }
+    set className(value) {
+        this.setAttribute("class", value);
+    }
+    // ---- dataset ----
+    get dataset() {
+        return this._dataset;
+    }
+    // ---- textContent / innerHTML ----
+    get textContent() {
+        return this.childNodes.map((c) => c.textContent ?? "").join("");
+    }
+    set textContent(value) {
+        this.childNodes = [];
+        if (value) {
+            this.appendChild(new VText(value));
+        }
+    }
+    get innerHTML() {
+        return this.childNodes.map((c) => serializeNode(c)).join("");
+    }
+    set innerHTML(html) {
+        // Minimal: just set the raw text. A real implementation would parse HTML.
+        this.childNodes = [];
+        if (html) {
+            this.appendChild(new VText(html));
+        }
+    }
+    get outerHTML() {
+        return serializeNode(this);
+    }
+    // ---- Attributes ----
+    getAttribute(name) {
+        return this._attrs.get(name);
+    }
+    setAttribute(name, value) {
+        this._attrs.set(name, value);
+        // Keep dataset in sync
+        if (name.startsWith("data-")) {
+            this._dataset[camelCase(name.slice(5))] = value;
+        }
+    }
+    removeAttribute(name) {
+        this._attrs.remove(name);
+        if (name.startsWith("data-")) {
+            delete this._dataset[camelCase(name.slice(5))];
+        }
+    }
+    hasAttribute(name) {
+        return this._attrs.has(name);
+    }
+    getAttributeNames() {
+        return [...this._attrs.entries()].map(([k]) => k);
+    }
+    // ---- Query helpers ----
+    getElementById(id) {
+        return this._query((el) => el.getAttribute("id") === id);
+    }
+    getElementsByClassName(className) {
+        const target = className.trim();
+        return this._queryAll((el) => el.classList.contains(target));
+    }
+    getElementsByTagName(tag) {
+        const upper = tag.toUpperCase();
+        return this._queryAll((el) => upper === "*" || el.tagName === upper);
+    }
+    querySelector(selector) {
+        return this._query(makeSimpleMatcher(selector));
+    }
+    querySelectorAll(selector) {
+        return this._queryAll(makeSimpleMatcher(selector));
+    }
+    closest(selector) {
+        const matcher = makeSimpleMatcher(selector);
+        let current = this;
+        while (current) {
+            if (current instanceof VElement && matcher(current)) {
+                return current;
+            }
+            current = current.parentNode;
+        }
+        return null;
+    }
+    matches(selector) {
+        return makeSimpleMatcher(selector)(this);
+    }
+    // ---- Events (record & replay for testing) ----
+    addEventListener(type, listener) {
+        let list = this._eventListeners.get(type);
+        if (!list) {
+            list = [];
+            this._eventListeners.set(type, list);
+        }
+        list.push(listener);
+    }
+    removeEventListener(type, listener) {
+        const arr = this._eventListeners.get(type);
+        if (!arr)
+            return;
+        const idx = arr.indexOf(listener);
+        if (idx !== -1)
+            arr.splice(idx, 1);
+    }
+    dispatchEvent(event) {
+        const listeners = this._eventListeners.get(event.type) ?? [];
+        for (const l of listeners) {
+            if (typeof l === "function")
+                l(event);
+            else
+                l.handleEvent(event);
+        }
+        return true;
+    }
+    /** Click shorthand — dispatches a "click" VEvent. */
+    click() {
+        this.dispatchEvent(new VEvent("click"));
+    }
+    // ---- Children helpers ----
+    get children() {
+        return this.childNodes.filter((c) => c instanceof VElement);
+    }
+    get childElementCount() {
+        return this.children.length;
+    }
+    get firstElementChild() {
+        return this.children[0] ?? null;
+    }
+    get lastElementChild() {
+        const ch = this.children;
+        return ch[ch.length - 1] ?? null;
+    }
+    // ---- Clone ----
+    _clone(deep) {
+        const el = new VElement(this.tagName);
+        el._attrs = this._attrs.clone();
+        el._dataset = { ...this._dataset };
+        el.style.cssText = this.style.cssText;
+        if (deep) {
+            for (const child of this.childNodes) {
+                el.appendChild(child.cloneNode(true));
+            }
+        }
+        return el;
+    }
+    // ---- Internal query helpers ----
+    _query(pred) {
+        for (const child of this.childNodes) {
+            if (child instanceof VElement) {
+                if (pred(child))
+                    return child;
+                const found = child._query(pred);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    _queryAll(pred) {
+        const results = [];
+        for (const child of this.childNodes) {
+            if (child instanceof VElement) {
+                if (pred(child))
+                    results.push(child);
+                results.push(...child._queryAll(pred));
+            }
+        }
+        return results;
+    }
+}
+exports.VElement = VElement;
+// ---------------------------------------------------------------------------
+// VDocumentFragment
+// ---------------------------------------------------------------------------
+class VDocumentFragment extends VNode {
+    nodeType = NodeType.DOCUMENT_FRAGMENT_NODE;
+    nodeName = "#document-fragment";
+    get textContent() {
+        return this.childNodes.map((c) => c.textContent ?? "").join("");
+    }
+    set textContent(value) {
+        this.childNodes = [];
+        if (value)
+            this.appendChild(new VText(value));
+    }
+    _clone(deep) {
+        const frag = new VDocumentFragment();
+        if (deep) {
+            for (const child of this.childNodes) {
+                frag.appendChild(child.cloneNode(true));
+            }
+        }
+        return frag;
+    }
+}
+exports.VDocumentFragment = VDocumentFragment;
+// ---------------------------------------------------------------------------
+// VDocument
+// ---------------------------------------------------------------------------
+class VDocument extends VNode {
+    nodeType = NodeType.DOCUMENT_NODE;
+    nodeName = "#document";
+    body;
+    head;
+    documentElement;
+    constructor() {
+        super();
+        this.ownerDocument = this;
+        this.documentElement = this._make("html");
+        this.head = this._make("head");
+        this.body = this._make("body");
+        this.documentElement.appendChild(this.head);
+        this.documentElement.appendChild(this.body);
+        this.appendChild(this.documentElement);
+    }
+    get textContent() {
+        return null; // matches real DOM behaviour
+    }
+    set textContent(_value) {
+        // no-op for Document, matches real DOM
+    }
+    createElement(tagName) {
+        const el = new VElement(tagName);
+        el.ownerDocument = this;
+        return el;
+    }
+    createTextNode(data) {
+        const t = new VText(data);
+        t.ownerDocument = this;
+        return t;
+    }
+    createComment(data) {
+        const c = new VComment(data);
+        c.ownerDocument = this;
+        return c;
+    }
+    createDocumentFragment() {
+        const f = new VDocumentFragment();
+        f.ownerDocument = this;
+        return f;
+    }
+    getElementById(id) {
+        return this.documentElement.getElementById(id);
+    }
+    getElementsByClassName(className) {
+        return this.documentElement.getElementsByClassName(className);
+    }
+    getElementsByTagName(tag) {
+        return this.documentElement.getElementsByTagName(tag);
+    }
+    querySelector(selector) {
+        return this.documentElement.querySelector(selector);
+    }
+    querySelectorAll(selector) {
+        return this.documentElement.querySelectorAll(selector);
+    }
+    _clone(deep) {
+        const doc = new VDocument();
+        if (deep) {
+            // Already has html > head + body structure; skip re-creating
+        }
+        return doc;
+    }
+    _make(tag) {
+        const el = new VElement(tag);
+        el.ownerDocument = this;
+        return el;
+    }
+}
+exports.VDocument = VDocument;
+// ---------------------------------------------------------------------------
+// VEvent — lightweight Event stand-in
+// ---------------------------------------------------------------------------
+class VEvent {
+    type;
+    bubbles;
+    cancelable;
+    defaultPrevented = false;
+    target = null;
+    currentTarget = null;
+    constructor(type, opts = {}) {
+        this.type = type;
+        this.bubbles = opts.bubbles ?? false;
+        this.cancelable = opts.cancelable ?? false;
+    }
+    preventDefault() {
+        if (this.cancelable)
+            this.defaultPrevented = true;
+    }
+    stopPropagation() {
+        /* noop for now */
+    }
+    stopImmediatePropagation() {
+        /* noop for now */
+    }
+}
+exports.VEvent = VEvent;
+// ---------------------------------------------------------------------------
+// Serialization helper  (outerHTML / innerHTML / toHTML)
+// ---------------------------------------------------------------------------
+const VOID_ELEMENTS = new Set([
+    "AREA",
+    "BASE",
+    "BR",
+    "COL",
+    "EMBED",
+    "HR",
+    "IMG",
+    "INPUT",
+    "LINK",
+    "META",
+    "PARAM",
+    "SOURCE",
+    "TRACK",
+    "WBR",
+]);
+/** Flat serialization used by innerHTML / outerHTML (no indentation). */
+function serializeNode(node) {
+    if (node instanceof VText)
+        return escapeHtml(node.data);
+    if (node instanceof VComment)
+        return `<!--${node.data}-->`;
+    if (node instanceof VElement) {
+        const tag = node.tagName.toLowerCase();
+        let attrs = "";
+        for (const name of node.getAttributeNames()) {
+            const val = node.getAttribute(name) ?? "";
+            attrs += ` ${name}="${escapeAttr(val)}"`;
+        }
+        if (VOID_ELEMENTS.has(node.tagName)) {
+            return `<${tag}${attrs} />`;
+        }
+        const inner = node.childNodes.map(serializeNode).join("");
+        return `<${tag}${attrs}>${inner}</${tag}>`;
+    }
+    if (node instanceof VDocumentFragment) {
+        return node.childNodes.map(serializeNode).join("");
+    }
+    if (node instanceof VDocument) {
+        return "<!DOCTYPE html>\n" + node.childNodes.map(serializeNode).join("");
+    }
+    return "";
+}
+// ---------------------------------------------------------------------------
+// Pretty-printed serialization (used by toHTML)
+// ---------------------------------------------------------------------------
+/** Elements whose content is purely inline and should stay on one line. */
+const INLINE_ELEMENTS = new Set([
+    "A",
+    "ABBR",
+    "B",
+    "BDO",
+    "BR",
+    "CITE",
+    "CODE",
+    "DFN",
+    "EM",
+    "I",
+    "KBD",
+    "LABEL",
+    "MAP",
+    "Q",
+    "S",
+    "SAMP",
+    "SMALL",
+    "SPAN",
+    "STRONG",
+    "SUB",
+    "SUP",
+    "TEXTAREA",
+    "TIME",
+    "U",
+    "VAR",
+]);
+/**
+ * Returns `true` when every child is either a text node or an inline element
+ * that itself contains only text / inline children. In that case we render
+ * the element on a single line to avoid awkward whitespace inside e.g.
+ * `<p>Hello <b>world</b></p>`.
+ */
+function isInlineContent(node) {
+    return node.childNodes.every((child) => {
+        if (child instanceof VText)
+            return true;
+        if (child instanceof VElement && INLINE_ELEMENTS.has(child.tagName)) {
+            return isInlineContent(child);
+        }
+        return false;
+    });
+}
+function prettyPrint(node, depth, indent) {
+    const pad = indent.repeat(depth);
+    if (node instanceof VText) {
+        const trimmed = node.data.trim();
+        return trimmed.length > 0 ? pad + escapeHtml(trimmed) : "";
+    }
+    if (node instanceof VComment) {
+        return `${pad}<!--${node.data}-->`;
+    }
+    if (node instanceof VElement) {
+        const tag = node.tagName.toLowerCase();
+        let attrs = "";
+        for (const name of node.getAttributeNames()) {
+            const val = node.getAttribute(name) ?? "";
+            attrs += ` ${name}="${escapeAttr(val)}"`;
+        }
+        // Self-closing / void
+        if (VOID_ELEMENTS.has(node.tagName)) {
+            return `${pad}<${tag}${attrs} />`;
+        }
+        // No children
+        if (node.childNodes.length === 0) {
+            return `${pad}<${tag}${attrs}></${tag}>`;
+        }
+        // Inline content — keep on one line
+        if (isInlineContent(node)) {
+            const inner = node.childNodes.map((c) => serializeNode(c)).join("");
+            return `${pad}<${tag}${attrs}>${inner}</${tag}>`;
+        }
+        // Block content — children on separate indented lines
+        const children = node.childNodes
+            .map((c) => prettyPrint(c, depth + 1, indent))
+            .filter(Boolean)
+            .join("\n");
+        return `${pad}<${tag}${attrs}>\n${children}\n${pad}</${tag}>`;
+    }
+    if (node instanceof VDocumentFragment) {
+        return node.childNodes
+            .map((c) => prettyPrint(c, depth, indent))
+            .filter(Boolean)
+            .join("\n");
+    }
+    if (node instanceof VDocument) {
+        const children = node.childNodes
+            .map((c) => prettyPrint(c, depth, indent))
+            .filter(Boolean)
+            .join("\n");
+        return `<!DOCTYPE html>\n${children}`;
+    }
+    return "";
+}
+/**
+ * Convert any virtual DOM node to an HTML string.
+ *
+ * @param node   The node to serialise.
+ * @param indent Indentation per level (default: `"  "` — two spaces).
+ *               Pass `""` for compact / non-indented output.
+ *
+ * - `VDocument`         → `<!DOCTYPE html>\n<html>…</html>`
+ * - `VElement`          → `<tag attrs>\n  …children…\n</tag>`
+ * - `VText`             → escaped text content
+ * - `VComment`          → `<!--…-->`
+ * - `VDocumentFragment` → concatenated children
+ */
+function toHTML(node, indent = "  ") {
+    if (indent === "")
+        return serializeNode(node);
+    return prettyPrint(node, 0, indent);
+}
+function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(s) {
+    return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+// ---------------------------------------------------------------------------
+// Very small CSS-selector matcher (covers the common cases)
+//   Supports: tag, .class, #id, [attr], [attr=value], and combos thereof
+// ---------------------------------------------------------------------------
+function makeSimpleMatcher(selector) {
+    // Split on commas for ,‑separated selectors
+    const parts = selector.split(",").map((s) => s.trim());
+    const matchers = parts.map(parseSingleSelector);
+    return (el) => matchers.some((m) => m(el));
+}
+function parseSingleSelector(sel) {
+    const checks = [];
+    // Tag name (must be at the start, before any # . or [)
+    const tagMatch = sel.match(/^([a-zA-Z][a-zA-Z0-9-]*)/);
+    if (tagMatch) {
+        const tag = tagMatch[1].toUpperCase();
+        checks.push((el) => el.tagName === tag);
+    }
+    // #id
+    for (const m of sel.matchAll(/#([a-zA-Z0-9_-]+)/g)) {
+        const id = m[1];
+        checks.push((el) => el.getAttribute("id") === id);
+    }
+    // .class
+    for (const m of sel.matchAll(/\.([a-zA-Z0-9_-]+)/g)) {
+        const cls = m[1];
+        checks.push((el) => el.classList.contains(cls));
+    }
+    // [attr] and [attr=value] and [attr="value"]
+    for (const m of sel.matchAll(/\[([a-zA-Z0-9_-]+)(?:=["']?([^"'\]]*)["']?)?\]/g)) {
+        const attr = m[1];
+        const val = m[2];
+        if (val !== undefined) {
+            checks.push((el) => el.getAttribute(attr) === val);
+        }
+        else {
+            checks.push((el) => el.hasAttribute(attr));
+        }
+    }
+    if (checks.length === 0) {
+        return () => false;
+    }
+    return (el) => checks.every((fn) => fn(el));
+}
+// ---------------------------------------------------------------------------
+// Utility
+// ---------------------------------------------------------------------------
+function camelCase(s) {
+    return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+// ---------------------------------------------------------------------------
+// Convenience factory (drop-in for tests)
+// ---------------------------------------------------------------------------
+/** Create a fresh virtual document, ready to use like `window.document`. */
+function createDocument() {
+    return new VDocument();
+}
+//# sourceMappingURL=velement.js.map