@bquery/bquery 1.1.2 → 1.3.0

package/dist/view/evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../src/view/evaluate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AA4D9C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,QAAO,IAGvC,CAAC;AA8BF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,GAAG,OAAO,EAAE,YAAY,MAAM,EAAE,SAAS,cAAc,KAAG,CAoBnF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,GAAG,OAAO,EAAE,YAAY,MAAM,EAAE,SAAS,cAAc,KAAG,CAiBtF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAAI,YAAY,MAAM,KAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAqG/E,CAAC"}

package/dist/view/index.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Declarative DOM bindings via data attributes.
+ *
+ * This module provides Vue/Svelte-style template directives without
+ * requiring a compiler. Bindings are evaluated at runtime using
+ * bQuery's reactive system. Features include:
+ * - Conditional rendering (bq-if)
+ * - List rendering (bq-for)
+ * - Two-way binding (bq-model)
+ * - Class binding (bq-class)
+ * - Text/HTML binding (bq-text, bq-html)
+ * - Attribute binding (bq-bind)
+ * - Event binding (bq-on)
+ *
+ * ## Security Considerations
+ *
+ * **WARNING:** This module uses `new Function()` to evaluate expressions at runtime.
+ * This is similar to Vue/Alpine's approach but carries inherent security risks:
+ *
+ * - **NEVER** use expressions derived from user input or untrusted sources
+ * - Expressions should only come from developer-controlled templates
+ * - The context object should not contain sensitive data that could be exfiltrated
+ * - For user-generated content, use static bindings with sanitized values instead
+ *
+ * Since bQuery is runtime-only (no build-time compilation), expressions are evaluated
+ * dynamically. If your application loads templates from external sources (APIs, databases),
+ * ensure they are trusted and validated before mounting.
+ *
+ * ## Content Security Policy (CSP) Compatibility
+ *
+ * **IMPORTANT:** This module requires `'unsafe-eval'` in your CSP `script-src` directive.
+ * The `new Function()` constructor used for expression evaluation will be blocked by
+ * strict CSP policies that omit `'unsafe-eval'`.
+ *
+ * ### Required CSP Header
+ * ```
+ * Content-Security-Policy: script-src 'self' 'unsafe-eval';
+ * ```
+ *
+ * ### CSP-Strict Alternatives
+ *
+ * If your application requires a strict CSP without `'unsafe-eval'`, consider these alternatives:
+ *
+ * 1. **Use bQuery's core reactive system directly** - Bind signals to DOM elements manually
+ *    using `effect()` without the view module's template directives:
+ *    ```ts
+ *    import { signal, effect } from 'bquery/reactive';
+ *    import { $ } from 'bquery';
+ *
+ *    const count = signal(0);
+ *    effect(() => {
+ *      $('#counter').text(String(count.value));
+ *    });
+ *    ```
+ *
+ * 2. **Use bQuery's component module** - Web Components with typed props don't require
+ *    dynamic expression evaluation:
+ *    ```ts
+ *    import { component } from 'bquery/component';
+ *    component('my-counter', {
+ *      props: { count: { type: Number } },
+ *      render: ({ props }) => `<span>${props.count}</span>`,
+ *    });
+ *    ```
+ *
+ * 3. **Pre-compile templates at build time** - Use a build step to transform bq-* attributes
+ *    into static JavaScript (similar to Svelte/Vue SFC compilation). This is outside bQuery's
+ *    scope but can be achieved with custom Vite/Rollup plugins.
+ *
+ * The view module is designed for rapid prototyping and applications where CSP flexibility
+ * is acceptable. For security-critical applications requiring strict CSP, use the alternatives above.
+ *
+ * @module bquery/view
+ *
+ * @example
+ * ```html
+ * <div id="app">
+ *   <input bq-model="name" />
+ *   <p bq-text="greeting"></p>
+ *   <ul>
+ *     <li bq-for="item in items" bq-text="item.name"></li>
+ *   </ul>
+ *   <button bq-on:click="handleClick">Click me</button>
+ *   <div bq-if="showDetails" bq-class="{ active: isActive }">
+ *     Details here
+ *   </div>
+ * </div>
+ * ```
+ *
+ * ```ts
+ * import { mount } from 'bquery/view';
+ * import { signal } from 'bquery/reactive';
+ *
+ * mount('#app', {
+ *   name: signal('World'),
+ *   greeting: computed(() => `Hello, ${name.value}!`),
+ *   items: signal([{ name: 'Item 1' }, { name: 'Item 2' }]),
+ *   showDetails: signal(true),
+ *   isActive: signal(false),
+ *   handleClick: () => console.log('Clicked!'),
+ * });
+ * ```
+ */
+export { clearExpressionCache } from './evaluate';
+export { createTemplate, mount } from './mount';
+export type { BindingContext, MountOptions, View } from './types';
+/**
+ * Re-export reactive primitives for convenience.
+ */
+export { batch, computed, effect, signal } from '../reactive/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/view/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/view/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsGG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChD,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAElE;;GAEG;AACH,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/view/mount.d.ts

