@bquery/bquery 1.0.2 → 1.1.0

package/dist/index.d.ts

@@ -5,7 +5,7 @@
  * and build-step frameworks with modern features.
  *
  * @module bquery
- * @see https://github.com/your-org/bquery
+ * @see https://github.com/bquery/bquery
  */
 export * from './core/index';
 export * from './reactive/index';

package/dist/index.es.mjs

@@ -1,43 +1,48 @@
-import { $ as i, $$ as r, BQueryCollection as s, BQueryElement as o, utils as p } from "./core.es.mjs";
-import { Computed as n, Signal as c, batch as l, computed as m, effect as f, persistedSignal as u, signal as g } from "./reactive.es.mjs";
-import { component as x, html as T, safeHtml as y } from "./component.es.mjs";
-import { capturePosition as H, flip as P, flipList as S, spring as z, springPresets as C, transition as $ } from "./motion.es.mjs";
-import { createTrustedHtml as B, escapeHtml as Q, generateNonce as k, getTrustedTypesPolicy as v, hasCSPDirective as D, isTrustedTypesSupported as E, sanitize as L, sanitize as N, stripTags as j } from "./security.es.mjs";
-import { buckets as w, cache as A, notifications as F, storage as G } from "./platform.es.mjs";
+import { $ as i, $$ as r, BQueryCollection as s, BQueryElement as o, utils as a } from "./core.es.mjs";
+import { Computed as p, Signal as c, batch as l, computed as m, effect as u, isComputed as f, isSignal as g, persistedSignal as d, readonly as x, signal as y, untrack as T, watch as h } from "./reactive.es.mjs";
+import { component as C, html as H, safeHtml as P } from "./component.es.mjs";
+import { capturePosition as $, flip as b, flipList as k, spring as B, springPresets as Q, transition as v } from "./motion.es.mjs";
+import { createTrustedHtml as D, escapeHtml as E, generateNonce as L, getTrustedTypesPolicy as N, hasCSPDirective as j, isTrustedTypesSupported as q, sanitize as A, sanitize as F, stripTags as G } from "./security.es.mjs";
+import { buckets as J, cache as K, notifications as M, storage as O } from "./platform.es.mjs";
 export {
   i as $,
   r as $$,
   s as BQueryCollection,
   o as BQueryElement,
-  n as Computed,
+  p as Computed,
   c as Signal,
   l as batch,
-  w as buckets,
-  A as cache,
-  H as capturePosition,
-  x as component,
+  J as buckets,
+  K as cache,
+  $ as capturePosition,
+  C as component,
   m as computed,
-  B as createTrustedHtml,
-  f as effect,
-  Q as escapeHtml,
-  P as flip,
-  S as flipList,
-  k as generateNonce,
-  v as getTrustedTypesPolicy,
-  D as hasCSPDirective,
-  T as html,
-  E as isTrustedTypesSupported,
-  F as notifications,
-  u as persistedSignal,
-  y as safeHtml,
-  L as sanitize,
-  N as sanitizeHtml,
-  g as signal,
-  z as spring,
-  C as springPresets,
-  G as storage,
-  j as stripTags,
-  $ as transition,
-  p as utils
+  D as createTrustedHtml,
+  u as effect,
+  E as escapeHtml,
+  b as flip,
+  k as flipList,
+  L as generateNonce,
+  N as getTrustedTypesPolicy,
+  j as hasCSPDirective,
+  H as html,
+  f as isComputed,
+  g as isSignal,
+  q as isTrustedTypesSupported,
+  M as notifications,
+  d as persistedSignal,
+  x as readonly,
+  P as safeHtml,
+  A as sanitize,
+  F as sanitizeHtml,
+  y as signal,
+  B as spring,
+  Q as springPresets,
+  O as storage,
+  G as stripTags,
+  v as transition,
+  T as untrack,
+  a as utils,
+  h as watch
 };
 //# sourceMappingURL=index.es.mjs.map

package/dist/reactive/index.d.ts

@@ -3,6 +3,6 @@
  *
  * @module bquery/reactive
  */
-export { batch, Computed, computed, effect, persistedSignal, Signal, signal } from './signal';
-export type { CleanupFn, Observer } from './signal';
+export { Computed, Signal, batch, computed, effect, isComputed, isSignal, persistedSignal, readonly, signal, untrack, watch, } from './signal';
+export type { CleanupFn, Observer, ReadonlySignal } from './signal';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reactive/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAE9F,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reactive/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,QAAQ,EACR,MAAM,EACN,KAAK,EACL,QAAQ,EACR,MAAM,EACN,UAAU,EACV,QAAQ,EACR,eAAe,EACf,QAAQ,EACR,MAAM,EACN,OAAO,EACP,KAAK,GACN,MAAM,UAAU,CAAC;AAElB,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC"}

package/dist/reactive/signal.d.ts

