@bquery/bquery 1.3.0 → 1.4.0

package/src/view/evaluate.ts

@@ -1,274 +1,290 @@
-import { isComputed, isSignal, type Signal } from '../reactive/index';
-import type { BindingContext } from './types';
-
-/** Maximum number of cached expression functions before LRU eviction */
-const MAX_CACHE_SIZE = 500;
-
-/** Compiled function type for expression evaluation */
-type CompiledFn = (ctx: BindingContext) => unknown;
-
-/**
- * Simple LRU cache for compiled expression functions.
- * Uses Map's insertion order to track recency - accessed items are re-inserted.
- * @internal
- */
-class LRUCache {
-  private cache = new Map<string, CompiledFn>();
-  private maxSize: number;
-
-  constructor(maxSize: number) {
-    this.maxSize = maxSize;
-  }
-
-  get(key: string): CompiledFn | undefined {
-    const value = this.cache.get(key);
-    if (value !== undefined) {
-      // Move to end (most recently used) by re-inserting
-      this.cache.delete(key);
-      this.cache.set(key, value);
-    }
-    return value;
-  }
-
-  set(key: string, value: CompiledFn): void {
-    // Delete first if exists to update insertion order
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    } else if (this.cache.size >= this.maxSize) {
-      // Evict oldest (first) entry
-      const oldest = this.cache.keys().next().value;
-      if (oldest !== undefined) {
-        this.cache.delete(oldest);
-      }
-    }
-    this.cache.set(key, value);
-  }
-
-  clear(): void {
-    this.cache.clear();
-  }
-
-  get size(): number {
-    return this.cache.size;
-  }
-}
-
-/** LRU cache for compiled evaluate functions, keyed by expression string */
-const evaluateCache = new LRUCache(MAX_CACHE_SIZE);
-
-/** LRU cache for compiled evaluateRaw functions, keyed by expression string */
-const evaluateRawCache = new LRUCache(MAX_CACHE_SIZE);
-
-/**
- * Clears all cached compiled expression functions.
- * Call this when unmounting views or to free memory after heavy template usage.
- *
- * @example
- * ```ts
- * import { clearExpressionCache } from 'bquery/view';
- *
- * // After destroying a view or when cleaning up
- * clearExpressionCache();
- * ```
- */
-export const clearExpressionCache = (): void => {
-  evaluateCache.clear();
-  evaluateRawCache.clear();
-};
-
-/**
- * Creates a proxy that lazily unwraps signals/computed only when accessed.
- * This avoids subscribing to signals that aren't referenced in the expression.
- * @internal
- */
-const createLazyContext = (context: BindingContext): BindingContext =>
-  new Proxy(context, {
-    get(target, prop: string | symbol) {
-      // Only handle string keys for BindingContext indexing
-      if (typeof prop !== 'string') {
-        return Reflect.get(target, prop);
-      }
-      const value = target[prop];
-      // Auto-unwrap signals/computed only when actually accessed
-      if (isSignal(value) || isComputed(value)) {
-        return (value as Signal<unknown>).value;
-      }
-      return value;
-    },
-    has(target, prop: string | symbol) {
-      // Required for `with` statement to resolve identifiers correctly
-      if (typeof prop !== 'string') {
-        return Reflect.has(target, prop);
-      }
-      return prop in target;
-    },
-  });
-
-/**
- * Evaluates an expression in the given context using `new Function()`.
- *
- * Signals and computed values in the context are lazily unwrapped only when
- * accessed by the expression, avoiding unnecessary subscriptions to unused values.
- *
- * @security **WARNING:** This function uses dynamic code execution via `new Function()`.
- * - NEVER pass expressions derived from user input or untrusted sources
- * - Expressions should only come from developer-controlled templates
- * - Malicious expressions can access and exfiltrate context data
- * - Consider this equivalent to `eval()` in terms of security implications
- *
- * @internal
- */
-export const evaluate = <T = unknown>(expression: string, context: BindingContext): T => {
-  try {
-    // Create a proxy that lazily unwraps signals/computed on access
-    const lazyContext = createLazyContext(context);
-
-    // Use cached function or compile and cache a new one
-    let fn = evaluateCache.get(expression);
-    if (!fn) {
-      // Use `with` to enable direct property access from proxy scope.
-      // Note: `new Function()` runs in non-strict mode, so `with` is allowed.
-      fn = new Function('$ctx', `with($ctx) { return (${expression}); }`) as (
-        ctx: BindingContext
-      ) => unknown;
-      evaluateCache.set(expression, fn);
-    }
-    return fn(lazyContext) as T;
-  } catch (error) {
-    console.error(`bQuery view: Error evaluating "${expression}"`, error);
-    return undefined as T;
-  }
-};
-
-/**
- * Evaluates an expression and returns the raw value (for signal access).
- *
- * @security **WARNING:** Uses dynamic code execution. See {@link evaluate} for security notes.
- * @internal
- */
-export const evaluateRaw = <T = unknown>(expression: string, context: BindingContext): T => {
-  try {
-    // Use cached function or compile and cache a new one
-    let fn = evaluateRawCache.get(expression);
-    if (!fn) {
-      // Use `with` to enable direct property access from context scope.
-      // Unlike `evaluate`, we don't use a lazy proxy - values are accessed directly.
-      fn = new Function('$ctx', `with($ctx) { return (${expression}); }`) as (
-        ctx: BindingContext
-      ) => unknown;
-      evaluateRawCache.set(expression, fn);
-    }
-    return fn(context) as T;
-  } catch (error) {
-    console.error(`bQuery view: Error evaluating "${expression}"`, error);
-    return undefined as T;
-  }
-};
-
-/**
- * Parses object expression like "{ active: isActive, disabled: !enabled }".
- * Handles nested structures like function calls, arrays, and template literals.
- * @internal
- */
-export const parseObjectExpression = (expression: string): Record<string, string> => {
-  const result: Record<string, string> = {};
-
-  // Remove outer braces and trim
-  const inner = expression
-    .trim()
-    .replace(/^\{|\}$/g, '')
-    .trim();
-  if (!inner) return result;
-
-  // Split by comma at depth 0, respecting strings and nesting
-  const parts: string[] = [];
-  let current = '';
-  let depth = 0;
-  let inString: string | null = null;
-
-  for (let i = 0; i < inner.length; i++) {
-    const char = inner[i];
-    const prevChar = i > 0 ? inner[i - 1] : '';
-
-    // Handle string literals (including escape sequences)
-    if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
-      if (inString === null) {
-        inString = char;
-      } else if (inString === char) {
-        inString = null;
-      }
-      current += char;
-      continue;
-    }
-
-    // Skip if inside string
-    if (inString !== null) {
-      current += char;
-      continue;
-    }
-
-    // Track nesting depth for parentheses, brackets, and braces
-    if (char === '(' || char === '[' || char === '{') {
-      depth++;
-      current += char;
-    } else if (char === ')' || char === ']' || char === '}') {
-      depth--;
-      current += char;
-    } else if (char === ',' && depth === 0) {
-      // Top-level comma - split point
-      parts.push(current.trim());
-      current = '';
-    } else {
-      current += char;
-    }
-  }
-
-  // Add the last part
-  if (current.trim()) {
-    parts.push(current.trim());
-  }
-
-  // Parse each part to extract key and value
-  for (const part of parts) {
-    // Find the first colon at depth 0 (to handle ternary operators in values)
-    let colonIndex = -1;
-    let partDepth = 0;
-    let partInString: string | null = null;
-
-    for (let i = 0; i < part.length; i++) {
-      const char = part[i];
-      const prevChar = i > 0 ? part[i - 1] : '';
-
-      if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
-        if (partInString === null) {
-          partInString = char;
-        } else if (partInString === char) {
-          partInString = null;
-        }
-        continue;
-      }
-
-      if (partInString !== null) continue;
-
-      if (char === '(' || char === '[' || char === '{') {
-        partDepth++;
-      } else if (char === ')' || char === ']' || char === '}') {
-        partDepth--;
-      } else if (char === ':' && partDepth === 0) {
-        colonIndex = i;
-        break;
-      }
-    }
-
-    if (colonIndex > -1) {
-      const key = part
-        .slice(0, colonIndex)
-        .trim()
-        .replace(/^['"]|['"]$/g, '');
-      const value = part.slice(colonIndex + 1).trim();
-      result[key] = value;
-    }
-  }
-
-  return result;
-};
+import { isComputed, isSignal, type Signal } from '../reactive/index';
+import type { BindingContext } from './types';
+
+/** Maximum number of cached expression functions before LRU eviction */
+const MAX_CACHE_SIZE = 500;
+
+/** Compiled function type for expression evaluation */
+type CompiledFn = (ctx: BindingContext) => unknown;
+
+/**
+ * Simple LRU cache for compiled expression functions.
+ * Uses Map's insertion order to track recency - accessed items are re-inserted.
+ * @internal
+ */
+class LRUCache {
+  private cache = new Map<string, CompiledFn>();
+  private maxSize: number;
+
+  constructor(maxSize: number) {
+    this.maxSize = maxSize;
+  }
+
+  get(key: string): CompiledFn | undefined {
+    const value = this.cache.get(key);
+    if (value !== undefined) {
+      // Move to end (most recently used) by re-inserting
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+
+  set(key: string, value: CompiledFn): void {
+    // Delete first if exists to update insertion order
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      // Evict oldest (first) entry
+      const oldest = this.cache.keys().next().value;
+      if (oldest !== undefined) {
+        this.cache.delete(oldest);
+      }
+    }
+    this.cache.set(key, value);
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  get size(): number {
+    return this.cache.size;
+  }
+}
+
+/** LRU cache for compiled evaluate functions, keyed by expression string */
+const evaluateCache = new LRUCache(MAX_CACHE_SIZE);
+
+/** LRU cache for compiled evaluateRaw functions, keyed by expression string */
+const evaluateRawCache = new LRUCache(MAX_CACHE_SIZE);
+
+/**
+ * Clears all cached compiled expression functions.
+ * Call this when unmounting views or to free memory after heavy template usage.
+ *
+ * @example
+ * ```ts
+ * import { clearExpressionCache } from 'bquery/view';
+ *
+ * // After destroying a view or when cleaning up
+ * clearExpressionCache();
+ * ```
+ */
+export const clearExpressionCache = (): void => {
+  evaluateCache.clear();
+  evaluateRawCache.clear();
+};
+
+/**
+ * Creates a proxy that lazily unwraps signals/computed only when accessed.
+ * This avoids subscribing to signals that aren't referenced in the expression.
+ * @internal
+ */
+const createLazyContext = (context: BindingContext): BindingContext =>
+  new Proxy(context, {
+    get(target, prop: string | symbol) {
+      // Only handle string keys for BindingContext indexing
+      if (typeof prop !== 'string') {
+        return Reflect.get(target, prop);
+      }
+      const value = target[prop];
+      // Auto-unwrap signals/computed only when actually accessed
+      if (isSignal(value) || isComputed(value)) {
+        return (value as Signal<unknown>).value;
+      }
+      return value;
+    },
+    has(target, prop: string | symbol) {
+      // Required for `with` statement to resolve identifiers correctly
+      if (typeof prop !== 'string') {
+        return Reflect.has(target, prop);
+      }
+      return prop in target;
+    },
+  });
+
+/**
+ * Evaluates an expression in the given context using `new Function()`.
+ *
+ * Signals and computed values in the context are lazily unwrapped only when
+ * accessed by the expression, avoiding unnecessary subscriptions to unused values.
+ *
+ * @security **WARNING:** This function uses dynamic code execution via `new Function()`.
+ * - NEVER pass expressions derived from user input or untrusted sources
+ * - Expressions should only come from developer-controlled templates
+ * - Malicious expressions can access and exfiltrate context data
+ * - Consider this equivalent to `eval()` in terms of security implications
+ *
+ * @internal
+ */
+export const evaluate = <T = unknown>(expression: string, context: BindingContext): T => {
+  try {
+    // Create a proxy that lazily unwraps signals/computed on access
+    const lazyContext = createLazyContext(context);
+
+    // Use cached function or compile and cache a new one
+    let fn = evaluateCache.get(expression);
+    if (!fn) {
+      // Use `with` to enable direct property access from proxy scope.
+      // Note: `new Function()` runs in non-strict mode, so `with` is allowed.
+      fn = new Function('$ctx', `with($ctx) { return (${expression}); }`) as (
+        ctx: BindingContext
+      ) => unknown;
+      evaluateCache.set(expression, fn);
+    }
+    return fn(lazyContext) as T;
+  } catch (error) {
+    console.error(`bQuery view: Error evaluating "${expression}"`, error);
+    return undefined as T;
+  }
+};
+
+/**
+ * Evaluates an expression and returns the raw value (for signal access).
+ *
+ * @security **WARNING:** Uses dynamic code execution. See {@link evaluate} for security notes.
+ * @internal
+ */
+export const evaluateRaw = <T = unknown>(expression: string, context: BindingContext): T => {
+  try {
+    // Use cached function or compile and cache a new one
+    let fn = evaluateRawCache.get(expression);
+    if (!fn) {
+      // Use `with` to enable direct property access from context scope.
+      // Unlike `evaluate`, we don't use a lazy proxy - values are accessed directly.
+      fn = new Function('$ctx', `with($ctx) { return (${expression}); }`) as (
+        ctx: BindingContext
+      ) => unknown;
+      evaluateRawCache.set(expression, fn);
+    }
+    return fn(context) as T;
+  } catch (error) {
+    console.error(`bQuery view: Error evaluating "${expression}"`, error);
+    return undefined as T;
+  }
+};
+
+/**
+ * Parses object expression like "{ active: isActive, disabled: !enabled }".
+ * Handles nested structures like function calls, arrays, and template literals.
+ * @internal
+ */
+export const parseObjectExpression = (expression: string): Record<string, string> => {
+  const result: Record<string, string> = {};
+
+  // Remove outer braces and trim
+  const inner = expression
+    .trim()
+    .replace(/^\{|\}$/g, '')
+    .trim();
+  if (!inner) return result;
+
+  // Split by comma at depth 0, respecting strings and nesting
+  const parts: string[] = [];
+  let current = '';
+  let depth = 0;
+  let inString: string | null = null;
+
+  for (let i = 0; i < inner.length; i++) {
+    const char = inner[i];
+
+    // Handle string literals: count consecutive backslashes before a quote
+    // to correctly distinguish escaped quotes from end-of-string
+    if (char === '"' || char === "'" || char === '`') {
+      let backslashCount = 0;
+      let j = i - 1;
+      while (j >= 0 && inner[j] === '\\') {
+        backslashCount++;
+        j--;
+      }
+      // Quote is escaped only if preceded by an odd number of backslashes
+      if (backslashCount % 2 === 0) {
+        if (inString === null) {
+          inString = char;
+        } else if (inString === char) {
+          inString = null;
+        }
+      }
+      current += char;
+      continue;
+    }
+
+    // Skip if inside string
+    if (inString !== null) {
+      current += char;
+      continue;
+    }
+
+    // Track nesting depth for parentheses, brackets, and braces
+    if (char === '(' || char === '[' || char === '{') {
+      depth++;
+      current += char;
+    } else if (char === ')' || char === ']' || char === '}') {
+      depth--;
+      current += char;
+    } else if (char === ',' && depth === 0) {
+      // Top-level comma - split point
+      parts.push(current.trim());
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+
+  // Add the last part
+  if (current.trim()) {
+    parts.push(current.trim());
+  }
+
+  // Parse each part to extract key and value
+  for (const part of parts) {
+    // Find the first colon at depth 0 (to handle ternary operators in values)
+    let colonIndex = -1;
+    let partDepth = 0;
+    let partInString: string | null = null;
+
+    for (let i = 0; i < part.length; i++) {
+      const char = part[i];
+
+      if (char === '"' || char === "'" || char === '`') {
+        let backslashCount = 0;
+        let j = i - 1;
+        while (j >= 0 && part[j] === '\\') {
+          backslashCount++;
+          j--;
+        }
+        if (backslashCount % 2 === 0) {
+          if (partInString === null) {
+            partInString = char;
+          } else if (partInString === char) {
+            partInString = null;
+          }
+        }
+        continue;
+      }
+
+      if (partInString !== null) continue;
+
+      if (char === '(' || char === '[' || char === '{') {
+        partDepth++;
+      } else if (char === ')' || char === ']' || char === '}') {
+        partDepth--;
+      } else if (char === ':' && partDepth === 0) {
+        colonIndex = i;
+        break;
+      }
+    }
+
+    if (colonIndex > -1) {
+      const key = part
+        .slice(0, colonIndex)
+        .trim()
+        .replace(/^['"]|['"]$/g, '');
+      const value = part.slice(colonIndex + 1).trim();
+      result[key] = value;
+    }
+  }
+
+  return result;
+};

package/dist/core-COenAZjD.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"core-COenAZjD.js","sources":["../src/reactive/internals.ts","../src/reactive/computed.ts","../src/reactive/core.ts"],"sourcesContent":["/**\n * Internal reactive plumbing shared across primitives.\n * @internal\n */\n\nexport type Observer = () => void;\nexport type CleanupFn = () => void;\n\n/**\n * Interface for reactive sources (Signals, Computed) that can unsubscribe observers.\n * @internal\n */\nexport interface ReactiveSource {\n  unsubscribe(observer: Observer): void;\n}\n\nconst observerStack: Observer[] = [];\nlet batchDepth = 0;\nconst pendingObservers = new Set<Observer>();\n\n// Track dependencies for each observer to enable cleanup\nconst observerDependencies = new WeakMap<Observer, Set<ReactiveSource>>();\n\nexport const track = <T>(observer: Observer, fn: () => T): T => {\n  observerStack.push(observer);\n  try {\n    return fn();\n  } finally {\n    observerStack.pop();\n  }\n};\n\nexport const getCurrentObserver = (): Observer | undefined =>\n  observerStack[observerStack.length - 1];\n\n/**\n * Executes a function without exposing the current observer to dependencies.\n * Unlike disabling tracking globally, this still allows nested reactive internals\n * (e.g., computed recomputation) to track their own dependencies.\n * @internal\n */\nexport const withoutCurrentObserver = <T>(fn: () => T): T => {\n  // Push undefined to temporarily \"hide\" the current observer\n  // This way, Signal.value reads won't link to the previous observer,\n  // but nested track() calls (e.g., computed recompute) still work normally.\n  observerStack.push(undefined as unknown as Observer);\n  try {\n    return fn();\n  } finally {\n    observerStack.pop();\n  }\n};\n\nexport const scheduleObserver = (observer: Observer): void => {\n  if (batchDepth > 0) {\n    pendingObservers.add(observer);\n    return;\n  }\n  observer();\n};\n\nconst flushObservers = (): void => {\n  for (const observer of Array.from(pendingObservers)) {\n    pendingObservers.delete(observer);\n    observer();\n  }\n};\n\nexport const beginBatch = (): void => {\n  batchDepth += 1;\n};\n\nexport const endBatch = (): void => {\n  batchDepth -= 1;\n  if (batchDepth === 0) {\n    flushObservers();\n  }\n};\n\n/**\n * Registers a dependency between an observer and a reactive source.\n * @internal\n */\nexport const registerDependency = (observer: Observer, source: ReactiveSource): void => {\n  let deps = observerDependencies.get(observer);\n  if (!deps) {\n    deps = new Set();\n    observerDependencies.set(observer, deps);\n  }\n  deps.add(source);\n};\n\n/**\n * Clears all dependencies for an observer, unsubscribing from all sources.\n * @internal\n */\nexport const clearDependencies = (observer: Observer): void => {\n  const deps = observerDependencies.get(observer);\n  if (deps) {\n    for (const source of deps) {\n      source.unsubscribe(observer);\n    }\n    deps.clear();\n  }\n};\n","/**\n * Computed reactive values.\n */\n\nimport {\n  clearDependencies,\n  getCurrentObserver,\n  registerDependency,\n  scheduleObserver,\n  track,\n  type ReactiveSource,\n} from './internals';\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 */\nexport class Computed<T> implements ReactiveSource {\n  private cachedValue!: T;\n  private dirty = true;\n  private subscribers = new Set<() => void>();\n  private readonly markDirty = () => {\n    this.dirty = true;\n    // Create snapshot to avoid issues with subscribers modifying the set during iteration\n    const subscribersSnapshot = Array.from(this.subscribers);\n    for (const subscriber of subscribersSnapshot) {\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   * During untrack calls, getCurrentObserver returns undefined, preventing dependency tracking.\n   */\n  get value(): T {\n    const current = getCurrentObserver();\n    if (current) {\n      this.subscribers.add(current);\n      registerDependency(current, this);\n    }\n    if (this.dirty) {\n      this.dirty = false;\n      // Clear old dependencies before recomputing\n      clearDependencies(this.markDirty);\n      this.cachedValue = track(this.markDirty, this.compute);\n    }\n    return this.cachedValue;\n  }\n\n  /**\n   * Reads the current computed value without tracking.\n   * Useful when you need the value but don't want to create a dependency.\n   *\n   * @returns The current cached value (recomputes if dirty)\n   */\n  peek(): T {\n    if (this.dirty) {\n      this.dirty = false;\n      // Clear old dependencies before recomputing\n      clearDependencies(this.markDirty);\n      this.cachedValue = track(this.markDirty, this.compute);\n    }\n    return this.cachedValue;\n  }\n\n  /**\n   * Removes an observer from this computed's subscriber set.\n   * @internal\n   */\n  unsubscribe(observer: () => void): void {\n    this.subscribers.delete(observer);\n  }\n}\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 */\nexport const computed = <T>(fn: () => T): Computed<T> => new Computed(fn);\n","/**\n * Core reactive signals.\n */\n\nimport {\n  getCurrentObserver,\n  registerDependency,\n  scheduleObserver,\n  type ReactiveSource,\n} from './internals';\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 */\nexport class Signal<T> implements ReactiveSource {\n  private subscribers = new Set<() => void>();\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   * During untrack calls, getCurrentObserver returns undefined, preventing dependency tracking.\n   */\n  get value(): T {\n    const current = getCurrentObserver();\n    if (current) {\n      this.subscribers.add(current);\n      registerDependency(current, this);\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    // Create snapshot to avoid issues with subscribers modifying the set during iteration\n    const subscribersSnapshot = Array.from(this.subscribers);\n    for (const subscriber of subscribersSnapshot) {\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   * Removes an observer from this signal's subscriber set.\n   * @internal\n   */\n  unsubscribe(observer: () => void): void {\n    this.subscribers.delete(observer);\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 */\nexport const signal = <T>(value: T): Signal<T> => new Signal(value);\n"],"names":["observerStack","batchDepth","pendingObservers","observerDependencies","track","observer","fn","getCurrentObserver","withoutCurrentObserver","scheduleObserver","flushObservers","beginBatch","endBatch","registerDependency","source","deps","clearDependencies","Computed","compute","subscribersSnapshot","subscriber","current","computed","Signal","_value","next","updater","signal","value"],"mappings":"AAgBA,MAAMA,IAA4B,CAAA;AAClC,IAAIC,IAAa;AACjB,MAAMC,wBAAuB,IAAA,GAGvBC,wBAA2B,QAAA,GAEpBC,IAAQ,CAAIC,GAAoBC,MAAmB;AAC9D,EAAAN,EAAc,KAAKK,CAAQ;AAC3B,MAAI;AACF,WAAOC,EAAA;AAAA,EACT,UAAA;AACE,IAAAN,EAAc,IAAA;AAAA,EAChB;AACF,GAEaO,IAAqB,MAChCP,EAAcA,EAAc,SAAS,CAAC,GAQ3BQ,IAAyB,CAAIF,MAAmB;AAI3D,EAAAN,EAAc,KAAK,MAAgC;AACnD,MAAI;AACF,WAAOM,EAAA;AAAA,EACT,UAAA;AACE,IAAAN,EAAc,IAAA;AAAA,EAChB;AACF,GAEaS,IAAmB,CAACJ,MAA6B;AAC5D,MAAIJ,IAAa,GAAG;AAClB,IAAAC,EAAiB,IAAIG,CAAQ;AAC7B;AAAA,EACF;AACA,EAAAA,EAAA;AACF,GAEMK,IAAiB,MAAY;AACjC,aAAWL,KAAY,MAAM,KAAKH,CAAgB;AAChD,IAAAA,EAAiB,OAAOG,CAAQ,GAChCA,EAAA;AAEJ,GAEaM,IAAa,MAAY;AACpC,EAAAV,KAAc;AAChB,GAEaW,IAAW,MAAY;AAClC,EAAAX,KAAc,GACVA,MAAe,KACjBS,EAAA;AAEJ,GAMaG,IAAqB,CAACR,GAAoBS,MAAiC;AACtF,MAAIC,IAAOZ,EAAqB,IAAIE,CAAQ;AAC5C,EAAKU,MACHA,wBAAW,IAAA,GACXZ,EAAqB,IAAIE,GAAUU,CAAI,IAEzCA,EAAK,IAAID,CAAM;AACjB,GAMaE,IAAoB,CAACX,MAA6B;AAC7D,QAAMU,IAAOZ,EAAqB,IAAIE,CAAQ;AAC9C,MAAIU,GAAM;AACR,eAAWD,KAAUC;AACnB,MAAAD,EAAO,YAAYT,CAAQ;AAE7B,IAAAU,EAAK,MAAA;AAAA,EACP;AACF;ACnFO,MAAME,EAAsC;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBjD,YAA6BC,GAAkB;AAAlB,SAAA,UAAAA,GAf7B,KAAQ,QAAQ,IAChB,KAAQ,kCAAkB,IAAA,GAC1B,KAAiB,YAAY,MAAM;AACjC,WAAK,QAAQ;AAEb,YAAMC,IAAsB,MAAM,KAAK,KAAK,WAAW;AACvD,iBAAWC,KAAcD;AACvB,QAAAV,EAAiBW,CAAU;AAAA,IAE/B;AAAA,EAMgD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMhD,IAAI,QAAW;AACb,UAAMC,IAAUd,EAAA;AAChB,WAAIc,MACF,KAAK,YAAY,IAAIA,CAAO,GAC5BR,EAAmBQ,GAAS,IAAI,IAE9B,KAAK,UACP,KAAK,QAAQ,IAEbL,EAAkB,KAAK,SAAS,GAChC,KAAK,cAAcZ,EAAM,KAAK,WAAW,KAAK,OAAO,IAEhD,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,OAAU;AACR,WAAI,KAAK,UACP,KAAK,QAAQ,IAEbY,EAAkB,KAAK,SAAS,GAChC,KAAK,cAAcZ,EAAM,KAAK,WAAW,KAAK,OAAO,IAEhD,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,YAAYC,GAA4B;AACtC,SAAK,YAAY,OAAOA,CAAQ;AAAA,EAClC;AACF;AASO,MAAMiB,IAAW,CAAIhB,MAA6B,IAAIW,EAASX,CAAE;ACvEjE,MAAMiB,EAAoC;AAAA;AAAA;AAAA;AAAA;AAAA,EAO/C,YAAoBC,GAAW;AAAX,SAAA,SAAAA,GANpB,KAAQ,kCAAkB,IAAA;AAAA,EAMM;AAAA;AAAA;AAAA;AAAA;AAAA,EAMhC,IAAI,QAAW;AACb,UAAMH,IAAUd,EAAA;AAChB,WAAIc,MACF,KAAK,YAAY,IAAIA,CAAO,GAC5BR,EAAmBQ,GAAS,IAAI,IAE3B,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,MAAMI,GAAS;AACjB,QAAI,OAAO,GAAG,KAAK,QAAQA,CAAI,EAAG;AAClC,SAAK,SAASA;AAEd,UAAMN,IAAsB,MAAM,KAAK,KAAK,WAAW;AACvD,eAAWC,KAAcD;AACvB,MAAAV,EAAiBW,CAAU;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,OAAOM,GAAkC;AACvC,SAAK,QAAQA,EAAQ,KAAK,MAAM;AAAA,EAClC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,YAAYrB,GAA4B;AACtC,SAAK,YAAY,OAAOA,CAAQ;AAAA,EAClC;AACF;AASO,MAAMsB,IAAS,CAAIC,MAAwB,IAAIL,EAAOK,CAAK;"}