sigmx 0.1.0

package/dist/core/expr.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/expr.ts"],
+  "sourcesContent": ["// Expression compiler. Signals need no rewriting: the body runs inside `with (scope)`, where\n// `$count`, `$user.name` and `$` resolve through the store's scope proxy. Only `@action(` is\n// rewritten, into a call on the per-evaluation actions object.\n\nexport type Compiler = (params: string[], body: string) => (...args: any[]) => any\n\n/** Default compiler: `new Function`. Not usable under a strict CSP; see `cspCompiler`. */\nexport const functionCompiler: Compiler = (params, body) => Function(...params, body) as (...args: any[]) => any\n\nconst cache = new Map<string, (...args: any[]) => any>()\n\nconst isIdent = (c: string): boolean => /[A-Za-z0-9_$]/.test(c)\n\n/** Walk source text, skipping string, template and comment contents; `emit` receives code chars. */\nconst scan = (src: string, onCode: (c: string, i: number) => number | void): void => {\n  let i = 0\n  const n = src.length\n  while (i < n) {\n    const c = src[i]\n    const next = src[i + 1]\n    if (c === '\"' || c === \"'\" || c === '`') {\n      let j = i + 1\n      while (j < n && src[j] !== c) j += src[j] === '\\\\' ? 2 : 1\n      onCode(src.slice(i, j + 1), i)\n      i = j + 1\n    } else if (c === '/' && next === '/') {\n      const j = src.indexOf('\\n', i)\n      i = j < 0 ? n : j\n    } else if (c === '/' && next === '*') {\n      const j = src.indexOf('*/', i + 2)\n      i = j < 0 ? n : j + 2\n    } else {\n      const skip = onCode(c, i)\n      i += skip || 1\n    }\n  }\n}\n\n/** Replace `@name(` with `__a.name(` outside strings and comments. */\nexport const rewriteActions = (src: string): string => {\n  let out = ''\n  scan(src, (c, i) => {\n    if (c === '@') {\n      let j = i + 1\n      while (j < src.length && isIdent(src[j])) j++\n      let k = j\n      while (k < src.length && /\\s/.test(src[k])) k++\n      if (j > i + 1 && src[k] === '(') {\n        out += `__a.${src.slice(i + 1, j)}(`\n        return k + 1 - i\n      }\n    }\n    out += c\n  })\n  return out\n}\n\n/** Split on top-level semicolons. */\nexport const splitStatements = (src: string): string[] => {\n  const parts: string[] = []\n  let depth = 0\n  let start = 0\n  scan(src, (c, i) => {\n    if (c.length > 1) return\n    if ('([{'.includes(c)) depth++\n    else if (')]}'.includes(c)) depth--\n    else if (c === ';' && !depth) {\n      parts.push(src.slice(start, i))\n      start = i + 1\n    }\n  })\n  parts.push(src.slice(start))\n  return parts.filter((p) => p.trim())\n}\n\n/**\n * Compile an expression to `(scope, actions, ...params) => any`. With `returns`, the value of the\n * last statement is returned, so `$a = 1; $a * 2` works. Compiled functions are cached by source.\n */\nexport const compile = (\n  compiler: Compiler,\n  src: string,\n  params: string[],\n  returns: boolean,\n): ((...args: any[]) => any) => {\n  const key = `${+returns}|${params.join()}|${src}`\n  const hit = cache.get(key)\n  if (hit) return hit\n  const code = rewriteActions(src.trim())\n  const make = (body: string) => compiler(['$', '__a', ...params], `with($){${body}\\n}`)\n  let fn: (...args: any[]) => any\n  if (!returns) {\n    fn = make(code)\n  } else {\n    try {\n      fn = make(`return(${code}\\n)`)\n    } catch {\n      const parts = splitStatements(code)\n      const last = parts.pop() ?? ''\n      try {\n        fn = make(`${parts.join(';')};return(${last}\\n)`)\n      } catch {\n        fn = make(code)\n      }\n    }\n  }\n  cache.set(key, fn)\n  return fn\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/core/index.d.ts

@@ -0,0 +1,16 @@
+export { createSigmx, parseAttr } from './engine.js';
+export { compile, functionCompiler, rewriteActions, splitStatements } from './expr.js';
+export type { Compiler } from './expr.js';
+export { Computed, Signal, batch, computed, effect, flush, onSettled, signal, untracked } from './signals.js';
+export { createStore } from './store.js';
+export type { Patch, Store } from './store.js';
+export type * from './types.js';
+export { expand, isPlain, toPredicate } from '../utils/object.js';
+export type { Filter } from '../utils/object.js';
+export { camel, kebab, pascal, recase, snake } from '../utils/text.js';
+export { debounce, delay, throttle, toMs, withTiming, withViewTransition } from '../utils/timing.js';
+import type { ActionPlugin, AttributePlugin, HandlerPlugin } from './types.js';
+/** Type a plugin definition. Pure: registration is `createSigmx({ plugins })` or `sigmx.use()`. */
+export declare const attribute: (p: Omit<AttributePlugin, "type">) => AttributePlugin;
+export declare const action: (p: Omit<ActionPlugin, "type">) => ActionPlugin;
+export declare const handler: (p: Omit<HandlerPlugin, "type">) => HandlerPlugin;

package/dist/core/index.js

@@ -0,0 +1,46 @@
+import { createSigmx, parseAttr } from "./engine.js";
+import { compile, functionCompiler, rewriteActions, splitStatements } from "./expr.js";
+import { Computed, Signal, batch, computed, effect, flush, onSettled, signal, untracked } from "./signals.js";
+import { createStore } from "./store.js";
+import { expand, isPlain, toPredicate } from "../utils/object.js";
+import { camel, kebab, pascal, recase, snake } from "../utils/text.js";
+import { debounce, delay, throttle, toMs, withTiming, withViewTransition } from "../utils/timing.js";
+const attribute = (p) => ({ type: "attribute", ...p });
+const action = (p) => ({ type: "action", ...p });
+const handler = (p) => ({ type: "handler", ...p });
+export {
+  Computed,
+  Signal,
+  action,
+  attribute,
+  batch,
+  camel,
+  compile,
+  computed,
+  createSigmx,
+  createStore,
+  debounce,
+  delay,
+  effect,
+  expand,
+  flush,
+  functionCompiler,
+  handler,
+  isPlain,
+  kebab,
+  onSettled,
+  parseAttr,
+  pascal,
+  recase,
+  rewriteActions,
+  signal,
+  snake,
+  splitStatements,
+  throttle,
+  toMs,
+  toPredicate,
+  untracked,
+  withTiming,
+  withViewTransition
+};
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/index.ts"],
+  "sourcesContent": ["export { createSigmx, parseAttr } from './engine.js'\nexport { compile, functionCompiler, rewriteActions, splitStatements } from './expr.js'\nexport type { Compiler } from './expr.js'\nexport { Computed, Signal, batch, computed, effect, flush, onSettled, signal, untracked } from './signals.js'\nexport { createStore } from './store.js'\nexport type { Patch, Store } from './store.js'\nexport type * from './types.js'\nexport { expand, isPlain, toPredicate } from '../utils/object.js'\nexport type { Filter } from '../utils/object.js'\nexport { camel, kebab, pascal, recase, snake } from '../utils/text.js'\nexport { debounce, delay, throttle, toMs, withTiming, withViewTransition } from '../utils/timing.js'\n\nimport type { ActionPlugin, AttributePlugin, HandlerPlugin } from './types.js'\n\n/** Type a plugin definition. Pure: registration is `createSigmx({ plugins })` or `sigmx.use()`. */\nexport const attribute = (p: Omit<AttributePlugin, 'type'>): AttributePlugin => ({ type: 'attribute', ...p })\nexport const action = (p: Omit<ActionPlugin, 'type'>): ActionPlugin => ({ type: 'action', ...p })\nexport const handler = (p: Omit<HandlerPlugin, 'type'>): HandlerPlugin => ({ type: 'handler', ...p })\n"],
+  "mappings": "AAAA,SAAS,aAAa,iBAAiB;AACvC,SAAS,SAAS,kBAAkB,gBAAgB,uBAAuB;AAE3E,SAAS,UAAU,QAAQ,OAAO,UAAU,QAAQ,OAAO,WAAW,QAAQ,iBAAiB;AAC/F,SAAS,mBAAmB;AAG5B,SAAS,QAAQ,SAAS,mBAAmB;AAE7C,SAAS,OAAO,OAAO,QAAQ,QAAQ,aAAa;AACpD,SAAS,UAAU,OAAO,UAAU,MAAM,YAAY,0BAA0B;AAKzE,MAAM,YAAY,CAAC,OAAuD,EAAE,MAAM,aAAa,GAAG,EAAE;AACpG,MAAM,SAAS,CAAC,OAAiD,EAAE,MAAM,UAAU,GAAG,EAAE;AACxF,MAAM,UAAU,CAAC,OAAmD,EAAE,MAAM,WAAW,GAAG,EAAE;",
+  "names": []
+}