@@ -61,6 +61,7 @@ export declare class Signal<T> {
     constructor(_value: T);
     /**
      * Gets the current value and tracks the read if inside an observer.
+     * Respects the global tracking state (disabled during untrack calls).
      */
     get value(): T;
     /**
@@ -201,4 +202,110 @@ export declare const batch: (fn: () => void) => void;
  * ```
  */
 export declare const persistedSignal: <T>(key: string, initialValue: T) => Signal<T>;
+/**
+ * A readonly wrapper around a signal that prevents writes.
+ * Provides read-only access to a signal's value while maintaining reactivity.
+ *
+ * @template T - The type of the wrapped value
+ */
+export interface ReadonlySignal<T> {
+    /** Gets the current value with dependency tracking. */
+    readonly value: T;
+    /** Gets the current value without dependency tracking. */
+    peek(): T;
+}
+/**
+ * Creates a read-only view of a signal.
+ * Useful for exposing reactive state without allowing modifications.
+ *
+ * @template T - The type of the signal value
+ * @param sig - The signal to wrap
+ * @returns A readonly signal wrapper
+ *
+ * @example
+ * ```ts
+ * const _count = signal(0);
+ * const count = readonly(_count); // Expose read-only version
+ *
+ * console.log(count.value); // 0
+ * count.value = 1; // TypeScript error: Cannot assign to 'value'
+ * ```
+ */
+export declare const readonly: <T>(sig: Signal<T>) => ReadonlySignal<T>;
+/**
+ * Watches a signal or computed value and calls a callback with old and new values.
+ * Unlike effect, watch provides access to the previous value.
+ *
+ * @template T - The type of the watched value
+ * @param source - The signal or computed to watch
+ * @param callback - Function called with (newValue, oldValue) on changes
+ * @param options - Watch options
+ * @returns A cleanup function to stop watching
+ *
+ * @example
+ * ```ts
+ * const count = signal(0);
+ *
+ * const cleanup = watch(count, (newVal, oldVal) => {
+ *   console.log(`Changed from ${oldVal} to ${newVal}`);
+ * });
+ *
+ * count.value = 5; // Logs: "Changed from 0 to 5"
+ * cleanup();
+ * ```
+ */
+export declare const watch: <T>(source: Signal<T> | Computed<T>, callback: (newValue: T, oldValue: T | undefined) => void, options?: {
+    immediate?: boolean;
+}) => CleanupFn;
+/**
+ * Executes a function without tracking any signal dependencies.
+ * Useful when reading a signal value without creating a reactive dependency.
+ *
+ * @template T - The return type of the function
+ * @param fn - The function to execute without tracking
+ * @returns The result of the function
+ *
+ * @example
+ * ```ts
+ * const count = signal(0);
+ *
+ * effect(() => {
+ *   // This creates a dependency
+ *   console.log('Tracked:', count.value);
+ *
+ *   // This does NOT create a dependency
+ *   const untracked = untrack(() => otherSignal.value);
+ * });
+ * ```
+ */
+export declare const untrack: <T>(fn: () => T) => T;
+/**
+ * Type guard to check if a value is a Signal instance.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Signal
+ *
+ * @example
+ * ```ts
+ * const count = signal(0);
+ * const num = 42;
+ *
+ * isSignal(count); // true
+ * isSignal(num);   // false
+ * ```
+ */
+export declare const isSignal: (value: unknown) => value is Signal<unknown>;
+/**
+ * Type guard to check if a value is a Computed instance.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Computed
+ *
+ * @example
+ * ```ts
+ * const doubled = computed(() => count.value * 2);
+ * isComputed(doubled); // true
+ * ```
+ */
+export declare const isComputed: (value: unknown) => value is Computed<unknown>;
 //# sourceMappingURL=signal.d.ts.map

package/dist/reactive/signal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/reactive/signal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC;AAElC;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC;AA2CnC;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,MAAM,CAAC,CAAC;IAOP,OAAO,CAAC,MAAM;IAN1B,OAAO,CAAC,WAAW,CAAuB;IAE1C;;;OAGG;gBACiB,MAAM,EAAE,CAAC;IAE7B;;OAEG;IACH,IAAI,KAAK,IAAI,CAAC,CAMb;IAED;;;OAGG;IACH,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,EAMhB;IAED;;;;;OAKG;IACH,IAAI,IAAI,CAAC;IAIT;;;;;OAKG;IACH,MAAM,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI;CAGzC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,QAAQ,CAAC,CAAC;IAeT,OAAO,CAAC,QAAQ,CAAC,OAAO;IAdpC,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAKxB;IAEF;;;OAGG;gBAC0B,OAAO,EAAE,MAAM,CAAC;IAE7C;;OAEG;IACH,IAAI,KAAK,IAAI,CAAC,CAUb;CACF;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,MAAM,CAAC,CAAC,CAAsB,CAAC;AAEpE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,IAAI,MAAM,CAAC,KAAG,QAAQ,CAAC,CAAC,CAAqB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,MAAM,GAAI,IAAI,MAAM,IAAI,GAAG,SAAS,KAAG,SAwBnD,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,GAAI,IAAI,MAAM,IAAI,KAAG,IAUtC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,KAAK,MAAM,EAAE,cAAc,CAAC,KAAG,MAAM,CAAC,CAAC,CAwBzE,CAAC"}
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../src/reactive/signal.ts"],"names":[],"mappings":"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"}

package/dist/reactive.es.mjs

@@ -1,45 +1,52 @@
-let r = [], c = 0;
-const n = /* @__PURE__ */ new Set(), a = (e, t) => {
-  r = [...r, e];
+const i = [];
+let u = 0;
+const o = /* @__PURE__ */ new Set();
+let a = !0;
+const l = (t, e) => {
+  i.push(t);
   try {
-    return t();
+    return e();
   } finally {
-    r = r.slice(0, -1);
+    i.pop();
   }
-}, l = (e) => {
-  if (c > 0) {
-    n.add(e);
+}, h = (t) => {
+  if (u > 0) {
+    o.add(t);
     return;
   }
-  e();
-}, o = () => {
-  for (const e of Array.from(n))
-    n.delete(e), e();
+  t();
+}, v = () => {
+  for (const t of Array.from(o))
+    o.delete(t), t();
 };
-class h {
+class f {
   /**
    * Creates a new signal with an initial value.
    * @param _value - The initial value
    */
-  constructor(t) {
-    this._value = t, this.subscribers = /* @__PURE__ */ new Set();
+  constructor(e) {
+    this._value = e, this.subscribers = /* @__PURE__ */ new Set();
   }
   /**
    * Gets the current value and tracks the read if inside an observer.
+   * Respects the global tracking state (disabled during untrack calls).
    */
   get value() {
-    const t = r[r.length - 1];
-    return t && this.subscribers.add(t), this._value;
+    if (a) {
+      const e = i[i.length - 1];
+      e && this.subscribers.add(e);
+    }
+    return this._value;
   }
   /**
    * Sets a new value and notifies all subscribers if the value changed.
    * Uses Object.is for equality comparison.
    */
-  set value(t) {
-    if (!Object.is(this._value, t)) {
-      this._value = t;
+  set value(e) {
+    if (!Object.is(this._value, e)) {
+      this._value = e;
       for (const s of this.subscribers)
-        l(s);
+        h(s);
     }
   }
   /**
@@ -57,67 +64,97 @@ class h {
    *
    * @param updater - Function that receives current value and returns new value
    */
-  update(t) {
-    this.value = t(this._value);
+  update(e) {
+    this.value = e(this._value);
   }
 }
-class f {
+class d {
   /**
    * Creates a new computed value.
    * @param compute - Function that computes the value
    */
-  constructor(t) {
-    this.compute = t, this.dirty = !0, this.subscribers = /* @__PURE__ */ new Set(), this.markDirty = () => {
+  constructor(e) {
+    this.compute = e, this.dirty = !0, this.subscribers = /* @__PURE__ */ new Set(), this.markDirty = () => {
       this.dirty = !0;
       for (const s of this.subscribers)
-        l(s);
+        h(s);
     };
   }
   /**
    * Gets the computed value, recomputing if dependencies changed.
    */
   get value() {
-    const t = r[r.length - 1];
-    return t && this.subscribers.add(t), this.dirty && (this.dirty = !1, this.cachedValue = a(this.markDirty, this.compute)), this.cachedValue;
+    const e = i[i.length - 1];
+    return e && this.subscribers.add(e), this.dirty && (this.dirty = !1, this.cachedValue = l(this.markDirty, this.compute)), this.cachedValue;
   }
 }
-const b = (e) => new h(e), v = (e) => new f(e), d = (e) => {
-  let t, s = !1;
-  const i = () => {
-    s || (t && t(), t = a(i, e));
+const p = (t) => new f(t), g = (t) => new d(t), b = (t) => {
+  let e, s = !1;
+  const r = () => {
+    s || (e && e(), e = l(r, t));
   };
-  return i(), () => {
-    s = !0, t && t();
+  return r(), () => {
+    s = !0, e && e();
   };
-}, g = (e) => {
-  c += 1;
+}, y = (t) => {
+  u += 1;
   try {
-    e();
+    t();
   } finally {
-    c -= 1, c === 0 && o();
+    u -= 1, u === 0 && v();
   }
-}, p = (e, t) => {
-  let s = t;
+}, m = (t, e) => {
+  let s = e;
   try {
-    const u = localStorage.getItem(e);
-    u !== null && (s = JSON.parse(u));
+    const n = localStorage.getItem(t);
+    n !== null && (s = JSON.parse(n));
   } catch {
   }
-  const i = b(s);
-  return d(() => {
+  const r = p(s);
+  return b(() => {
     try {
-      localStorage.setItem(e, JSON.stringify(i.value));
+      localStorage.setItem(t, JSON.stringify(r.value));
     } catch {
     }
-  }), i;
-};
+  }), r;
+}, S = (t) => ({
+  get value() {
+    return t.value;
+  },
+  peek() {
+    return t.peek();
+  }
+}), k = (t, e, s = {}) => {
+  let r, n = !0;
+  return b(() => {
+    const c = t.value;
+    if (n) {
+      n = !1, r = c, s.immediate && e(c, void 0);
+      return;
+    }
+    e(c, r), r = c;
+  });
+}, w = (t) => {
+  const e = a;
+  a = !1;
+  try {
+    return t();
+  } finally {
+    a = e;
+  }
+}, O = (t) => t instanceof f, _ = (t) => t instanceof d;
 export {
-  f as Computed,
-  h as Signal,
-  g as batch,
-  v as computed,
-  d as effect,
-  p as persistedSignal,
-  b as signal
+  d as Computed,
+  f as Signal,
+  y as batch,
+  g as computed,
+  b as effect,
+  _ as isComputed,
+  O as isSignal,
+  m as persistedSignal,
+  S as readonly,
+  p as signal,
+  w as untrack,
+  k as watch
 };
 //# sourceMappingURL=reactive.es.mjs.map

package/dist/reactive.es.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"reactive.es.mjs","sources":["../src/reactive/signal.ts"],"sourcesContent":["/**\n * Reactive primitives inspired by fine-grained reactivity.\n *\n * This module provides a minimal but powerful reactive system:\n * - Signal: A reactive value that notifies subscribers when changed\n * - Computed: A derived value that automatically updates when dependencies change\n * - Effect: A side effect that re-runs when its dependencies change\n * - Batch: Group multiple updates to prevent intermediate re-renders\n *\n * @module bquery/reactive\n *\n * @example\n * ```ts\n * const count = signal(0);\n * const doubled = computed(() => count.value * 2);\n *\n * effect(() => {\n *   console.log(`Count: ${count.value}, Doubled: ${doubled.value}`);\n * });\n *\n * batch(() => {\n *   count.value = 1;\n *   count.value = 2;\n * });\n * // Logs: \"Count: 2, Doubled: 4\" (only once due to batching)\n * ```\n */\n\n/**\n * Observer function type used internally for tracking reactivity.\n */\nexport type Observer = () => void;\n\n/**\n * Cleanup function returned by effects for disposal.\n */\nexport type CleanupFn = () => void;\n\n// Internal state for tracking the current observer context\nlet observerStack: Observer[] = [];\nlet batchDepth = 0;\nconst pendingObservers = new Set<Observer>();\n\n/**\n * Tracks dependencies during a function execution.\n * @internal\n */\nconst track = <T>(observer: Observer, fn: () => T): T => {\n  observerStack = [...observerStack, observer];\n  try {\n    return fn();\n  } finally {\n    observerStack = observerStack.slice(0, -1);\n  }\n};\n\n/**\n * Schedules an observer to run, respecting batch mode.\n * @internal\n */\nconst scheduleObserver = (observer: Observer) => {\n  if (batchDepth > 0) {\n    pendingObservers.add(observer);\n    return;\n  }\n  observer();\n};\n\n/**\n * Flushes all pending observers after a batch completes.\n * @internal\n */\nconst flushObservers = () => {\n  for (const observer of Array.from(pendingObservers)) {\n    pendingObservers.delete(observer);\n    observer();\n  }\n};\n\n/**\n * A reactive value container that notifies subscribers on change.\n *\n * Signals are the foundational primitive of the reactive system.\n * Reading a signal's value inside an effect or computed automatically\n * establishes a reactive dependency.\n *\n * @template T - The type of the stored value\n *\n * @example\n * ```ts\n * const name = signal('World');\n * console.log(name.value); // 'World'\n *\n * name.value = 'bQuery';\n * console.log(name.value); // 'bQuery'\n * ```\n */\nexport class Signal<T> {\n  private subscribers = new Set<Observer>();\n\n  /**\n   * Creates a new signal with an initial value.\n   * @param _value - The initial value\n   */\n  constructor(private _value: T) {}\n\n  /**\n   * Gets the current value and tracks the read if inside an observer.\n   */\n  get value(): T {\n    const current = observerStack[observerStack.length - 1];\n    if (current) {\n      this.subscribers.add(current);\n    }\n    return this._value;\n  }\n\n  /**\n   * Sets a new value and notifies all subscribers if the value changed.\n   * Uses Object.is for equality comparison.\n   */\n  set value(next: T) {\n    if (Object.is(this._value, next)) return;\n    this._value = next;\n    for (const subscriber of this.subscribers) {\n      scheduleObserver(subscriber);\n    }\n  }\n\n  /**\n   * Reads the current value without tracking.\n   * Useful when you need the value but don't want to create a dependency.\n   *\n   * @returns The current value\n   */\n  peek(): T {\n    return this._value;\n  }\n\n  /**\n   * Updates the value using a function.\n   * Useful for updates based on the current value.\n   *\n   * @param updater - Function that receives current value and returns new value\n   */\n  update(updater: (current: T) => T): void {\n    this.value = updater(this._value);\n  }\n}\n\n/**\n * A computed value that derives from other reactive sources.\n *\n * Computed values are lazily evaluated and cached. They only\n * recompute when their dependencies change.\n *\n * @template T - The type of the computed value\n *\n * @example\n * ```ts\n * const price = signal(100);\n * const quantity = signal(2);\n * const total = computed(() => price.value * quantity.value);\n *\n * console.log(total.value); // 200\n * price.value = 150;\n * console.log(total.value); // 300\n * ```\n */\nexport class Computed<T> {\n  private cachedValue!: T;\n  private dirty = true;\n  private subscribers = new Set<Observer>();\n  private readonly markDirty = () => {\n    this.dirty = true;\n    for (const subscriber of this.subscribers) {\n      scheduleObserver(subscriber);\n    }\n  };\n\n  /**\n   * Creates a new computed value.\n   * @param compute - Function that computes the value\n   */\n  constructor(private readonly compute: () => T) {}\n\n  /**\n   * Gets the computed value, recomputing if dependencies changed.\n   */\n  get value(): T {\n    const current = observerStack[observerStack.length - 1];\n    if (current) {\n      this.subscribers.add(current);\n    }\n    if (this.dirty) {\n      this.dirty = false;\n      this.cachedValue = track(this.markDirty, this.compute);\n    }\n    return this.cachedValue;\n  }\n}\n\n/**\n * Creates a new reactive signal.\n *\n * @template T - The type of the signal value\n * @param value - The initial value\n * @returns A new Signal instance\n *\n * @example\n * ```ts\n * const count = signal(0);\n * count.value++; // Triggers subscribers\n * ```\n */\nexport const signal = <T>(value: T): Signal<T> => new Signal(value);\n\n/**\n * Creates a new computed value.\n *\n * @template T - The type of the computed value\n * @param fn - Function that computes the value from reactive sources\n * @returns A new Computed instance\n *\n * @example\n * ```ts\n * const doubled = computed(() => count.value * 2);\n * ```\n */\nexport const computed = <T>(fn: () => T): Computed<T> => new Computed(fn);\n\n/**\n * Creates a side effect that automatically re-runs when dependencies change.\n *\n * The effect runs immediately upon creation and then re-runs whenever\n * any signal or computed value read inside it changes.\n *\n * @param fn - The effect function to run\n * @returns A cleanup function to stop the effect\n *\n * @example\n * ```ts\n * const count = signal(0);\n *\n * const cleanup = effect(() => {\n *   document.title = `Count: ${count.value}`;\n * });\n *\n * // Later, to stop the effect:\n * cleanup();\n * ```\n */\nexport const effect = (fn: () => void | CleanupFn): CleanupFn => {\n  let cleanupFn: CleanupFn | void;\n  let isDisposed = false;\n\n  const observer: Observer = () => {\n    if (isDisposed) return;\n\n    // Run previous cleanup if exists\n    if (cleanupFn) {\n      cleanupFn();\n    }\n\n    // Run effect and capture cleanup\n    cleanupFn = track(observer, fn);\n  };\n\n  observer();\n\n  return () => {\n    isDisposed = true;\n    if (cleanupFn) {\n      cleanupFn();\n    }\n  };\n};\n\n/**\n * Batches multiple signal updates into a single notification cycle.\n *\n * Updates made inside the batch function are deferred until the batch\n * completes, preventing intermediate re-renders and improving performance.\n *\n * @param fn - Function containing multiple signal updates\n *\n * @example\n * ```ts\n * batch(() => {\n *   firstName.value = 'John';\n *   lastName.value = 'Doe';\n *   age.value = 30;\n * });\n * // Effects only run once with all three updates\n * ```\n */\nexport const batch = (fn: () => void): void => {\n  batchDepth += 1;\n  try {\n    fn();\n  } finally {\n    batchDepth -= 1;\n    if (batchDepth === 0) {\n      flushObservers();\n    }\n  }\n};\n\n/**\n * Creates a signal that persists to localStorage.\n *\n * @template T - The type of the signal value\n * @param key - The localStorage key\n * @param initialValue - The initial value if not found in storage\n * @returns A Signal that syncs with localStorage\n *\n * @example\n * ```ts\n * const theme = persistedSignal('theme', 'light');\n * theme.value = 'dark'; // Automatically saved to localStorage\n * ```\n */\nexport const persistedSignal = <T>(key: string, initialValue: T): Signal<T> => {\n  let stored: T = initialValue;\n\n  try {\n    const raw = localStorage.getItem(key);\n    if (raw !== null) {\n      stored = JSON.parse(raw) as T;\n    }\n  } catch {\n    // Use initial value on parse error\n  }\n\n  const sig = signal(stored);\n\n  // Create an effect to persist changes\n  effect(() => {\n    try {\n      localStorage.setItem(key, JSON.stringify(sig.value));\n    } catch {\n      // Ignore storage errors\n    }\n  });\n\n  return sig;\n};\n"],"names":["observerStack","batchDepth","pendingObservers","track","observer","fn","scheduleObserver","flushObservers","Signal","_value","current","next","subscriber","updater","Computed","compute","signal","value","computed","effect","cleanupFn","isDisposed","batch","persistedSignal","key","initialValue","stored","raw","sig"],"mappings":"AAuCA,IAAIA,IAA4B,CAAA,GAC5BC,IAAa;AACjB,MAAMC,wBAAuB,IAAA,GAMvBC,IAAQ,CAAIC,GAAoBC,MAAmB;AACvD,EAAAL,IAAgB,CAAC,GAAGA,GAAeI,CAAQ;AAC3C,MAAI;AACF,WAAOC,EAAA;AAAA,EACT,UAAA;AACE,IAAAL,IAAgBA,EAAc,MAAM,GAAG,EAAE;AAAA,EAC3C;AACF,GAMMM,IAAmB,CAACF,MAAuB;AAC/C,MAAIH,IAAa,GAAG;AAClB,IAAAC,EAAiB,IAAIE,CAAQ;AAC7B;AAAA,EACF;AACA,EAAAA,EAAA;AACF,GAMMG,IAAiB,MAAM;AAC3B,aAAWH,KAAY,MAAM,KAAKF,CAAgB;AAChD,IAAAA,EAAiB,OAAOE,CAAQ,GAChCA,EAAA;AAEJ;AAoBO,MAAMI,EAAU;AAAA;AAAA;AAAA;AAAA;AAAA,EAOrB,YAAoBC,GAAW;AAAX,SAAA,SAAAA,GANpB,KAAQ,kCAAkB,IAAA;AAAA,EAMM;AAAA;AAAA;AAAA;AAAA,EAKhC,IAAI,QAAW;AACb,UAAMC,IAAUV,EAAcA,EAAc,SAAS,CAAC;AACtD,WAAIU,KACF,KAAK,YAAY,IAAIA,CAAO,GAEvB,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,MAAMC,GAAS;AACjB,QAAI,QAAO,GAAG,KAAK,QAAQA,CAAI,GAC/B;AAAA,WAAK,SAASA;AACd,iBAAWC,KAAc,KAAK;AAC5B,QAAAN,EAAiBM,CAAU;AAAA;AAAA,EAE/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAU;AACR,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAOC,GAAkC;AACvC,SAAK,QAAQA,EAAQ,KAAK,MAAM;AAAA,EAClC;AACF;AAqBO,MAAMC,EAAY;AAAA;AAAA;AAAA;AAAA;AAAA,EAevB,YAA6BC,GAAkB;AAAlB,SAAA,UAAAA,GAb7B,KAAQ,QAAQ,IAChB,KAAQ,kCAAkB,IAAA,GAC1B,KAAiB,YAAY,MAAM;AACjC,WAAK,QAAQ;AACb,iBAAWH,KAAc,KAAK;AAC5B,QAAAN,EAAiBM,CAAU;AAAA,IAE/B;AAAA,EAMgD;AAAA;AAAA;AAAA;AAAA,EAKhD,IAAI,QAAW;AACb,UAAMF,IAAUV,EAAcA,EAAc,SAAS,CAAC;AACtD,WAAIU,KACF,KAAK,YAAY,IAAIA,CAAO,GAE1B,KAAK,UACP,KAAK,QAAQ,IACb,KAAK,cAAcP,EAAM,KAAK,WAAW,KAAK,OAAO,IAEhD,KAAK;AAAA,EACd;AACF;AAeO,MAAMa,IAAS,CAAIC,MAAwB,IAAIT,EAAOS,CAAK,GAcrDC,IAAW,CAAIb,MAA6B,IAAIS,EAAST,CAAE,GAuB3Dc,IAAS,CAACd,MAA0C;AAC/D,MAAIe,GACAC,IAAa;AAEjB,QAAMjB,IAAqB,MAAM;AAC/B,IAAIiB,MAGAD,KACFA,EAAA,GAIFA,IAAYjB,EAAMC,GAAUC,CAAE;AAAA,EAChC;AAEA,SAAAD,EAAA,GAEO,MAAM;AACX,IAAAiB,IAAa,IACTD,KACFA,EAAA;AAAA,EAEJ;AACF,GAoBaE,IAAQ,CAACjB,MAAyB;AAC7C,EAAAJ,KAAc;AACd,MAAI;AACF,IAAAI,EAAA;AAAA,EACF,UAAA;AACE,IAAAJ,KAAc,GACVA,MAAe,KACjBM,EAAA;AAAA,EAEJ;AACF,GAgBagB,IAAkB,CAAIC,GAAaC,MAA+B;AAC7E,MAAIC,IAAYD;AAEhB,MAAI;AACF,UAAME,IAAM,aAAa,QAAQH,CAAG;AACpC,IAAIG,MAAQ,SACVD,IAAS,KAAK,MAAMC,CAAG;AAAA,EAE3B,QAAQ;AAAA,EAER;AAEA,QAAMC,IAAMZ,EAAOU,CAAM;AAGzB,SAAAP,EAAO,MAAM;AACX,QAAI;AACF,mBAAa,QAAQK,GAAK,KAAK,UAAUI,EAAI,KAAK,CAAC;AAAA,IACrD,QAAQ;AAAA,IAER;AAAA,EACF,CAAC,GAEMA;AACT;"}
+{"version":3,"file":"reactive.es.mjs","sources":["../src/reactive/signal.ts"],"sourcesContent":["/**\r\n * Reactive primitives inspired by fine-grained reactivity.\r\n *\r\n * This module provides a minimal but powerful reactive system:\r\n * - Signal: A reactive value that notifies subscribers when changed\r\n * - Computed: A derived value that automatically updates when dependencies change\r\n * - Effect: A side effect that re-runs when its dependencies change\r\n * - Batch: Group multiple updates to prevent intermediate re-renders\r\n *\r\n * @module bquery/reactive\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n * const doubled = computed(() => count.value * 2);\r\n *\r\n * effect(() => {\r\n *   console.log(`Count: ${count.value}, Doubled: ${doubled.value}`);\r\n * });\r\n *\r\n * batch(() => {\r\n *   count.value = 1;\r\n *   count.value = 2;\r\n * });\r\n * // Logs: \"Count: 2, Doubled: 4\" (only once due to batching)\r\n * ```\r\n */\r\n\r\n/**\r\n * Observer function type used internally for tracking reactivity.\r\n */\r\nexport type Observer = () => void;\r\n\r\n/**\r\n * Cleanup function returned by effects for disposal.\r\n */\r\nexport type CleanupFn = () => void;\r\n\r\n// Internal state for tracking the current observer context\r\nconst observerStack: Observer[] = [];\r\nlet batchDepth = 0;\r\nconst pendingObservers = new Set<Observer>();\r\n\r\n// Flag to disable tracking temporarily (for untrack)\r\nlet trackingEnabled = true;\r\n\r\n/**\r\n * Tracks dependencies during a function execution.\r\n * Uses direct push/pop for O(1) operations instead of array copying.\r\n * @internal\r\n */\r\nconst track = <T>(observer: Observer, fn: () => T): T => {\r\n  observerStack.push(observer);\r\n  try {\r\n    return fn();\r\n  } finally {\r\n    observerStack.pop();\r\n  }\r\n};\r\n\r\n/**\r\n * Schedules an observer to run, respecting batch mode.\r\n * @internal\r\n */\r\nconst scheduleObserver = (observer: Observer) => {\r\n  if (batchDepth > 0) {\r\n    pendingObservers.add(observer);\r\n    return;\r\n  }\r\n  observer();\r\n};\r\n\r\n/**\r\n * Flushes all pending observers after a batch completes.\r\n * @internal\r\n */\r\nconst flushObservers = () => {\r\n  for (const observer of Array.from(pendingObservers)) {\r\n    pendingObservers.delete(observer);\r\n    observer();\r\n  }\r\n};\r\n\r\n/**\r\n * A reactive value container that notifies subscribers on change.\r\n *\r\n * Signals are the foundational primitive of the reactive system.\r\n * Reading a signal's value inside an effect or computed automatically\r\n * establishes a reactive dependency.\r\n *\r\n * @template T - The type of the stored value\r\n *\r\n * @example\r\n * ```ts\r\n * const name = signal('World');\r\n * console.log(name.value); // 'World'\r\n *\r\n * name.value = 'bQuery';\r\n * console.log(name.value); // 'bQuery'\r\n * ```\r\n */\r\nexport class Signal<T> {\r\n  private subscribers = new Set<Observer>();\r\n\r\n  /**\r\n   * Creates a new signal with an initial value.\r\n   * @param _value - The initial value\r\n   */\r\n  constructor(private _value: T) {}\r\n\r\n  /**\r\n   * Gets the current value and tracks the read if inside an observer.\r\n   * Respects the global tracking state (disabled during untrack calls).\r\n   */\r\n  get value(): T {\r\n    if (trackingEnabled) {\r\n      const current = observerStack[observerStack.length - 1];\r\n      if (current) {\r\n        this.subscribers.add(current);\r\n      }\r\n    }\r\n    return this._value;\r\n  }\r\n\r\n  /**\r\n   * Sets a new value and notifies all subscribers if the value changed.\r\n   * Uses Object.is for equality comparison.\r\n   */\r\n  set value(next: T) {\r\n    if (Object.is(this._value, next)) return;\r\n    this._value = next;\r\n    for (const subscriber of this.subscribers) {\r\n      scheduleObserver(subscriber);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Reads the current value without tracking.\r\n   * Useful when you need the value but don't want to create a dependency.\r\n   *\r\n   * @returns The current value\r\n   */\r\n  peek(): T {\r\n    return this._value;\r\n  }\r\n\r\n  /**\r\n   * Updates the value using a function.\r\n   * Useful for updates based on the current value.\r\n   *\r\n   * @param updater - Function that receives current value and returns new value\r\n   */\r\n  update(updater: (current: T) => T): void {\r\n    this.value = updater(this._value);\r\n  }\r\n}\r\n\r\n/**\r\n * A computed value that derives from other reactive sources.\r\n *\r\n * Computed values are lazily evaluated and cached. They only\r\n * recompute when their dependencies change.\r\n *\r\n * @template T - The type of the computed value\r\n *\r\n * @example\r\n * ```ts\r\n * const price = signal(100);\r\n * const quantity = signal(2);\r\n * const total = computed(() => price.value * quantity.value);\r\n *\r\n * console.log(total.value); // 200\r\n * price.value = 150;\r\n * console.log(total.value); // 300\r\n * ```\r\n */\r\nexport class Computed<T> {\r\n  private cachedValue!: T;\r\n  private dirty = true;\r\n  private subscribers = new Set<Observer>();\r\n  private readonly markDirty = () => {\r\n    this.dirty = true;\r\n    for (const subscriber of this.subscribers) {\r\n      scheduleObserver(subscriber);\r\n    }\r\n  };\r\n\r\n  /**\r\n   * Creates a new computed value.\r\n   * @param compute - Function that computes the value\r\n   */\r\n  constructor(private readonly compute: () => T) {}\r\n\r\n  /**\r\n   * Gets the computed value, recomputing if dependencies changed.\r\n   */\r\n  get value(): T {\r\n    const current = observerStack[observerStack.length - 1];\r\n    if (current) {\r\n      this.subscribers.add(current);\r\n    }\r\n    if (this.dirty) {\r\n      this.dirty = false;\r\n      this.cachedValue = track(this.markDirty, this.compute);\r\n    }\r\n    return this.cachedValue;\r\n  }\r\n}\r\n\r\n/**\r\n * Creates a new reactive signal.\r\n *\r\n * @template T - The type of the signal value\r\n * @param value - The initial value\r\n * @returns A new Signal instance\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n * count.value++; // Triggers subscribers\r\n * ```\r\n */\r\nexport const signal = <T>(value: T): Signal<T> => new Signal(value);\r\n\r\n/**\r\n * Creates a new computed value.\r\n *\r\n * @template T - The type of the computed value\r\n * @param fn - Function that computes the value from reactive sources\r\n * @returns A new Computed instance\r\n *\r\n * @example\r\n * ```ts\r\n * const doubled = computed(() => count.value * 2);\r\n * ```\r\n */\r\nexport const computed = <T>(fn: () => T): Computed<T> => new Computed(fn);\r\n\r\n/**\r\n * Creates a side effect that automatically re-runs when dependencies change.\r\n *\r\n * The effect runs immediately upon creation and then re-runs whenever\r\n * any signal or computed value read inside it changes.\r\n *\r\n * @param fn - The effect function to run\r\n * @returns A cleanup function to stop the effect\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n *\r\n * const cleanup = effect(() => {\r\n *   document.title = `Count: ${count.value}`;\r\n * });\r\n *\r\n * // Later, to stop the effect:\r\n * cleanup();\r\n * ```\r\n */\r\nexport const effect = (fn: () => void | CleanupFn): CleanupFn => {\r\n  let cleanupFn: CleanupFn | void;\r\n  let isDisposed = false;\r\n\r\n  const observer: Observer = () => {\r\n    if (isDisposed) return;\r\n\r\n    // Run previous cleanup if exists\r\n    if (cleanupFn) {\r\n      cleanupFn();\r\n    }\r\n\r\n    // Run effect and capture cleanup\r\n    cleanupFn = track(observer, fn);\r\n  };\r\n\r\n  observer();\r\n\r\n  return () => {\r\n    isDisposed = true;\r\n    if (cleanupFn) {\r\n      cleanupFn();\r\n    }\r\n  };\r\n};\r\n\r\n/**\r\n * Batches multiple signal updates into a single notification cycle.\r\n *\r\n * Updates made inside the batch function are deferred until the batch\r\n * completes, preventing intermediate re-renders and improving performance.\r\n *\r\n * @param fn - Function containing multiple signal updates\r\n *\r\n * @example\r\n * ```ts\r\n * batch(() => {\r\n *   firstName.value = 'John';\r\n *   lastName.value = 'Doe';\r\n *   age.value = 30;\r\n * });\r\n * // Effects only run once with all three updates\r\n * ```\r\n */\r\nexport const batch = (fn: () => void): void => {\r\n  batchDepth += 1;\r\n  try {\r\n    fn();\r\n  } finally {\r\n    batchDepth -= 1;\r\n    if (batchDepth === 0) {\r\n      flushObservers();\r\n    }\r\n  }\r\n};\r\n\r\n/**\r\n * Creates a signal that persists to localStorage.\r\n *\r\n * @template T - The type of the signal value\r\n * @param key - The localStorage key\r\n * @param initialValue - The initial value if not found in storage\r\n * @returns A Signal that syncs with localStorage\r\n *\r\n * @example\r\n * ```ts\r\n * const theme = persistedSignal('theme', 'light');\r\n * theme.value = 'dark'; // Automatically saved to localStorage\r\n * ```\r\n */\r\nexport const persistedSignal = <T>(key: string, initialValue: T): Signal<T> => {\r\n  let stored: T = initialValue;\r\n\r\n  try {\r\n    const raw = localStorage.getItem(key);\r\n    if (raw !== null) {\r\n      stored = JSON.parse(raw) as T;\r\n    }\r\n  } catch {\r\n    // Use initial value on parse error\r\n  }\r\n\r\n  const sig = signal(stored);\r\n\r\n  // Create an effect to persist changes\r\n  effect(() => {\r\n    try {\r\n      localStorage.setItem(key, JSON.stringify(sig.value));\r\n    } catch {\r\n      // Ignore storage errors\r\n    }\r\n  });\r\n\r\n  return sig;\r\n};\r\n\r\n// ============================================================================\r\n// Extended Reactive Utilities\r\n// ============================================================================\r\n\r\n/**\r\n * A readonly wrapper around a signal that prevents writes.\r\n * Provides read-only access to a signal's value while maintaining reactivity.\r\n *\r\n * @template T - The type of the wrapped value\r\n */\r\nexport interface ReadonlySignal<T> {\r\n  /** Gets the current value with dependency tracking. */\r\n  readonly value: T;\r\n  /** Gets the current value without dependency tracking. */\r\n  peek(): T;\r\n}\r\n\r\n/**\r\n * Creates a read-only view of a signal.\r\n * Useful for exposing reactive state without allowing modifications.\r\n *\r\n * @template T - The type of the signal value\r\n * @param sig - The signal to wrap\r\n * @returns A readonly signal wrapper\r\n *\r\n * @example\r\n * ```ts\r\n * const _count = signal(0);\r\n * const count = readonly(_count); // Expose read-only version\r\n *\r\n * console.log(count.value); // 0\r\n * count.value = 1; // TypeScript error: Cannot assign to 'value'\r\n * ```\r\n */\r\nexport const readonly = <T>(sig: Signal<T>): ReadonlySignal<T> => ({\r\n  get value(): T {\r\n    return sig.value;\r\n  },\r\n  peek(): T {\r\n    return sig.peek();\r\n  },\r\n});\r\n\r\n/**\r\n * Watches a signal or computed value and calls a callback with old and new values.\r\n * Unlike effect, watch provides access to the previous value.\r\n *\r\n * @template T - The type of the watched value\r\n * @param source - The signal or computed to watch\r\n * @param callback - Function called with (newValue, oldValue) on changes\r\n * @param options - Watch options\r\n * @returns A cleanup function to stop watching\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n *\r\n * const cleanup = watch(count, (newVal, oldVal) => {\r\n *   console.log(`Changed from ${oldVal} to ${newVal}`);\r\n * });\r\n *\r\n * count.value = 5; // Logs: \"Changed from 0 to 5\"\r\n * cleanup();\r\n * ```\r\n */\r\nexport const watch = <T>(\r\n  source: Signal<T> | Computed<T>,\r\n  callback: (newValue: T, oldValue: T | undefined) => void,\r\n  options: { immediate?: boolean } = {}\r\n): CleanupFn => {\r\n  let oldValue: T | undefined;\r\n  let isFirst = true;\r\n\r\n  return effect(() => {\r\n    const newValue = source.value;\r\n\r\n    if (isFirst) {\r\n      isFirst = false;\r\n      oldValue = newValue;\r\n      if (options.immediate) {\r\n        callback(newValue, undefined);\r\n      }\r\n      return;\r\n    }\r\n\r\n    callback(newValue, oldValue);\r\n    oldValue = newValue;\r\n  });\r\n};\r\n\r\n/**\r\n * Executes a function without tracking any signal dependencies.\r\n * Useful when reading a signal value without creating a reactive dependency.\r\n *\r\n * @template T - The return type of the function\r\n * @param fn - The function to execute without tracking\r\n * @returns The result of the function\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n *\r\n * effect(() => {\r\n *   // This creates a dependency\r\n *   console.log('Tracked:', count.value);\r\n *\r\n *   // This does NOT create a dependency\r\n *   const untracked = untrack(() => otherSignal.value);\r\n * });\r\n * ```\r\n */\r\nexport const untrack = <T>(fn: () => T): T => {\r\n  const prevTracking = trackingEnabled;\r\n  trackingEnabled = false;\r\n  try {\r\n    return fn();\r\n  } finally {\r\n    trackingEnabled = prevTracking;\r\n  }\r\n};\r\n\r\n/**\r\n * Type guard to check if a value is a Signal instance.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is a Signal\r\n *\r\n * @example\r\n * ```ts\r\n * const count = signal(0);\r\n * const num = 42;\r\n *\r\n * isSignal(count); // true\r\n * isSignal(num);   // false\r\n * ```\r\n */\r\nexport const isSignal = (value: unknown): value is Signal<unknown> => value instanceof Signal;\r\n\r\n/**\r\n * Type guard to check if a value is a Computed instance.\r\n *\r\n * @param value - The value to check\r\n * @returns True if the value is a Computed\r\n *\r\n * @example\r\n * ```ts\r\n * const doubled = computed(() => count.value * 2);\r\n * isComputed(doubled); // true\r\n * ```\r\n */\r\nexport const isComputed = (value: unknown): value is Computed<unknown> => value instanceof Computed;\r\n"],"names":["observerStack","batchDepth","pendingObservers","trackingEnabled","track","observer","fn","scheduleObserver","flushObservers","Signal","_value","current","next","subscriber","updater","Computed","compute","signal","value","computed","effect","cleanupFn","isDisposed","batch","persistedSignal","key","initialValue","stored","raw","sig","readonly","watch","source","callback","options","oldValue","isFirst","newValue","untrack","prevTracking","isSignal","isComputed"],"mappings":"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"}

package/dist/security/sanitize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/security/sanitize.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,wDAAwD;IACxD,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,8CAA8C;IAC9C,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,4DAA4D;IAC5D,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAsBD,qCAAqC;AACrC,UAAU,iBAAiB;IACzB,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,WAAW,CAAC;CAC5C;AAED,2EAA2E;AAC3E,UAAU,WAAW;IACnB,QAAQ,IAAI,MAAM,CAAC;CACpB;AAKD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,QAAO,OAE1C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,QAAO,iBAAiB,GAAG,IAgB5D,CAAC;AAgQF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,EAAE,UAAS,eAAoB,KAAG,MAE1E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,WAAW,GAAG,MAM9D,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,KAAG,MAUzC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,KAAG,MAExC,CAAC;AAMF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,MAAW,KAAG,MAOnD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,WAAW,MAAM,KAAG,OAQnD,CAAC"}
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/security/sanitize.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,wDAAwD;IACxD,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,8CAA8C;IAC9C,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,4DAA4D;IAC5D,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAsBD,qCAAqC;AACrC,UAAU,iBAAiB;IACzB,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,WAAW,CAAC;CAC5C;AAED,2EAA2E;AAC3E,UAAU,WAAW;IACnB,QAAQ,IAAI,MAAM,CAAC;CACpB;AAKD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,QAAO,OAE1C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,QAAO,iBAAiB,GAAG,IAgB5D,CAAC;AA2WF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,EAAE,UAAS,eAAoB,KAAG,MAE1E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,WAAW,GAAG,MAM9D,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,KAAG,MAUzC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,KAAG,MAExC,CAAC;AAMF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAI,SAAQ,MAAW,KAAG,MAOnD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,WAAW,MAAM,KAAG,OAQnD,CAAC"}