@@ -0,0 +1,69 @@
+import type { BindingContext, MountOptions, View } from './types';
+/**
+ * Mounts a reactive view to an element.
+ *
+ * @param selector - CSS selector or Element
+ * @param context - Binding context with signals, computed, and functions
+ * @param options - Mount options
+ * @returns The mounted View instance
+ *
+ * @security **WARNING:** Directive expressions (bq-text, bq-if, bq-on, etc.) are evaluated
+ * using `new Function()` at runtime. This means:
+ * - Template attributes must come from trusted sources only
+ * - NEVER load templates containing bq-* attributes from user input or untrusted APIs
+ * - If you must use external templates, validate/sanitize attribute values first
+ *
+ * @example
+ * ```ts
+ * import { mount } from 'bquery/view';
+ * import { signal, computed } from 'bquery/reactive';
+ *
+ * const name = signal('World');
+ * const greeting = computed(() => `Hello, ${name.value}!`);
+ * const items = signal([
+ *   { id: 1, text: 'Item 1' },
+ *   { id: 2, text: 'Item 2' },
+ * ]);
+ *
+ * const view = mount('#app', {
+ *   name,
+ *   greeting,
+ *   items,
+ *   addItem: () => {
+ *     items.value = [...items.value, { id: Date.now(), text: 'New Item' }];
+ *   },
+ * });
+ *
+ * // Later, cleanup
+ * view.destroy();
+ * ```
+ */
+export declare const mount: (selector: string | Element, context: BindingContext, options?: MountOptions) => View;
+/**
+ * Creates a reactive template function.
+ *
+ * @param template - HTML template string
+ * @returns A function that creates a mounted element with the given context
+ *
+ * @example
+ * ```ts
+ * import { createTemplate } from 'bquery/view';
+ * import { signal } from 'bquery/reactive';
+ *
+ * const TodoItem = createTemplate(`
+ *   <li bq-class="{ completed: done }">
+ *     <input type="checkbox" bq-model="done" />
+ *     <span bq-text="text"></span>
+ *   </li>
+ * `);
+ *
+ * const item = TodoItem({
+ *   done: signal(false),
+ *   text: 'Buy groceries',
+ * });
+ *
+ * document.querySelector('#list').append(item.el);
+ * ```
+ */
+export declare const createTemplate: (template: string, options?: MountOptions) => ((context: BindingContext) => View);
+//# sourceMappingURL=mount.d.ts.map

package/dist/view/mount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mount.d.ts","sourceRoot":"","sources":["../../src/view/mount.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,KAAK,GAChB,UAAU,MAAM,GAAG,OAAO,EAC1B,SAAS,cAAc,EACvB,UAAS,YAAiB,KACzB,IA2EF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,cAAc,GACzB,UAAU,MAAM,EAChB,UAAS,YAAiB,KACzB,CAAC,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAiCpC,CAAC"}

package/dist/view/process.d.ts