package/dist/core/signals.d.ts

@@ -0,0 +1,42 @@
+interface Tracker {
+    _deps: Map<Signal<any>, number>;
+    _invalidate(): void;
+}
+export declare class Signal<T> {
+    /** @internal */ _v: T;
+    /** @internal */ _ver: number;
+    /** @internal */ _subs: Set<Tracker>;
+    constructor(v: T);
+    get value(): T;
+    set value(x: T);
+    /** Read without subscribing. */
+    peek(): T;
+    /** Notify subscribers without replacing the value (after mutating an array or object in place). */
+    bump(): void;
+}
+export declare class Computed<T> extends Signal<T> implements Tracker {
+    _deps: Map<Signal<any>, number>;
+    /** @internal */ _dirty: boolean;
+    /** @internal */ _fn: () => T;
+    constructor(fn: () => T);
+    /** @internal */ _refresh(): void;
+    get value(): T;
+    set value(_: T);
+    peek(): T;
+    _invalidate(): void;
+}
+export declare const signal: <T>(value: T) => Signal<T>;
+export declare const computed: <T>(fn: () => T) => Computed<T>;
+/**
+ * Run `fn` now and again whenever a signal it read changes. Effects created inside another
+ * effect are disposed when the parent re-runs. Returns a disposer.
+ */
+export declare const effect: (fn: () => void, onError?: (e: unknown) => void) => (() => void);
+/** Coalesce many writes into one round of effect runs. */
+export declare const batch: <R>(fn: () => R) => R;
+/** Read signals inside `fn` without subscribing the current effect to them. */
+export declare const untracked: <R>(fn: () => R) => R;
+/** Called after each flush once every queued effect has run. */
+export declare const onSettled: (fn: () => void) => (() => void);
+export declare const flush: () => void;
+export {};

package/dist/core/signals.js

