@bquery/bquery 1.2.0 → 1.3.0

package/dist/core/utils/object.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Object-focused utility helpers.
+ *
+ * @module bquery/core/utils/object
+ */
+/**
+ * Checks if a value is a plain object (not null, array, or class instance).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a plain object
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Checks if a key could cause prototype pollution.
+ * These keys are dangerous when used in object merging operations.
+ *
+ * @param key - The key to check
+ * @returns True if the key is a prototype pollution vector
+ *
+ * @internal
+ */
+export declare function isPrototypePollutionKey(key: string): boolean;
+/**
+ * Creates a deep clone using structuredClone if available, otherwise fallback to JSON.
+ *
+ * @template T - The type of value being cloned
+ * @param value - The value to clone
+ * @returns A deep copy of the value
+ *
+ * @remarks
+ * When `structuredClone` is available (modern browsers, Node 17+, Bun), this function
+ * provides full deep cloning including circular references, Date, Map, Set, ArrayBuffer, etc.
+ *
+ * **JSON fallback limitations** (older environments without `structuredClone`):
+ * - **Throws** on circular references
+ * - **Drops** functions, `undefined`, and Symbol properties
+ * - **Transforms** Date → ISO string, Map/Set → empty object, BigInt → throws
+ * - **Loses** prototype chains and non-enumerable properties
+ *
+ * For guaranteed safe cloning of arbitrary data, ensure your environment supports
+ * `structuredClone` or pre-validate your data structure.
+ *
+ * @example
+ * ```ts
+ * const original = { nested: { value: 1 } };
+ * const copy = clone(original);
+ * copy.nested.value = 2;
+ * console.log(original.nested.value); // 1
+ * ```
+ */
+export declare function clone<T>(value: T): T;
+/**
+ * Deep-merges plain objects into a new object.
+ * Later sources override earlier ones for primitive values.
+ * Objects are recursively merged.
+ *
+ * @param sources - Objects to merge
+ * @returns A new object with all sources merged as an intersection type
+ *
+ * @remarks
+ * This function uses overloads to provide accurate intersection types for up to 5 sources.
+ * For more than 5 sources, the return type falls back to `Record<string, unknown>`.
+ *
+ * Note that deep merging creates a shallow intersection at the type level. Nested objects
+ * are merged at runtime, but TypeScript sees them as intersected types which may not
+ * perfectly represent the merged structure for deeply nested conflicting types.
+ *
+ * @example
+ * ```ts
+ * const result = merge(
+ *   { a: 1, nested: { x: 1 } },
+ *   { b: 2, nested: { y: 2 } }
+ * );
+ * // Result: { a: 1, b: 2, nested: { x: 1, y: 2 } }
+ * // Type: { a: number; nested: { x: number } } & { b: number; nested: { y: number } }
+ * ```
+ *
+ * @security This method is protected against prototype pollution attacks.
+ * Keys like `__proto__`, `constructor`, and `prototype` are ignored.
+ */
+export declare function merge<T1 extends Record<string, unknown>>(source1: T1): T1;
+export declare function merge<T1 extends Record<string, unknown>, T2 extends Record<string, unknown>>(source1: T1, source2: T2): T1 & T2;
+export declare function merge<T1 extends Record<string, unknown>, T2 extends Record<string, unknown>, T3 extends Record<string, unknown>>(source1: T1, source2: T2, source3: T3): T1 & T2 & T3;
+export declare function merge<T1 extends Record<string, unknown>, T2 extends Record<string, unknown>, T3 extends Record<string, unknown>, T4 extends Record<string, unknown>>(source1: T1, source2: T2, source3: T3, source4: T4): T1 & T2 & T3 & T4;
+export declare function merge<T1 extends Record<string, unknown>, T2 extends Record<string, unknown>, T3 extends Record<string, unknown>, T4 extends Record<string, unknown>, T5 extends Record<string, unknown>>(source1: T1, source2: T2, source3: T3, source4: T4, source5: T5): T1 & T2 & T3 & T4 & T5;
+export declare function merge(...sources: Record<string, unknown>[]): Record<string, unknown>;
+/**
+ * Picks specified keys from an object.
+ *
+ * @template T - The object type
+ * @template K - The key type
+ * @param obj - The source object
+ * @param keys - Keys to pick
+ * @returns A new object with only the specified keys
+ *
+ * @example
+ * ```ts
+ * const user = { name: 'John', age: 30, email: 'john@example.com' };
+ * pick(user, ['name', 'email']); // { name: 'John', email: 'john@example.com' }
+ * ```
+ */
+export declare function pick<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+/**
+ * Omits specified keys from an object.
+ *
+ * @template T - The object type
+ * @template K - The key type
+ * @param obj - The source object
+ * @param keys - Keys to omit
+ * @returns A new object without the specified keys
+ *
+ * @example
+ * ```ts
+ * const user = { name: 'John', age: 30, password: 'secret' };
+ * omit(user, ['password']); // { name: 'John', age: 30 }
+ * ```
+ */
+export declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+/**
+ * Checks if an object has a given own property.
+ *
+ * @template T - The object type
+ * @param obj - The object to check
+ * @param key - The property key
+ * @returns True if the property exists on the object
+ *
+ * @example
+ * ```ts
+ * hasOwn({ a: 1 }, 'a'); // true
+ * ```
+ */
+export declare function hasOwn<T extends object>(obj: T, key: PropertyKey): key is keyof T;
+//# sourceMappingURL=object.d.ts.map