@@ -0,0 +1,26 @@
+import type { CleanupFn } from '../reactive/index';
+import type { BindingContext, DirectiveHandler } from './types';
+export type DirectiveHandlers = {
+    text: DirectiveHandler;
+    html: DirectiveHandler;
+    if: DirectiveHandler;
+    show: DirectiveHandler;
+    class: DirectiveHandler;
+    style: DirectiveHandler;
+    model: DirectiveHandler;
+    ref: DirectiveHandler;
+    for: DirectiveHandler;
+    bind: (attrName: string) => DirectiveHandler;
+    on: (eventName: string) => DirectiveHandler;
+};
+/**
+ * Processes a single element for directives.
+ * @internal
+ */
+export declare const processElement: (el: Element, context: BindingContext, prefix: string, cleanups: CleanupFn[], handlers: DirectiveHandlers) => void;
+/**
+ * Recursively processes children of an element.
+ * @internal
+ */
+export declare const processChildren: (el: Element, context: BindingContext, prefix: string, cleanups: CleanupFn[], handlers: DirectiveHandlers) => void;
+//# sourceMappingURL=process.d.ts.map

package/dist/view/process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../src/view/process.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,gBAAgB,CAAC;IACvB,EAAE,EAAE,gBAAgB,CAAC;IACrB,IAAI,EAAE,gBAAgB,CAAC;IACvB,KAAK,EAAE,gBAAgB,CAAC;IACxB,KAAK,EAAE,gBAAgB,CAAC;IACxB,KAAK,EAAE,gBAAgB,CAAC;IACxB,GAAG,EAAE,gBAAgB,CAAC;IACtB,GAAG,EAAE,gBAAgB,CAAC;IACtB,IAAI,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,gBAAgB,CAAC;IAC7C,EAAE,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,gBAAgB,CAAC;CAC7C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,GACzB,IAAI,OAAO,EACX,SAAS,cAAc,EACvB,QAAQ,MAAM,EACd,UAAU,SAAS,EAAE,EACrB,UAAU,iBAAiB,KAC1B,IAyCF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,GAC1B,IAAI,OAAO,EACX,SAAS,cAAc,EACvB,QAAQ,MAAM,EACd,UAAU,SAAS,EAAE,EACrB,UAAU,iBAAiB,KAC1B,IAWF,CAAC"}

package/dist/view/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Public types for the view module.
+ */
+import type { CleanupFn } from '../reactive/index';
+/**
+ * Context object passed to binding expressions.
+ */
+export type BindingContext = Record<string, unknown>;
+/**
+ * Configuration options for mount.
+ */
+export type MountOptions = {
+    /** Prefix for directive attributes (default: 'bq') */
+    prefix?: string;
+    /** Whether to sanitize bq-html content (default: true) */
+    sanitize?: boolean;
+};
+/**
+ * Mounted view instance.
+ */
+export type View = {
+    /** The root element */
+    el: Element;
+    /** The binding context */
+    context: BindingContext;
+    /** Update the context object. Note: this only mutates the context; reactive re-rendering happens automatically when signals/computed values change. */
+    update: (newContext: Partial<BindingContext>) => void;
+    /** Destroy the view and cleanup effects */
+    destroy: () => void;
+};
+/**
+ * Internal directive handler type.
+ * @internal
+ */
+export type DirectiveHandler = (el: Element, expression: string, context: BindingContext, cleanups: CleanupFn[]) => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/view/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/view/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,IAAI,GAAG;IACjB,uBAAuB;IACvB,EAAE,EAAE,OAAO,CAAC;IACZ,0BAA0B;IAC1B,OAAO,EAAE,cAAc,CAAC;IACxB,uJAAuJ;IACvJ,MAAM,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,cAAc,CAAC,KAAK,IAAI,CAAC;IACtD,2CAA2C;IAC3C,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC7B,EAAE,EAAE,OAAO,EACX,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,SAAS,EAAE,KAClB,IAAI,CAAC"}

package/dist/view.es.mjs