@@ -0,0 +1,195 @@
+let active;
+let owner;
+let depth = 0;
+let flushing = false;
+const queue = /* @__PURE__ */ new Set();
+const settled = /* @__PURE__ */ new Set();
+class Signal {
+  constructor(v) {
+    /** @internal */
+    this.e = 0;
+    /** @internal */
+    this.f = /* @__PURE__ */ new Set();
+    this.a = v;
+  }
+  get value() {
+    if (active) {
+      active.b.set(this, this.e);
+      this.f.add(active);
+    }
+    return this.a;
+  }
+  set value(x) {
+    if (!Object.is(x, this.a)) {
+      this.a = x;
+      this.bump();
+    }
+  }
+  /** Read without subscribing. */
+  peek() {
+    return this.a;
+  }
+  /** Notify subscribers without replacing the value (after mutating an array or object in place). */
+  bump() {
+    this.e++;
+    for (const s of [...this.f]) s.h();
+    if (!depth) flush();
+  }
+}
+const release = (t) => {
+  for (const d of t.b.keys()) d.f.delete(t);
+  t.b.clear();
+};
+const stale = (t) => {
+  for (const [d, seen] of t.b) {
+    if (d instanceof Computed) d.i();
+    if (d.e !== seen) return true;
+  }
+  return false;
+};
+const capture = (t, fn) => {
+  release(t);
+  const prev = active;
+  active = t;
+  try {
+    return fn();
+  } finally {
+    active = prev;
+  }
+};
+class Computed extends Signal {
+  constructor(fn) {
+    super(void 0);
+    this.b = /* @__PURE__ */ new Map();
+    /** @internal */
+    this.g = true;
+    this.c = fn;
+  }
+  /** @internal */
+  i() {
+    if (!this.g) return;
+    this.g = false;
+    if (this.b.size && !stale(this)) return;
+    const x = capture(this, this.c);
+    if (!Object.is(x, this.a)) {
+      this.a = x;
+      this.e++;
+    }
+  }
+  get value() {
+    this.i();
+    return super.value;
+  }
+  set value(_) {
+    throw new Error("computed signals are read-only");
+  }
+  peek() {
+    this.i();
+    return this.a;
+  }
+  h() {
+    if (!this.g) {
+      this.g = true;
+      for (const s of this.f) s.h();
+    }
+  }
+}
+class Effect {
+  constructor(fn, onError) {
+    this.b = /* @__PURE__ */ new Map();
+    this.j = false;
+    this.k = false;
+    this.d = /* @__PURE__ */ new Set();
+    this.c = fn;
+    this.l = onError;
+  }
+  h() {
+    if (!this.k && !this.j) {
+      this.j = true;
+      queue.add(this);
+    }
+  }
+  n() {
+    this.j = false;
+    if (this.k || this.b.size && !stale(this)) return;
+    for (const c of this.d) c.m();
+    this.d.clear();
+    const prevOwner = owner;
+    owner = this;
+    depth++;
+    try {
+      capture(this, this.c);
+    } catch (e) {
+      if (!this.l) throw e;
+      this.l(e);
+    } finally {
+      depth--;
+      owner = prevOwner;
+    }
+  }
+  m() {
+    this.k = true;
+    release(this);
+    for (const c of this.d) c.m();
+    this.d.clear();
+    queue.delete(this);
+  }
+}
+const signal = (value) => new Signal(value);
+const computed = (fn) => new Computed(fn);
+const effect = (fn, onError) => {
+  const e = new Effect(fn, onError);
+  owner?.d.add(e);
+  e.n();
+  if (!depth) flush();
+  return () => e.m();
+};
+const batch = (fn) => {
+  depth++;
+  try {
+    return fn();
+  } finally {
+    if (!--depth) flush();
+  }
+};
+const untracked = (fn) => {
+  const prev = active;
+  active = void 0;
+  try {
+    return fn();
+  } finally {
+    active = prev;
+  }
+};
+const onSettled = (fn) => {
+  settled.add(fn);
+  return () => settled.delete(fn);
+};
+const flush = () => {
+  if (flushing || depth) return;
+  flushing = true;
+  try {
+    let guard = 0;
+    while (queue.size) {
+      if (++guard > 1e5) throw new Error("effect loop: a signal is written by an effect that reads it");
+      const e = queue.values().next().value;
+      queue.delete(e);
+      e.n();
+    }
+  } finally {
+    flushing = false;
+  }
+  for (const fn of settled) fn();
+};
+export {
+  Computed,
+  Signal,
+  batch,
+  computed,
+  effect,
+  flush,
+  onSettled,
+  signal,
+  untracked
+};
+//# sourceMappingURL=signals.js.map

package/dist/core/signals.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/signals.ts"],
+  "sourcesContent": ["// Reactive primitives: push invalidation, pull recomputation, version-checked effects.\n// No DOM dependency, so this module is unit-testable in plain Node.\n// Members prefixed with `_` are internal and get mangled by the build.\n\ninterface Tracker {\n  _deps: Map<Signal<any>, number>\n  _invalidate(): void\n}\n\nlet active: Tracker | undefined\nlet owner: Effect | undefined\nlet depth = 0\nlet flushing = false\nconst queue = new Set<Effect>()\nconst settled = new Set<() => void>()\n\nexport class Signal<T> {\n  /** @internal */ _v: T\n  /** @internal */ _ver = 0\n  /** @internal */ _subs = new Set<Tracker>()\n  constructor(v: T) {\n    this._v = v\n  }\n  get value(): T {\n    if (active) {\n      active._deps.set(this, this._ver)\n      this._subs.add(active)\n    }\n    return this._v\n  }\n  set value(x: T) {\n    if (!Object.is(x, this._v)) {\n      this._v = x\n      this.bump()\n    }\n  }\n  /** Read without subscribing. */\n  peek(): T {\n    return this._v\n  }\n  /** Notify subscribers without replacing the value (after mutating an array or object in place). */\n  bump(): void {\n    this._ver++\n    for (const s of [...this._subs]) s._invalidate()\n    if (!depth) flush()\n  }\n}\n\nconst release = (t: Tracker): void => {\n  for (const d of t._deps.keys()) d._subs.delete(t)\n  t._deps.clear()\n}\n\n/** True when any dependency's version moved since the tracker last ran. Refreshes computeds on the way. */\nconst stale = (t: Tracker): boolean => {\n  for (const [d, seen] of t._deps) {\n    if (d instanceof Computed) d._refresh()\n    if (d._ver !== seen) return true\n  }\n  return false\n}\n\nconst capture = <R>(t: Tracker, fn: () => R): R => {\n  release(t)\n  const prev = active\n  active = t\n  try {\n    return fn()\n  } finally {\n    active = prev\n  }\n}\n\nexport class Computed<T> extends Signal<T> implements Tracker {\n  _deps = new Map<Signal<any>, number>()\n  /** @internal */ _dirty = true\n  /** @internal */ _fn: () => T\n  constructor(fn: () => T) {\n    super(undefined as T)\n    this._fn = fn\n  }\n  /** @internal */ _refresh(): void {\n    if (!this._dirty) return\n    this._dirty = false\n    if (this._deps.size && !stale(this)) return\n    const x = capture(this, this._fn)\n    if (!Object.is(x, this._v)) {\n      this._v = x\n      this._ver++\n    }\n  }\n  override get value(): T {\n    this._refresh()\n    return super.value\n  }\n  override set value(_: T) {\n    throw new Error('computed signals are read-only')\n  }\n  override peek(): T {\n    this._refresh()\n    return this._v\n  }\n  _invalidate(): void {\n    if (!this._dirty) {\n      this._dirty = true\n      for (const s of this._subs) s._invalidate()\n    }\n  }\n}\n\nclass Effect implements Tracker {\n  _deps = new Map<Signal<any>, number>()\n  _queued = false\n  _dead = false\n  _kids = new Set<Effect>()\n  _fn: () => void\n  _onError?: (e: unknown) => void\n  constructor(fn: () => void, onError?: (e: unknown) => void) {\n    this._fn = fn\n    this._onError = onError\n  }\n  _invalidate(): void {\n    if (!this._dead && !this._queued) {\n      this._queued = true\n      queue.add(this)\n    }\n  }\n  _exec(): void {\n    this._queued = false\n    if (this._dead || (this._deps.size && !stale(this))) return\n    for (const c of this._kids) c._dispose()\n    this._kids.clear()\n    const prevOwner = owner\n    owner = this\n    depth++\n    try {\n      capture(this, this._fn)\n    } catch (e) {\n      if (!this._onError) throw e\n      this._onError(e)\n    } finally {\n      depth--\n      owner = prevOwner\n    }\n  }\n  _dispose(): void {\n    this._dead = true\n    release(this)\n    for (const c of this._kids) c._dispose()\n    this._kids.clear()\n    queue.delete(this)\n  }\n}\n\nexport const signal = <T>(value: T): Signal<T> => new Signal(value)\nexport const computed = <T>(fn: () => T): Computed<T> => new Computed(fn)\n\n/**\n * Run `fn` now and again whenever a signal it read changes. Effects created inside another\n * effect are disposed when the parent re-runs. Returns a disposer.\n */\nexport const effect = (fn: () => void, onError?: (e: unknown) => void): (() => void) => {\n  const e = new Effect(fn, onError)\n  owner?._kids.add(e)\n  e._exec()\n  if (!depth) flush()\n  return () => e._dispose()\n}\n\n/** Coalesce many writes into one round of effect runs. */\nexport const batch = <R>(fn: () => R): R => {\n  depth++\n  try {\n    return fn()\n  } finally {\n    if (!--depth) flush()\n  }\n}\n\n/** Read signals inside `fn` without subscribing the current effect to them. */\nexport const untracked = <R>(fn: () => R): R => {\n  const prev = active\n  active = undefined\n  try {\n    return fn()\n  } finally {\n    active = prev\n  }\n}\n\n/** Called after each flush once every queued effect has run. */\nexport const onSettled = (fn: () => void): (() => void) => {\n  settled.add(fn)\n  return () => settled.delete(fn)\n}\n\nexport const flush = (): void => {\n  if (flushing || depth) return\n  flushing = true\n  try {\n    let guard = 0\n    while (queue.size) {\n      if (++guard > 1e5) throw new Error('effect loop: a signal is written by an effect that reads it')\n      const e: Effect = queue.values().next().value!\n      queue.delete(e)\n      e._exec()\n    }\n  } finally {\n    flushing = false\n  }\n  for (const fn of settled) fn()\n}\n"],
+  "mappings": "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",
+  "names": ["_ver", "_subs", "_v", "_deps", "_invalidate", "_refresh", "_dirty", "_fn", "_queued", "_dead", "_kids", "_onError", "_exec", "_dispose"]
+}