package/dist/core/utils/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../../src/core/utils/object.ts"],"names":[],"mappings":"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"}

package/dist/core/utils/string.d.ts

@@ -0,0 +1,80 @@
+/**
+ * String-focused utility helpers.
+ *
+ * @module bquery/core/utils/string
+ */
+/**
+ * Capitalizes the first letter of a string.
+ *
+ * @param str - The string to capitalize
+ * @returns The capitalized string
+ *
+ * @example
+ * ```ts
+ * capitalize('hello'); // 'Hello'
+ * ```
+ */
+export declare function capitalize(str: string): string;
+/**
+ * Converts a string to kebab-case.
+ *
+ * @param str - The string to convert
+ * @returns The kebab-cased string
+ *
+ * @example
+ * ```ts
+ * toKebabCase('myVariableName'); // 'my-variable-name'
+ * ```
+ */
+export declare function toKebabCase(str: string): string;
+/**
+ * Converts a string to camelCase.
+ *
+ * @param str - The string to convert
+ * @returns The camelCased string
+ *
+ * @example
+ * ```ts
+ * toCamelCase('my-variable-name'); // 'myVariableName'
+ * ```
+ */
+export declare function toCamelCase(str: string): string;
+/**
+ * Truncates a string to a maximum length.
+ *
+ * @param str - The string to truncate
+ * @param maxLength - The maximum length
+ * @param suffix - The suffix to append when truncating (default: '…')
+ * @returns The truncated string
+ *
+ * @example
+ * ```ts
+ * truncate('Hello world', 8); // 'Hello w…'
+ * ```
+ */
+export declare function truncate(str: string, maxLength: number, suffix?: string): string;
+/**
+ * Converts a string to a URL-friendly slug.
+ *
+ * @param str - The string to slugify
+ * @returns The slugified string
+ *
+ * @example
+ * ```ts
+ * slugify('Hello, World!'); // 'hello-world'
+ * ```
+ */
+export declare function slugify(str: string): string;
+/**
+ * Escapes a string for safe usage inside a RegExp.
+ *
+ * @param str - The string to escape
+ * @returns The escaped string
+ *
+ * @example
+ * ```ts
+ * escapeRegExp('[a-z]+'); // '\\[a-z\\]+'
+ * ```
+ */
+export declare function escapeRegExp(str: string): string;
+//# sourceMappingURL=string.d.ts.map