@@ -0,0 +1,426 @@
+import { a as z, i as V, e as E } from "./type-guards-DRma3-Kc.js";
+import { s as P } from "./core-COenAZjD.js";
+import { c as ye } from "./core-COenAZjD.js";
+import { s as Z } from "./sanitize-1FBEPAFH.js";
+import { b as be } from "./batch-4LAvfLE7.js";
+const N = 500;
+class D {
+  constructor(e) {
+    this.cache = /* @__PURE__ */ new Map(), this.maxSize = e;
+  }
+  get(e) {
+    const s = this.cache.get(e);
+    return s !== void 0 && (this.cache.delete(e), this.cache.set(e, s)), s;
+  }
+  set(e, s) {
+    if (this.cache.has(e))
+      this.cache.delete(e);
+    else if (this.cache.size >= this.maxSize) {
+      const r = this.cache.keys().next().value;
+      r !== void 0 && this.cache.delete(r);
+    }
+    this.cache.set(e, s);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+}
+const O = new D(N), T = new D(N), de = () => {
+  O.clear(), T.clear();
+}, U = (n) => new Proxy(n, {
+  get(e, s) {
+    if (typeof s != "string")
+      return Reflect.get(e, s);
+    const r = e[s];
+    return z(r) || V(r) ? r.value : r;
+  },
+  has(e, s) {
+    return typeof s != "string" ? Reflect.has(e, s) : s in e;
+  }
+}), y = (n, e) => {
+  try {
+    const s = U(e);
+    let r = O.get(n);
+    return r || (r = new Function("$ctx", `with($ctx) { return (${n}); }`), O.set(n, r)), r(s);
+  } catch (s) {
+    console.error(`bQuery view: Error evaluating "${n}"`, s);
+    return;
+  }
+}, q = (n, e) => {
+  try {
+    let s = T.get(n);
+    return s || (s = new Function("$ctx", `with($ctx) { return (${n}); }`), T.set(n, s)), s(e);
+  } catch (s) {
+    console.error(`bQuery view: Error evaluating "${n}"`, s);
+    return;
+  }
+}, _ = (n) => {
+  const e = {}, s = n.trim().replace(/^\{|\}$/g, "").trim();
+  if (!s) return e;
+  const r = [];
+  let t = "", a = 0, i = null;
+  for (let c = 0; c < s.length; c++) {
+    const o = s[c], l = c > 0 ? s[c - 1] : "";
+    if ((o === '"' || o === "'" || o === "`") && l !== "\\") {
+      i === null ? i = o : i === o && (i = null), t += o;
+      continue;
+    }
+    if (i !== null) {
+      t += o;
+      continue;
+    }
+    o === "(" || o === "[" || o === "{" ? (a++, t += o) : o === ")" || o === "]" || o === "}" ? (a--, t += o) : o === "," && a === 0 ? (r.push(t.trim()), t = "") : t += o;
+  }
+  t.trim() && r.push(t.trim());
+  for (const c of r) {
+    let o = -1, l = 0, h = null;
+    for (let u = 0; u < c.length; u++) {
+      const f = c[u], W = u > 0 ? c[u - 1] : "";
+      if ((f === '"' || f === "'" || f === "`") && W !== "\\") {
+        h === null ? h = f : h === f && (h = null);
+        continue;
+      }
+      if (h === null) {
+        if (f === "(" || f === "[" || f === "{")
+          l++;
+        else if (f === ")" || f === "]" || f === "}")
+          l--;
+        else if (f === ":" && l === 0) {
+          o = u;
+          break;
+        }
+      }
+    }
+    if (o > -1) {
+      const u = c.slice(0, o).trim().replace(/^['"]|['"]$/g, ""), f = c.slice(o + 1).trim();
+      e[u] = f;
+    }
+  }
+  return e;
+}, X = (n) => (e, s, r, t) => {
+  const a = E(() => {
+    const i = y(s, r);
+    i == null || i === !1 ? e.removeAttribute(n) : i === !0 ? e.setAttribute(n, "") : e.setAttribute(n, String(i));
+  });
+  t.push(a);
+}, G = (n, e, s, r) => {
+  let t = /* @__PURE__ */ new Set();
+  const a = E(() => {
+    const i = /* @__PURE__ */ new Set();
+    if (e.trimStart().startsWith("{")) {
+      const c = _(e);
+      for (const [o, l] of Object.entries(c)) {
+        const h = y(l, s);
+        n.classList.toggle(o, !!h), i.add(o);
+      }
+    } else if (/^\s*\[/.test(e)) {
+      const c = y(e, s);
+      if (Array.isArray(c))
+        for (const o of c)
+          o && (n.classList.add(o), i.add(o));
+    } else {
+      const c = y(e, s);
+      typeof c == "string" ? c.split(/\s+/).forEach((o) => {
+        o && (n.classList.add(o), i.add(o));
+      }) : Array.isArray(c) && c.forEach((o) => {
+        o && (n.classList.add(o), i.add(o));
+      });
+    }
+    for (const c of t)
+      i.has(c) || n.classList.remove(c);
+    t = i;
+  });
+  r.push(a);
+}, J = (n, e, s, r, t, a) => {
+  if (!s)
+    return e;
+  const i = {
+    ...a,
+    [r]: n
+  };
+  return t && (i[t] = e), y(s, i);
+}, Y = (n) => {
+  const { prefix: e, processElement: s, processChildren: r } = n;
+  return (t, a, i, c) => {
+    const o = t.parentNode;
+    if (!o) return;
+    const l = a.match(/^\(?(\w+)(?:\s*,\s*(\w+))?\)?\s+in\s+(\S.*)$/);
+    if (!l) {
+      console.error(`bQuery view: Invalid bq-for expression "${a}"`);
+      return;
+    }
+    const [, h, u, f] = l, W = t.getAttribute(":key") || t.getAttribute(`${e}-key`), L = t.cloneNode(!0);
+    L.removeAttribute(`${e}-for`), L.removeAttribute(":key"), L.removeAttribute(`${e}-key`);
+    const Q = document.createComment(`bq-for: ${a}`);
+    o.replaceChild(Q, t);
+    let S = /* @__PURE__ */ new Map(), I = [];
+    const F = (d, p, w) => {
+      const C = L.cloneNode(!0), A = [], k = P(d), $ = u ? P(p) : null, m = {
+        ...i,
+        [h]: k
+      };
+      return u && $ && (m[u] = $), s(C, m, e, A), r(C, m, e, A), {
+        key: w,
+        element: C,
+        cleanups: A,
+        item: d,
+        index: p,
+        itemSignal: k,
+        indexSignal: $
+      };
+    }, R = (d) => {
+      for (const p of d.cleanups)
+        p();
+      d.element.remove();
+    }, K = (d, p, w) => {
+      Object.is(d.item, p) || (d.item = p, d.itemSignal.value = p), d.index !== w && (d.index = w, d.indexSignal && (d.indexSignal.value = w));
+    }, B = E(() => {
+      const d = y(f, i);
+      if (!Array.isArray(d)) {
+        for (const m of S.values())
+          R(m);
+        S.clear(), I = [];
+        return;
+      }
+      const p = [], w = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Set();
+      d.forEach((m, v) => {
+        let g = J(m, v, W, h, u, i);
+        C.has(g) && (console.warn(
+          `bq-for: Duplicate key "${String(g)}" detected at index ${v}. Falling back to index-based key for this item. Ensure :key expressions produce unique values for each item.`
+        ), g = { __bqDuplicateKey: g, __bqIndex: v }), C.add(g), p.push(g), w.set(g, { item: m, index: v });
+      });
+      const A = [];
+      for (const m of I)
+        w.has(m) || A.push(m);
+      for (const m of A) {
+        const v = S.get(m);
+        v && (R(v), S.delete(m));
+      }
+      const k = /* @__PURE__ */ new Map();
+      let $ = Q;
+      for (let m = 0; m < p.length; m++) {
+        const v = p[m], { item: g, index: H } = w.get(v);
+        let b = S.get(v);
+        b ? (K(b, g, H), k.set(v, b), $.nextSibling !== b.element && $.after(b.element), $ = b.element) : (b = F(g, H, v), k.set(v, b), $.after(b.element), $ = b.element);
+      }
+      S = k, I = p;
+    });
+    c.push(() => {
+      B();
+      for (const d of S.values())
+        for (const p of d.cleanups)
+          p();
+      S.clear();
+    });
+  };
+}, x = (n) => (e, s, r, t) => {
+  const a = E(() => {
+    const i = y(s, r), c = String(i ?? "");
+    e.innerHTML = n ? Z(c) : c;
+  });
+  t.push(a);
+}, ee = (n, e, s, r) => {
+  const t = document.createComment(`bq-if: ${e}`);
+  let a = !0;
+  const i = E(() => {
+    const c = y(e, s);
+    c && !a ? (t.replaceWith(n), a = !0) : !c && a && (n.replaceWith(t), a = !1);
+  });
+  r.push(i);
+}, te = (n, e, s, r) => {
+  const t = n, a = q(e, s);
+  if (!z(a)) {
+    console.warn(`bQuery view: bq-model requires a signal, got "${e}"`);
+    return;
+  }
+  const i = a, c = t.type === "checkbox", o = t.type === "radio", l = () => {
+    c ? t.checked = !!i.value : o ? t.checked = i.value === t.value : t.value = String(i.value ?? "");
+  }, h = E(() => {
+    l();
+  });
+  r.push(h);
+  const u = t.tagName === "SELECT" ? "change" : "input", f = () => {
+    c ? i.value = t.checked : o ? t.checked && (i.value = t.value) : i.value = t.value;
+  };
+  t.addEventListener(u, f), r.push(() => t.removeEventListener(u, f));
+}, ne = (n) => (e, s, r, t) => {
+  const a = (i) => {
+    const c = { ...r, $event: i, $el: e };
+    if (!s.includes("(")) {
+      const l = q(s, c);
+      if (typeof l == "function") {
+        l(i);
+        return;
+      }
+      return;
+    }
+    q(s, c);
+  };
+  e.addEventListener(n, a), t.push(() => e.removeEventListener(n, a));
+};
+function se(n) {
+  const e = Object.getOwnPropertyDescriptor(n, "value");
+  return e ? "value" in e ? e.writable === !0 : typeof e.set == "function" : !1;
+}
+const re = (n, e, s, r) => {
+  const t = q(
+    e,
+    s
+  );
+  z(t) ? (t.value = n, r.push(() => {
+    t.value = null;
+  })) : typeof t == "object" && t !== null && se(t) && (t.value = n, r.push(() => {
+    t.value = null;
+  }));
+}, oe = (n, e, s, r) => {
+  const t = n;
+  let a = t.style.display;
+  if (!a || a === "none") {
+    const c = t.ownerDocument.defaultView?.getComputedStyle(t).display ?? "";
+    a = c !== "none" ? c : "";
+  }
+  const i = E(() => {
+    const c = y(e, s);
+    t.style.display = c ? a : "none";
+  });
+  r.push(i);
+}, ie = (n, e, s, r) => {
+  const t = n;
+  let a = /* @__PURE__ */ new Set();
+  const i = E(() => {
+    const c = /* @__PURE__ */ new Set();
+    if (e.trimStart().startsWith("{")) {
+      const o = _(e);
+      for (const [l, h] of Object.entries(o)) {
+        const u = y(h, s), f = l.replace(/([A-Z])/g, "-$1").toLowerCase();
+        t.style.setProperty(f, String(u ?? "")), c.add(f);
+      }
+    } else {
+      const o = y(e, s);
+      if (o && typeof o == "object")
+        for (const [l, h] of Object.entries(o)) {
+          const u = l.replace(/([A-Z])/g, "-$1").toLowerCase();
+          t.style.setProperty(u, String(h ?? "")), c.add(u);
+        }
+    }
+    for (const o of a)
+      c.has(o) || t.style.removeProperty(o);
+    a = c;
+  });
+  r.push(i);
+}, ce = (n, e, s, r) => {
+  const t = E(() => {
+    const a = y(e, s);
+    n.textContent = String(a ?? "");
+  });
+  r.push(t);
+}, M = (n, e, s, r, t) => {
+  const a = Array.from(n.attributes);
+  for (const i of a) {
+    const { name: c, value: o } = i;
+    if (!c.startsWith(`${s}-`)) continue;
+    const l = c.slice(s.length + 1);
+    if (l === "for") {
+      t.for(n, o, e, r);
+      return;
+    }
+    if (l === "text")
+      t.text(n, o, e, r);
+    else if (l === "html")
+      t.html(n, o, e, r);
+    else if (l === "if")
+      t.if(n, o, e, r);
+    else if (l === "show")
+      t.show(n, o, e, r);
+    else if (l === "class")
+      t.class(n, o, e, r);
+    else if (l === "style")
+      t.style(n, o, e, r);
+    else if (l === "model")
+      t.model(n, o, e, r);
+    else if (l === "ref")
+      t.ref(n, o, e, r);
+    else if (l.startsWith("bind:")) {
+      const h = l.slice(5);
+      t.bind(h)(n, o, e, r);
+    } else if (l.startsWith("on:")) {
+      const h = l.slice(3);
+      t.on(h)(n, o, e, r);
+    }
+  }
+}, j = (n, e, s, r, t) => {
+  const a = Array.from(n.children);
+  for (const i of a)
+    i.hasAttribute(`${s}-for`) ? M(i, e, s, r, t) : (M(i, e, s, r, t), j(i, e, s, r, t));
+}, ae = (n, e, s = {}) => {
+  const { prefix: r = "bq", sanitize: t = !0 } = s, a = typeof n == "string" ? document.querySelector(n) : n;
+  if (!a)
+    throw new Error(`bQuery view: Element "${n}" not found.`);
+  if (a.hasAttribute(`${r}-for`))
+    throw new Error(
+      `bQuery view: Cannot mount on element with ${r}-for directive. Wrap the ${r}-for element in a container instead.`
+    );
+  const i = [], c = {
+    text: ce,
+    html: x(t),
+    if: ee,
+    show: oe,
+    class: G,
+    style: ie,
+    model: te,
+    ref: re,
+    for: Y({
+      prefix: r,
+      processElement: (l, h, u, f) => M(l, h, u, f, c),
+      processChildren: (l, h, u, f) => j(l, h, u, f, c)
+    }),
+    bind: X,
+    on: ne
+  };
+  return ((l, h, u) => {
+    const f = l.hasAttribute(`${r}-for`);
+    M(l, h, r, u, c), f || j(l, h, r, u, c);
+  })(a, e, i), {
+    el: a,
+    context: e,
+    update: (l) => {
+      Object.assign(e, l);
+    },
+    destroy: () => {
+      for (const l of i)
+        l();
+      i.length = 0;
+    }
+  };
+}, me = (n, e = {}) => (s) => {
+  const r = document.createElement("div");
+  r.innerHTML = n.trim();
+  const t = r.firstElementChild;
+  if (!t)
+    throw new Error("bQuery view: Template must contain a single root element.");
+  if (r.childElementCount > 1)
+    throw new Error(
+      `bQuery view: Template must contain exactly one root element, found ${r.childElementCount}.`
+    );
+  const { prefix: a = "bq" } = e;
+  if (t.hasAttribute(`${a}-for`) || t.hasAttribute(`${a}-if`)) {
+    const i = t.hasAttribute(`${a}-for`) ? "for" : "if";
+    throw new Error(
+      `bQuery view: Template root element cannot have ${a}-${i} directive. Wrap the ${a}-${i} element in a container instead.`
+    );
+  }
+  return ae(t, s, e);
+};
+export {
+  be as batch,
+  de as clearExpressionCache,
+  ye as computed,
+  me as createTemplate,
+  E as effect,
+  ae as mount,
+  P as signal
+};
+//# sourceMappingURL=view.es.mjs.map