package/dist/core/store.d.ts

@@ -0,0 +1,32 @@
+import { Signal } from './signals.js';
+import { type Filter } from '../utils/object.js';
+export type Patch = Record<string, any>;
+export interface Store {
+    /** Value at a dotted path: a leaf value, a namespace proxy, or undefined. Reads subscribe. */
+    get(path: string): any;
+    /** Replace the value at a path. Plain objects become namespaces; null/undefined removes. */
+    set(path: string, value: any): void;
+    /** JSON merge-patch (RFC 7396): objects merge, null removes, everything else replaces. */
+    merge(patch: Patch, options?: {
+        at?: string;
+        ifMissing?: boolean;
+    }): void;
+    remove(path: string): void;
+    has(path: string): boolean;
+    /** Install a computed (or any signal) as the leaf at a path. */
+    define(path: string, node: Signal<any>): void;
+    /** Leaf paths, optionally filtered. */
+    paths(filter?: Filter): string[];
+    /** Plain-object copy of the store or a namespace. */
+    snapshot(filter?: Filter, options?: {
+        at?: string;
+        computed?: boolean;
+    }): Patch;
+    /** Called after each settled batch with the nested object of changed paths (null = removed). */
+    onPatch(fn: (patch: Patch) => void): () => void;
+    /** Root namespace proxy: `$.count`, `$.user.name = 'x'`, `JSON.stringify($)`. */
+    readonly $: any;
+    /** Identifier scope for compiled expressions: resolves `$count`, `$user`, and `$`. */
+    readonly scope: object;
+}
+export declare const createStore: () => Store;

package/dist/core/store.js