package/dist/core/utils/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../src/core/utils/string.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG9C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAK/C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI/C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,SAAM,GAAG,MAAM,CAK7E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ3C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/dist/core/utils/type-guards.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Type guard helpers.
+ *
+ * @module bquery/core/utils/type-guards
+ */
+/**
+ * Checks if a value is a DOM Element.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an Element
+ */
+export declare function isElement(value: unknown): value is Element;
+/**
+ * Checks if a value is a BQueryCollection-like object.
+ *
+ * @param value - The value to check
+ * @returns True if the value has an elements array property
+ */
+export declare function isCollection(value: unknown): value is {
+    elements: Element[];
+};
+/**
+ * Checks if a value is a function.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a function
+ */
+export declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+/**
+ * Checks if a value is a string.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a string
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Checks if a value is a number (excluding NaN).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid number
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Checks if a value is a boolean.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a boolean
+ */
+export declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Checks if a value is an array.
+ *
+ * @template T - The type of array elements
+ * @param value - The value to check
+ * @returns True if the value is an array
+ */
+export declare function isArray<T = unknown>(value: unknown): value is T[];
+/**
+ * Checks if a value is a Date instance.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Date
+ */
+export declare function isDate(value: unknown): value is Date;
+/**
+ * Checks if a value is a Promise-like object.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Promise-like object
+ */
+export declare function isPromise<T = unknown>(value: unknown): value is Promise<T>;
+/**
+ * Checks if a value is a non-null object.
+ *
+ * @param value - The value to check
+ * @returns True if the value is an object
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=type-guards.d.ts.map

package/dist/core/utils/type-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guards.d.ts","sourceRoot":"","sources":["../../../src/core/utils/type-guards.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE1D;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI;IAAE,QAAQ,EAAE,OAAO,EAAE,CAAA;CAAE,CAE7E;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAEnF;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE1D;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,CAAC,EAAE,CAEjE;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,CAEpD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAQ1E;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE"}

package/dist/core-COenAZjD.js

@@ -0,0 +1,145 @@
+const r = [];
+let i = 0;
+const n = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new WeakMap(), u = (e, s) => {
+  r.push(e);
+  try {
+    return s();
+  } finally {
+    r.pop();
+  }
+}, o = () => r[r.length - 1], y = (e) => {
+  r.push(void 0);
+  try {
+    return e();
+  } finally {
+    r.pop();
+  }
+}, b = (e) => {
+  if (i > 0) {
+    n.add(e);
+    return;
+  }
+  e();
+}, d = () => {
+  for (const e of Array.from(n))
+    n.delete(e), e();
+}, v = () => {
+  i += 1;
+}, m = () => {
+  i -= 1, i === 0 && d();
+}, l = (e, s) => {
+  let t = a.get(e);
+  t || (t = /* @__PURE__ */ new Set(), a.set(e, t)), t.add(s);
+}, h = (e) => {
+  const s = a.get(e);
+  if (s) {
+    for (const t of s)
+      t.unsubscribe(e);
+    s.clear();
+  }
+};
+class f {
+  /**
+   * Creates a new computed value.
+   * @param compute - Function that computes the value
+   */
+  constructor(s) {
+    this.compute = s, this.dirty = !0, this.subscribers = /* @__PURE__ */ new Set(), this.markDirty = () => {
+      this.dirty = !0;
+      const t = Array.from(this.subscribers);
+      for (const c of t)
+        b(c);
+    };
+  }
+  /**
+   * Gets the computed value, recomputing if dependencies changed.
+   * During untrack calls, getCurrentObserver returns undefined, preventing dependency tracking.
+   */
+  get value() {
+    const s = o();
+    return s && (this.subscribers.add(s), l(s, this)), this.dirty && (this.dirty = !1, h(this.markDirty), this.cachedValue = u(this.markDirty, this.compute)), this.cachedValue;
+  }
+  /**
+   * Reads the current computed value without tracking.
+   * Useful when you need the value but don't want to create a dependency.
+   *
+   * @returns The current cached value (recomputes if dirty)
+   */
+  peek() {
+    return this.dirty && (this.dirty = !1, h(this.markDirty), this.cachedValue = u(this.markDirty, this.compute)), this.cachedValue;
+  }
+  /**
+   * Removes an observer from this computed's subscriber set.
+   * @internal
+   */
+  unsubscribe(s) {
+    this.subscribers.delete(s);
+  }
+}
+const g = (e) => new f(e);
+class p {
+  /**
+   * Creates a new signal with an initial value.
+   * @param _value - The initial value
+   */
+  constructor(s) {
+    this._value = s, this.subscribers = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Gets the current value and tracks the read if inside an observer.
+   * During untrack calls, getCurrentObserver returns undefined, preventing dependency tracking.
+   */
+  get value() {
+    const s = o();
+    return s && (this.subscribers.add(s), l(s, this)), this._value;
+  }
+  /**
+   * Sets a new value and notifies all subscribers if the value changed.
+   * Uses Object.is for equality comparison.
+   */
+  set value(s) {
+    if (Object.is(this._value, s)) return;
+    this._value = s;
+    const t = Array.from(this.subscribers);
+    for (const c of t)
+      b(c);
+  }
+  /**
+   * Reads the current value without tracking.
+   * Useful when you need the value but don't want to create a dependency.
+   *
+   * @returns The current value
+   */
+  peek() {
+    return this._value;
+  }
+  /**
+   * Updates the value using a function.
+   * Useful for updates based on the current value.
+   *
+   * @param updater - Function that receives current value and returns new value
+   */
+  update(s) {
+    this.value = s(this._value);
+  }
+  /**
+   * Removes an observer from this signal's subscriber set.
+   * @internal
+   */
+  unsubscribe(s) {
+    this.subscribers.delete(s);
+  }
+}
+const k = (e) => new p(e);
+export {
+  f as C,
+  p as S,
+  h as a,
+  v as b,
+  g as c,
+  m as e,
+  k as s,
+  u as t,
+  y as w
+};
+//# sourceMappingURL=core-COenAZjD.js.map

package/dist/core-COenAZjD.js.map

@@ -0,0 +1 @@
+{"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":"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"}