@@ -0,0 +1,185 @@
+import { Computed, Signal, batch, onSettled } from "./signals.js";
+import { expand, isPlain, toPredicate } from "../utils/object.js";
+const parentOf = (p) => p.slice(0, Math.max(0, p.lastIndexOf(".")));
+const nameOf = (p) => p.slice(p.lastIndexOf(".") + 1);
+const join = (a, b) => a ? `${a}.${b}` : b;
+const under = (p, at) => !at || p === at || p.startsWith(`${at}.`);
+const createStore = () => {
+  const leaves = /* @__PURE__ */ new Map();
+  const kids = /* @__PURE__ */ new Map([["", /* @__PURE__ */ new Set()]]);
+  const shape = new Signal(0);
+  const pending = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const nsCache = /* @__PURE__ */ new Map();
+  const arrCache = /* @__PURE__ */ new WeakMap();
+  const ensureNs = (p) => {
+    let set2 = kids.get(p);
+    if (!set2) {
+      if (leaves.has(p)) dropLeaf(p);
+      kids.set(p, set2 = /* @__PURE__ */ new Set());
+      ensureNs(parentOf(p)).add(nameOf(p));
+      shape.bump();
+    }
+    return set2;
+  };
+  const dropLeaf = (p) => {
+    const s = leaves.get(p);
+    if (!s) return;
+    leaves.delete(p);
+    kids.get(parentOf(p))?.delete(nameOf(p));
+    pending.set(p, null);
+    s.bump();
+    shape.bump();
+  };
+  const dropNs = (p) => {
+    const set2 = kids.get(p);
+    if (!set2) return;
+    for (const k of [...set2]) remove(join(p, k));
+    if (p) {
+      kids.delete(p);
+      kids.get(parentOf(p))?.delete(nameOf(p));
+      nsCache.delete(p);
+    }
+    shape.bump();
+  };
+  const remove = (p) => batch(() => {
+    dropLeaf(p);
+    dropNs(p);
+  });
+  const define = (p, node) => batch(() => {
+    if (kids.has(p)) dropNs(p);
+    const old = leaves.get(p);
+    leaves.set(p, node);
+    ensureNs(parentOf(p)).add(nameOf(p));
+    old?.bump();
+    shape.bump();
+  });
+  const set = (p, v) => batch(() => {
+    if (v == null) return remove(p);
+    if (isPlain(v)) {
+      const names = ensureNs(p);
+      for (const k of [...names]) if (!(k in v)) remove(join(p, k));
+      for (const k in v) set(join(p, k), v[k]);
+      return;
+    }
+    if (kids.has(p)) dropNs(p);
+    const s = leaves.get(p);
+    if (s instanceof Computed) throw new Error(`"${p}" is a computed signal and cannot be assigned`);
+    if (s) {
+      if (Object.is(s.peek(), v)) return;
+      s.value = v;
+    } else {
+      define(p, new Signal(v));
+    }
+    pending.set(p, v);
+  });
+  const merge = (patch, { at = "", ifMissing = false } = {}) => batch(() => {
+    if (!isPlain(patch)) return;
+    ensureNs(at);
+    for (const k in patch) {
+      const p = join(at, k);
+      const v = patch[k];
+      if (v === null) {
+        if (!ifMissing) remove(p);
+      } else if (isPlain(v)) {
+        merge(v, { at: p, ifMissing });
+      } else if (!(ifMissing && (leaves.has(p) || kids.has(p))) && !(leaves.get(p) instanceof Computed)) {
+        set(p, v);
+      }
+    }
+  });
+  const wrapArray = (raw, s, p) => {
+    let px = arrCache.get(raw);
+    if (!px) {
+      const touch = () => {
+        pending.set(p, raw);
+        s.bump();
+      };
+      px = new Proxy(raw, {
+        set: (t, k, v) => (t[k] = v, touch(), true),
+        deleteProperty: (t, k) => (delete t[k], touch(), true)
+      });
+      arrCache.set(raw, px);
+    }
+    return px;
+  };
+  const get = (p) => {
+    const s = leaves.get(p);
+    if (s) {
+      const v = s.value;
+      return Array.isArray(v) ? wrapArray(v, s, p) : v;
+    }
+    if (kids.has(p)) return ns(p);
+    shape.value;
+    return void 0;
+  };
+  const ns = (p) => {
+    let px = nsCache.get(p);
+    if (!px) {
+      const names = () => (shape.value, kids.get(p));
+      px = new Proxy(/* @__PURE__ */ Object.create(null), {
+        get: (_, k) => typeof k !== "string" ? void 0 : k === "toJSON" ? () => snapshot(void 0, { at: p }) : get(join(p, k)),
+        set: (_, k, v) => (typeof k === "string" && set(join(p, k), v), true),
+        deleteProperty: (_, k) => (typeof k === "string" && remove(join(p, k)), true),
+        has: (_, k) => typeof k === "string" && !!names()?.has(k),
+        ownKeys: () => [...names() ?? []],
+        getOwnPropertyDescriptor: (_, k) => typeof k === "string" && names()?.has(k) ? { enumerable: true, configurable: true, writable: true, value: get(join(p, k)) } : void 0
+      });
+      nsCache.set(p, px);
+    }
+    return px;
+  };
+  const scope = new Proxy(/* @__PURE__ */ Object.create(null), {
+    has: (_, k) => typeof k === "string" && k[0] === "$",
+    get: (_, k) => typeof k !== "string" ? void 0 : k === "$" ? ns("") : get(k.slice(1)),
+    set: (_, k, v) => {
+      if (typeof k === "string") k === "$" ? merge(v) : set(k.slice(1), v);
+      return true;
+    }
+  });
+  const paths = (filter) => {
+    shape.value;
+    const ok = toPredicate(filter);
+    return [...leaves.keys()].filter(ok);
+  };
+  const snapshot = (filter, { at = "", computed = true } = {}) => {
+    shape.value;
+    const ok = toPredicate(filter);
+    const out = {};
+    const rel = (p) => at ? p.slice(at.length + 1) : p;
+    for (const [p, s] of leaves) {
+      if (!under(p, at) || !ok(p) || !computed && s instanceof Computed) continue;
+      expand(out, rel(p), s.value);
+    }
+    for (const p of kids.keys()) {
+      if (p && p !== at && under(p, at) && ok(p) && !kids.get(p).size) expand(out, rel(p), {});
+    }
+    return out;
+  };
+  onSettled(() => {
+    if (!pending.size) return;
+    const patch = {};
+    for (const [p, v] of pending) expand(patch, p, v);
+    pending.clear();
+    for (const fn of listeners) fn(patch);
+  });
+  return {
+    get,
+    set,
+    merge,
+    remove,
+    has: (p) => leaves.has(p) || kids.has(p),
+    define,
+    paths,
+    snapshot,
+    onPatch: (fn) => (listeners.add(fn), () => listeners.delete(fn)),
+    get $() {
+      return ns("");
+    },
+    scope
+  };
+};
+export {
+  createStore
+};
+//# sourceMappingURL=store.js.map

package/dist/core/store.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/store.ts"],
+  "sourcesContent": ["// Path-keyed signal store with JSON merge-patch semantics. No DOM dependency.\nimport { Computed, Signal, batch, onSettled } from './signals.js'\nimport { expand, isPlain, toPredicate, type Filter } from '../utils/object.js'\n\nexport type Patch = Record<string, any>\n\nexport interface Store {\n  /** Value at a dotted path: a leaf value, a namespace proxy, or undefined. Reads subscribe. */\n  get(path: string): any\n  /** Replace the value at a path. Plain objects become namespaces; null/undefined removes. */\n  set(path: string, value: any): void\n  /** JSON merge-patch (RFC 7396): objects merge, null removes, everything else replaces. */\n  merge(patch: Patch, options?: { at?: string; ifMissing?: boolean }): void\n  remove(path: string): void\n  has(path: string): boolean\n  /** Install a computed (or any signal) as the leaf at a path. */\n  define(path: string, node: Signal<any>): void\n  /** Leaf paths, optionally filtered. */\n  paths(filter?: Filter): string[]\n  /** Plain-object copy of the store or a namespace. */\n  snapshot(filter?: Filter, options?: { at?: string; computed?: boolean }): Patch\n  /** Called after each settled batch with the nested object of changed paths (null = removed). */\n  onPatch(fn: (patch: Patch) => void): () => void\n  /** Root namespace proxy: `$.count`, `$.user.name = 'x'`, `JSON.stringify($)`. */\n  readonly $: any\n  /** Identifier scope for compiled expressions: resolves `$count`, `$user`, and `$`. */\n  readonly scope: object\n}\n\nconst parentOf = (p: string): string => p.slice(0, Math.max(0, p.lastIndexOf('.')))\nconst nameOf = (p: string): string => p.slice(p.lastIndexOf('.') + 1)\nconst join = (a: string, b: string): string => (a ? `${a}.${b}` : b)\nconst under = (p: string, at: string): boolean => !at || p === at || p.startsWith(`${at}.`)\n\nexport const createStore = (): Store => {\n  const leaves = new Map<string, Signal<any>>()\n  const kids = new Map<string, Set<string>>([['', new Set()]])\n  const shape = new Signal(0) // bumped on any structural change; enumerations subscribe to it\n  const pending = new Map<string, any>()\n  const listeners = new Set<(p: Patch) => void>()\n  const nsCache = new Map<string, any>()\n  const arrCache = new WeakMap<object, any>()\n\n  const ensureNs = (p: string): Set<string> => {\n    let set = kids.get(p)\n    if (!set) {\n      if (leaves.has(p)) dropLeaf(p)\n      kids.set(p, (set = new Set()))\n      ensureNs(parentOf(p)).add(nameOf(p))\n      shape.bump()\n    }\n    return set\n  }\n\n  const dropLeaf = (p: string): void => {\n    const s = leaves.get(p)\n    if (!s) return\n    leaves.delete(p)\n    kids.get(parentOf(p))?.delete(nameOf(p))\n    pending.set(p, null)\n    s.bump()\n    shape.bump()\n  }\n\n  const dropNs = (p: string): void => {\n    const set = kids.get(p)\n    if (!set) return\n    for (const k of [...set]) remove(join(p, k))\n    if (p) {\n      kids.delete(p)\n      kids.get(parentOf(p))?.delete(nameOf(p))\n      nsCache.delete(p)\n    }\n    shape.bump()\n  }\n\n  const remove = (p: string): void =>\n    batch(() => {\n      dropLeaf(p)\n      dropNs(p)\n    })\n\n  const define = (p: string, node: Signal<any>): void =>\n    batch(() => {\n      if (kids.has(p)) dropNs(p)\n      const old = leaves.get(p)\n      leaves.set(p, node)\n      ensureNs(parentOf(p)).add(nameOf(p))\n      old?.bump()\n      shape.bump()\n    })\n\n  const set = (p: string, v: any): void =>\n    batch(() => {\n      if (v == null) return remove(p)\n      if (isPlain(v)) {\n        const names = ensureNs(p)\n        for (const k of [...names]) if (!(k in v)) remove(join(p, k))\n        for (const k in v) set(join(p, k), v[k])\n        return\n      }\n      if (kids.has(p)) dropNs(p)\n      const s = leaves.get(p)\n      if (s instanceof Computed) throw new Error(`\"${p}\" is a computed signal and cannot be assigned`)\n      if (s) {\n        if (Object.is(s.peek(), v)) return\n        s.value = v\n      } else {\n        define(p, new Signal(v))\n      }\n      pending.set(p, v)\n    })\n\n  const merge = (patch: Patch, { at = '', ifMissing = false } = {}): void =>\n    batch(() => {\n      if (!isPlain(patch)) return\n      ensureNs(at)\n      for (const k in patch) {\n        const p = join(at, k)\n        const v = patch[k]\n        if (v === null) {\n          if (!ifMissing) remove(p)\n        } else if (isPlain(v)) {\n          merge(v, { at: p, ifMissing })\n        } else if (!(ifMissing && (leaves.has(p) || kids.has(p))) && !(leaves.get(p) instanceof Computed)) {\n          set(p, v) // computed leaves are skipped: patches from storage or a server cannot overwrite them\n        }\n      }\n    })\n\n  /** Arrays are returned through a proxy so in-place mutation notifies the leaf. */\n  const wrapArray = (raw: any[], s: Signal<any>, p: string): any => {\n    let px = arrCache.get(raw)\n    if (!px) {\n      const touch = () => {\n        pending.set(p, raw)\n        s.bump()\n      }\n      px = new Proxy(raw, {\n        set: (t, k, v) => ((t as any)[k] = v, touch(), true),\n        deleteProperty: (t, k) => (delete (t as any)[k], touch(), true),\n      })\n      arrCache.set(raw, px)\n    }\n    return px\n  }\n\n  const get = (p: string): any => {\n    const s = leaves.get(p)\n    if (s) {\n      const v = s.value\n      return Array.isArray(v) ? wrapArray(v, s, p) : v\n    }\n    if (kids.has(p)) return ns(p)\n    shape.value // subscribe, so creating this path later re-runs the reader\n    return undefined\n  }\n\n  const ns = (p: string): any => {\n    let px = nsCache.get(p)\n    if (!px) {\n      const names = () => (shape.value, kids.get(p))\n      px = new Proxy(Object.create(null), {\n        get: (_, k) =>\n          typeof k !== 'string' ? undefined : k === 'toJSON' ? () => snapshot(undefined, { at: p }) : get(join(p, k)),\n        set: (_, k, v) => (typeof k === 'string' && set(join(p, k), v), true),\n        deleteProperty: (_, k) => (typeof k === 'string' && remove(join(p, k)), true),\n        has: (_, k) => typeof k === 'string' && !!names()?.has(k),\n        ownKeys: () => [...(names() ?? [])],\n        getOwnPropertyDescriptor: (_, k) =>\n          typeof k === 'string' && names()?.has(k)\n            ? { enumerable: true, configurable: true, writable: true, value: get(join(p, k)) }\n            : undefined,\n      })\n      nsCache.set(p, px)\n    }\n    return px\n  }\n\n  const scope = new Proxy(Object.create(null), {\n    has: (_, k) => typeof k === 'string' && k[0] === '$',\n    get: (_, k) => (typeof k !== 'string' ? undefined : k === '$' ? ns('') : get(k.slice(1))),\n    set: (_, k, v) => {\n      if (typeof k === 'string') k === '$' ? merge(v) : set(k.slice(1), v)\n      return true\n    },\n  })\n\n  const paths = (filter?: Filter): string[] => {\n    shape.value\n    const ok = toPredicate(filter)\n    return [...leaves.keys()].filter(ok)\n  }\n\n  const snapshot = (filter?: Filter, { at = '', computed = true } = {}): Patch => {\n    shape.value\n    const ok = toPredicate(filter)\n    const out: Patch = {}\n    const rel = (p: string) => (at ? p.slice(at.length + 1) : p)\n    for (const [p, s] of leaves) {\n      if (!under(p, at) || !ok(p) || (!computed && s instanceof Computed)) continue\n      expand(out, rel(p), s.value)\n    }\n    // Empty namespaces still appear as `{}`.\n    for (const p of kids.keys()) {\n      if (p && p !== at && under(p, at) && ok(p) && !kids.get(p)!.size) expand(out, rel(p), {})\n    }\n    return out\n  }\n\n  onSettled(() => {\n    if (!pending.size) return\n    const patch: Patch = {}\n    for (const [p, v] of pending) expand(patch, p, v)\n    pending.clear()\n    for (const fn of listeners) fn(patch)\n  })\n\n  return {\n    get,\n    set,\n    merge,\n    remove,\n    has: (p) => leaves.has(p) || kids.has(p),\n    define,\n    paths,\n    snapshot,\n    onPatch: (fn) => (listeners.add(fn), () => listeners.delete(fn)),\n    get $() {\n      return ns('')\n    },\n    scope,\n  }\n}\n"],
+  "mappings": "AACA,SAAS,UAAU,QAAQ,OAAO,iBAAiB;AACnD,SAAS,QAAQ,SAAS,mBAAgC;AA2B1D,MAAM,WAAW,CAAC,MAAsB,EAAE,MAAM,GAAG,KAAK,IAAI,GAAG,EAAE,YAAY,GAAG,CAAC,CAAC;AAClF,MAAM,SAAS,CAAC,MAAsB,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;AACpE,MAAM,OAAO,CAAC,GAAW,MAAuB,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK;AAClE,MAAM,QAAQ,CAAC,GAAW,OAAwB,CAAC,MAAM,MAAM,MAAM,EAAE,WAAW,GAAG,EAAE,GAAG;AAEnF,MAAM,cAAc,MAAa;AACtC,QAAM,SAAS,oBAAI,IAAyB;AAC5C,QAAM,OAAO,oBAAI,IAAyB,CAAC,CAAC,IAAI,oBAAI,IAAI,CAAC,CAAC,CAAC;AAC3D,QAAM,QAAQ,IAAI,OAAO,CAAC;AAC1B,QAAM,UAAU,oBAAI,IAAiB;AACrC,QAAM,YAAY,oBAAI,IAAwB;AAC9C,QAAM,UAAU,oBAAI,IAAiB;AACrC,QAAM,WAAW,oBAAI,QAAqB;AAE1C,QAAM,WAAW,CAAC,MAA2B;AAC3C,QAAIA,OAAM,KAAK,IAAI,CAAC;AACpB,QAAI,CAACA,MAAK;AACR,UAAI,OAAO,IAAI,CAAC,EAAG,UAAS,CAAC;AAC7B,WAAK,IAAI,GAAIA,OAAM,oBAAI,IAAI,CAAE;AAC7B,eAAS,SAAS,CAAC,CAAC,EAAE,IAAI,OAAO,CAAC,CAAC;AACnC,YAAM,KAAK;AAAA,IACb;AACA,WAAOA;AAAA,EACT;AAEA,QAAM,WAAW,CAAC,MAAoB;AACpC,UAAM,IAAI,OAAO,IAAI,CAAC;AACtB,QAAI,CAAC,EAAG;AACR,WAAO,OAAO,CAAC;AACf,SAAK,IAAI,SAAS,CAAC,CAAC,GAAG,OAAO,OAAO,CAAC,CAAC;AACvC,YAAQ,IAAI,GAAG,IAAI;AACnB,MAAE,KAAK;AACP,UAAM,KAAK;AAAA,EACb;AAEA,QAAM,SAAS,CAAC,MAAoB;AAClC,UAAMA,OAAM,KAAK,IAAI,CAAC;AACtB,QAAI,CAACA,KAAK;AACV,eAAW,KAAK,CAAC,GAAGA,IAAG,EAAG,QAAO,KAAK,GAAG,CAAC,CAAC;AAC3C,QAAI,GAAG;AACL,WAAK,OAAO,CAAC;AACb,WAAK,IAAI,SAAS,CAAC,CAAC,GAAG,OAAO,OAAO,CAAC,CAAC;AACvC,cAAQ,OAAO,CAAC;AAAA,IAClB;AACA,UAAM,KAAK;AAAA,EACb;AAEA,QAAM,SAAS,CAAC,MACd,MAAM,MAAM;AACV,aAAS,CAAC;AACV,WAAO,CAAC;AAAA,EACV,CAAC;AAEH,QAAM,SAAS,CAAC,GAAW,SACzB,MAAM,MAAM;AACV,QAAI,KAAK,IAAI,CAAC,EAAG,QAAO,CAAC;AACzB,UAAM,MAAM,OAAO,IAAI,CAAC;AACxB,WAAO,IAAI,GAAG,IAAI;AAClB,aAAS,SAAS,CAAC,CAAC,EAAE,IAAI,OAAO,CAAC,CAAC;AACnC,SAAK,KAAK;AACV,UAAM,KAAK;AAAA,EACb,CAAC;AAEH,QAAM,MAAM,CAAC,GAAW,MACtB,MAAM,MAAM;AACV,QAAI,KAAK,KAAM,QAAO,OAAO,CAAC;AAC9B,QAAI,QAAQ,CAAC,GAAG;AACd,YAAM,QAAQ,SAAS,CAAC;AACxB,iBAAW,KAAK,CAAC,GAAG,KAAK,EAAG,KAAI,EAAE,KAAK,GAAI,QAAO,KAAK,GAAG,CAAC,CAAC;AAC5D,iBAAW,KAAK,EAAG,KAAI,KAAK,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC;AACvC;AAAA,IACF;AACA,QAAI,KAAK,IAAI,CAAC,EAAG,QAAO,CAAC;AACzB,UAAM,IAAI,OAAO,IAAI,CAAC;AACtB,QAAI,aAAa,SAAU,OAAM,IAAI,MAAM,IAAI,CAAC,+CAA+C;AAC/F,QAAI,GAAG;AACL,UAAI,OAAO,GAAG,EAAE,KAAK,GAAG,CAAC,EAAG;AAC5B,QAAE,QAAQ;AAAA,IACZ,OAAO;AACL,aAAO,GAAG,IAAI,OAAO,CAAC,CAAC;AAAA,IACzB;AACA,YAAQ,IAAI,GAAG,CAAC;AAAA,EAClB,CAAC;AAEH,QAAM,QAAQ,CAAC,OAAc,EAAE,KAAK,IAAI,YAAY,MAAM,IAAI,CAAC,MAC7D,MAAM,MAAM;AACV,QAAI,CAAC,QAAQ,KAAK,EAAG;AACrB,aAAS,EAAE;AACX,eAAW,KAAK,OAAO;AACrB,YAAM,IAAI,KAAK,IAAI,CAAC;AACpB,YAAM,IAAI,MAAM,CAAC;AACjB,UAAI,MAAM,MAAM;AACd,YAAI,CAAC,UAAW,QAAO,CAAC;AAAA,MAC1B,WAAW,QAAQ,CAAC,GAAG;AACrB,cAAM,GAAG,EAAE,IAAI,GAAG,UAAU,CAAC;AAAA,MAC/B,WAAW,EAAE,cAAc,OAAO,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,CAAC,aAAa,WAAW;AACjG,YAAI,GAAG,CAAC;AAAA,MACV;AAAA,IACF;AAAA,EACF,CAAC;AAGH,QAAM,YAAY,CAAC,KAAY,GAAgB,MAAmB;AAChE,QAAI,KAAK,SAAS,IAAI,GAAG;AACzB,QAAI,CAAC,IAAI;AACP,YAAM,QAAQ,MAAM;AAClB,gBAAQ,IAAI,GAAG,GAAG;AAClB,UAAE,KAAK;AAAA,MACT;AACA,WAAK,IAAI,MAAM,KAAK;AAAA,QAClB,KAAK,CAAC,GAAG,GAAG,OAAQ,EAAU,CAAC,IAAI,GAAG,MAAM,GAAG;AAAA,QAC/C,gBAAgB,CAAC,GAAG,OAAO,OAAQ,EAAU,CAAC,GAAG,MAAM,GAAG;AAAA,MAC5D,CAAC;AACD,eAAS,IAAI,KAAK,EAAE;AAAA,IACtB;AACA,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,CAAC,MAAmB;AAC9B,UAAM,IAAI,OAAO,IAAI,CAAC;AACtB,QAAI,GAAG;AACL,YAAM,IAAI,EAAE;AACZ,aAAO,MAAM,QAAQ,CAAC,IAAI,UAAU,GAAG,GAAG,CAAC,IAAI;AAAA,IACjD;AACA,QAAI,KAAK,IAAI,CAAC,EAAG,QAAO,GAAG,CAAC;AAC5B,UAAM;AACN,WAAO;AAAA,EACT;AAEA,QAAM,KAAK,CAAC,MAAmB;AAC7B,QAAI,KAAK,QAAQ,IAAI,CAAC;AACtB,QAAI,CAAC,IAAI;AACP,YAAM,QAAQ,OAAO,MAAM,OAAO,KAAK,IAAI,CAAC;AAC5C,WAAK,IAAI,MAAM,uBAAO,OAAO,IAAI,GAAG;AAAA,QAClC,KAAK,CAAC,GAAG,MACP,OAAO,MAAM,WAAW,SAAY,MAAM,WAAW,MAAM,SAAS,QAAW,EAAE,IAAI,EAAE,CAAC,IAAI,IAAI,KAAK,GAAG,CAAC,CAAC;AAAA,QAC5G,KAAK,CAAC,GAAG,GAAG,OAAO,OAAO,MAAM,YAAY,IAAI,KAAK,GAAG,CAAC,GAAG,CAAC,GAAG;AAAA,QAChE,gBAAgB,CAAC,GAAG,OAAO,OAAO,MAAM,YAAY,OAAO,KAAK,GAAG,CAAC,CAAC,GAAG;AAAA,QACxE,KAAK,CAAC,GAAG,MAAM,OAAO,MAAM,YAAY,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC;AAAA,QACxD,SAAS,MAAM,CAAC,GAAI,MAAM,KAAK,CAAC,CAAE;AAAA,QAClC,0BAA0B,CAAC,GAAG,MAC5B,OAAO,MAAM,YAAY,MAAM,GAAG,IAAI,CAAC,IACnC,EAAE,YAAY,MAAM,cAAc,MAAM,UAAU,MAAM,OAAO,IAAI,KAAK,GAAG,CAAC,CAAC,EAAE,IAC/E;AAAA,MACR,CAAC;AACD,cAAQ,IAAI,GAAG,EAAE;AAAA,IACnB;AACA,WAAO;AAAA,EACT;AAEA,QAAM,QAAQ,IAAI,MAAM,uBAAO,OAAO,IAAI,GAAG;AAAA,IAC3C,KAAK,CAAC,GAAG,MAAM,OAAO,MAAM,YAAY,EAAE,CAAC,MAAM;AAAA,IACjD,KAAK,CAAC,GAAG,MAAO,OAAO,MAAM,WAAW,SAAY,MAAM,MAAM,GAAG,EAAE,IAAI,IAAI,EAAE,MAAM,CAAC,CAAC;AAAA,IACvF,KAAK,CAAC,GAAG,GAAG,MAAM;AAChB,UAAI,OAAO,MAAM,SAAU,OAAM,MAAM,MAAM,CAAC,IAAI,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC;AACnE,aAAO;AAAA,IACT;AAAA,EACF,CAAC;AAED,QAAM,QAAQ,CAAC,WAA8B;AAC3C,UAAM;AACN,UAAM,KAAK,YAAY,MAAM;AAC7B,WAAO,CAAC,GAAG,OAAO,KAAK,CAAC,EAAE,OAAO,EAAE;AAAA,EACrC;AAEA,QAAM,WAAW,CAAC,QAAiB,EAAE,KAAK,IAAI,WAAW,KAAK,IAAI,CAAC,MAAa;AAC9E,UAAM;AACN,UAAM,KAAK,YAAY,MAAM;AAC7B,UAAM,MAAa,CAAC;AACpB,UAAM,MAAM,CAAC,MAAe,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC,IAAI;AAC1D,eAAW,CAAC,GAAG,CAAC,KAAK,QAAQ;AAC3B,UAAI,CAAC,MAAM,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,KAAM,CAAC,YAAY,aAAa,SAAW;AACrE,aAAO,KAAK,IAAI,CAAC,GAAG,EAAE,KAAK;AAAA,IAC7B;AAEA,eAAW,KAAK,KAAK,KAAK,GAAG;AAC3B,UAAI,KAAK,MAAM,MAAM,MAAM,GAAG,EAAE,KAAK,GAAG,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,EAAG,KAAM,QAAO,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC;AAAA,IAC1F;AACA,WAAO;AAAA,EACT;AAEA,YAAU,MAAM;AACd,QAAI,CAAC,QAAQ,KAAM;AACnB,UAAM,QAAe,CAAC;AACtB,eAAW,CAAC,GAAG,CAAC,KAAK,QAAS,QAAO,OAAO,GAAG,CAAC;AAChD,YAAQ,MAAM;AACd,eAAW,MAAM,UAAW,IAAG,KAAK;AAAA,EACtC,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,KAAK,CAAC,MAAM,OAAO,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC;AAAA,IACvC;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS,CAAC,QAAQ,UAAU,IAAI,EAAE,GAAG,MAAM,UAAU,OAAO,EAAE;AAAA,IAC9D,IAAI,IAAI;AACN,aAAO,GAAG,EAAE;AAAA,IACd;AAAA,IACA;AAAA,EACF;AACF;",
+  "names": ["set"]
+}