@raphy-js/raph 1.0.1-dev.25 → 1.0.1-dev.54

package/dist/observable.js

@@ -0,0 +1,1187 @@
+import { REACTIVE_OBJECT_IDENTITY as ee, WRITE_NESTED as le, WRITE_CALLBACK as de, getReactiveObjectSupport as he, isPlainReactiveValue as U } from "./debug/reactivity/reactive-object.js";
+const B = Symbol("size"), K = Symbol("time"), I = Symbol("params"), be = new Set(Object.getOwnPropertyNames(Date.prototype).filter((t) => t.startsWith("set"))), we = /* @__PURE__ */ new Set(["append", "delete", "set", "sort"]), ve = Object.freeze([]);
+class $ {
+  _key;
+  _source;
+  _map;
+  get(e) {
+    if (this._source !== void 0 && j(e, this._key))
+      return this._source;
+    const r = this._map?.get(e);
+    return r !== void 0 && (this._key = e, this._source = r), r;
+  }
+  set(e, r) {
+    this._map !== void 0 ? this._map.set(e, r) : this._source !== void 0 && !j(e, this._key) && (this._map = /* @__PURE__ */ new Map([[this._key, this._source], [e, r]])), this._key = e, this._source = r;
+  }
+  delete(e) {
+    const r = this._source !== void 0 && j(e, this._key), n = this._map?.delete(e) ?? r;
+    return r && (this._key = void 0, this._source = void 0), this._map?.size === 0 && (this._map = void 0), n;
+  }
+  keys() {
+    return this._map?.keys() ?? (this._source === void 0 ? [] : [this._key]).values();
+  }
+}
+function j(t, e) {
+  return t === e || t !== t && e !== e;
+}
+function ye(t, e, r) {
+  const n = e instanceof Map ? "map" : e instanceof Set ? "set" : e instanceof WeakMap ? "weak-map" : e instanceof WeakSet ? "weak-set" : e instanceof Date ? "date" : e instanceof URL ? "url" : e instanceof URLSearchParams ? "params" : void 0;
+  if (n === void 0)
+    throw new TypeError("[Raph] Unsupported observable value; use makeObservable, an adapter, or observableBuffer.");
+  const o = {
+    raw: e,
+    context: t,
+    kind: n,
+    deep: r,
+    sources: /* @__PURE__ */ new Map(),
+    getDeps: new $(),
+    hasDeps: new $(),
+    sizeSource: void 0,
+    keysSource: void 0,
+    valuesSource: void 0,
+    methods: /* @__PURE__ */ Object.create(null),
+    view: void 0
+  }, s = new Proxy(e, {
+    get(i, a) {
+      if (a === ee)
+        return t.support.identity(e);
+      t.assertRead();
+      const c = o.methods[a];
+      return c === void 0 ? me(o, a) : c;
+    },
+    set(i, a, c) {
+      if (n !== "url")
+        throw new TypeError("[Raph] Observable native properties cannot be assigned; use their native methods.");
+      return oe(o, () => Reflect.set(e, a, c, e));
+    },
+    defineProperty() {
+      throw new TypeError("[Raph] Observable native properties cannot be redefined.");
+    },
+    deleteProperty() {
+      throw new TypeError("[Raph] Observable native properties cannot be deleted.");
+    }
+  });
+  return o.view = s, t.registerNative(o), s;
+}
+function me(t, e) {
+  const { context: r, raw: n, kind: o, deep: s } = t;
+  if (e === "constructor")
+    return Reflect.get(n, e, n);
+  if (o === "url") {
+    if (e === "searchParams") {
+      const c = r.wrap(n.searchParams, s);
+      return r.native(n.searchParams).parent = new WeakRef(t), c;
+    }
+    r.track(t.sources, e);
+  }
+  e === "size" && (o === "map" || o === "set" ? z(t, "sizeSource") : r.track(t.sources, B));
+  const i = Reflect.get(n, e, n);
+  if (typeof i != "function")
+    return i;
+  const a = Oe(t, e) ?? ((...c) => ge(t, e, i, c));
+  return t.methods[e] = a, a;
+}
+function ge(t, e, r, n) {
+  const { context: o, raw: s, kind: i } = t;
+  return o.assertRead(), i === "date" ? typeof e == "string" && be.has(e) ? o.write(() => {
+    const a = s.getTime(), c = Reflect.apply(r, s, n);
+    return Object.is(a, s.getTime()) || o.notify(t.sources, K), c;
+  }) : (o.track(t.sources, K), Reflect.apply(r, s, n)) : i === "url" ? (o.track(t.sources, "href"), Reflect.apply(r, s, n)) : i === "params" ? Ee(t, e, r, n) : i === "weak-map" || i === "weak-set" ? Ae(t, e, r, n) : Reflect.apply(r, s, n);
+}
+function Oe(t, e) {
+  const { context: r, raw: n, kind: o } = t;
+  if (!(o !== "map" && o !== "set")) {
+    if (e === "get" && o === "map")
+      return (s) => (r.assertRead(), r.track(t.getDeps, s), r.wrapChild(n.get(s), t.deep));
+    if (e === "has")
+      return (s) => (r.assertRead(), r.track(t.hasDeps, s), n.has(s));
+    if (e === "set" && o === "map")
+      return (s, i) => {
+        r.assertRead(), r.unwrap(s);
+        const a = r.unwrap(i);
+        return P(t, Re, s, a);
+      };
+    if (e === "add" && o === "set")
+      return (s) => (r.assertRead(), r.unwrap(s), P(t, _e, s, void 0));
+    if (e === "delete")
+      return (s) => (r.assertRead(), P(t, Se, s, void 0));
+    if (e === "clear")
+      return () => (r.assertRead(), r.write(() => {
+        if (n.size === 0)
+          return;
+        const s = [.../* @__PURE__ */ new Set([...t.getDeps.keys(), ...t.hasDeps.keys()])].filter((i) => n.has(i));
+        n.clear();
+        for (const i of s)
+          r.notify(t.getDeps, i), r.notify(t.hasDeps, i);
+        re(t);
+      }));
+    if (e === "keys" || e === "values" || e === "entries" || e === Symbol.iterator)
+      return () => (r.assertRead(), z(t, e === "keys" ? "keysSource" : "valuesSource"), Te(t, e));
+    if (e === "forEach")
+      return (s, i) => {
+        if (r.assertRead(), typeof s != "function")
+          throw new TypeError("[Raph] forEach callback must be a function.");
+        z(t, "valuesSource"), n.forEach((a, c) => {
+          r.assertRead();
+          const u = o === "map" ? r.wrapChild(a, t.deep) : a;
+          Reflect.apply(s, i, [u, c, t.view]);
+        });
+      };
+  }
+}
+function P(t, e, r, n) {
+  const o = t.context.support, s = o.openWrite();
+  if (s === le)
+    return e(t, r, n);
+  if (s === de)
+    return t.context.write(() => e(t, r, n));
+  let i;
+  try {
+    i = e(t, r, n);
+  } catch (a) {
+    throw o.failWrite(a);
+  }
+  return o.closeWrite(), i;
+}
+function Re(t, e, r) {
+  const { context: n, raw: o } = t, s = o.get(e), i = s !== void 0 || o.has(e);
+  return o.set(e, r), (!i || !Object.is(s, r)) && (n.notify(t.getDeps, e), y(t, t.valuesSource), i || (n.notify(t.hasDeps, e), y(t, t.sizeSource), y(t, t.keysSource))), t.view;
+}
+function _e(t, e, r) {
+  const { context: n, raw: o } = t, s = o.has(e);
+  return o.add(e), s || (y(t, t.valuesSource), n.notify(t.hasDeps, e), y(t, t.sizeSource), y(t, t.keysSource)), t.view;
+}
+function Se(t, e, r) {
+  const { context: n, raw: o } = t, s = o.delete(e);
+  return s && (n.notify(t.getDeps, e), n.notify(t.hasDeps, e), re(t)), s;
+}
+class te {
+  constructor(e, r) {
+    this._record = e, this._key = r;
+  }
+  _iterator;
+  next() {
+    const e = this._record;
+    if (e === void 0)
+      return { value: void 0, done: !0 };
+    try {
+      const r = this._iterator ??= Reflect.apply(e.raw[this._key], e.raw, ve);
+      e.context.assertRead();
+      const n = r.next();
+      return n.done ? (this._close(), { value: void 0, done: !0 }) : (e.kind === "map" && this._key !== "keys" && (this._key === "values" ? n.value = e.context.wrapChild(n.value, e.deep) : n.value[1] = e.context.wrapChild(n.value[1], e.deep)), n);
+    } catch (r) {
+      throw this._close(), r;
+    }
+  }
+  return(e) {
+    return this._close(), { value: e, done: !0 };
+  }
+  throw(e) {
+    throw this._close(), e;
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  _close() {
+    this._record = void 0, this._iterator = void 0;
+  }
+}
+Object.setPrototypeOf(te.prototype, Object.getPrototypeOf(Object.getPrototypeOf((function* () {
+})())));
+function Te(t, e) {
+  return new te(t, e);
+}
+function re(t) {
+  y(t, t.sizeSource), y(t, t.keysSource), y(t, t.valuesSource);
+}
+function y(t, e) {
+  e !== void 0 && t.context.support.bridge.trigger(e);
+}
+function z(t, e) {
+  const r = t.context.support.bridge;
+  if (!r.isTracking())
+    return;
+  let n = t[e];
+  n === void 0 && (n = r.createTransient(() => {
+    t[e] = void 0;
+  }), t[e] = n), r.track(n);
+}
+function ke(t, e, r) {
+  const { context: n } = t, o = n.support.bridge;
+  if (!o.isTracking() || typeof r != "object" && typeof r != "function" && typeof r != "symbol" || r === null || typeof r == "symbol" && Symbol.keyFor(r) !== void 0)
+    return;
+  let s = e.get(r);
+  if (s === void 0) {
+    const i = new WeakRef(r);
+    s = o.createTransient(() => {
+      const a = i.deref();
+      a !== void 0 && e.delete(a);
+    }), e.set(r, s);
+  }
+  o.track(s);
+}
+function Ae(t, e, r, n) {
+  const { context: o, raw: s } = t;
+  if (e === "get" || e === "has") {
+    ke(t, e === "get" ? t.weakGet ??= /* @__PURE__ */ new WeakMap() : t.weakHas ??= /* @__PURE__ */ new WeakMap(), n[0]);
+    const i = Reflect.apply(r, s, n);
+    return e === "get" ? o.wrapChild(i, t.deep) : i;
+  }
+  if (e === "set" || e === "add" || e === "delete") {
+    o.unwrap(n[0]);
+    const i = e === "set" ? o.unwrap(n[1]) : n[0];
+    return o.write(() => {
+      const a = s.has(n[0]), c = t.kind === "weak-map" ? s.get(n[0]) : n[0], u = Reflect.apply(r, s, e === "set" ? [n[0], i] : n);
+      if (e === "delete" ? u : !a || !Object.is(c, i)) {
+        const p = t.weakGet?.get(n[0]);
+        if (p !== void 0 && o.support.bridge.trigger(p), e === "delete" || !a) {
+          const l = t.weakHas?.get(n[0]);
+          l !== void 0 && o.support.bridge.trigger(l);
+        }
+      }
+      return e === "delete" ? u : t.view;
+    });
+  }
+  return Reflect.apply(r, s, n);
+}
+function ne(t) {
+  const e = /* @__PURE__ */ new Map();
+  for (const r of t.sources.keys())
+    e.set(r, r === B ? t.raw.size : r === I ? t.raw.toString() : JSON.stringify(t.raw.getAll(r)));
+  return e;
+}
+function se(t, e) {
+  for (const [r, n] of e) {
+    const o = r === B ? t.raw.size : r === I ? t.raw.toString() : JSON.stringify(t.raw.getAll(r));
+    n !== o && t.context.notify(t.sources, r);
+  }
+}
+function Ee(t, e, r, n) {
+  const { context: o, raw: s } = t;
+  if (typeof e == "string" && we.has(e)) {
+    const a = t.parent?.deref();
+    return a !== void 0 ? oe(a, () => Reflect.apply(r, s, n)) : o.write(() => {
+      const c = ne(t), u = Reflect.apply(r, s, n);
+      return se(t, c), u;
+    });
+  }
+  if (o.track(t.sources, e === "get" || e === "getAll" || e === "has" ? String(n[0]) : I), e === "forEach") {
+    if (typeof n[0] != "function")
+      throw new TypeError("[Raph] forEach callback must be a function.");
+    return s.forEach((a, c) => {
+      o.assertRead(), Reflect.apply(n[0], n[1], [a, c, t.view]);
+    });
+  }
+  const i = Reflect.apply(r, s, n);
+  return e === "entries" || e === "keys" || e === "values" || e === Symbol.iterator ? je(o, i) : i;
+}
+function* je(t, e) {
+  for (; ; ) {
+    t.assertRead();
+    const r = e.next();
+    if (r.done)
+      return;
+    yield r.value;
+  }
+}
+function oe(t, e) {
+  const { context: r, raw: n } = t;
+  return r.write(() => {
+    const o = /* @__PURE__ */ new Map();
+    for (const c of t.sources.keys())
+      o.set(c, Reflect.get(n, c, n));
+    const s = r.native(n.searchParams), i = s === void 0 ? void 0 : ne(s), a = e();
+    for (const [c, u] of o)
+      u !== Reflect.get(n, c, n) && r.notify(t.sources, c);
+    return s !== void 0 && i !== void 0 && se(s, i), a;
+  });
+}
+const C = /* @__PURE__ */ new WeakMap();
+class Pe {
+  runtime;
+  support;
+  engine;
+  unwrap;
+  write;
+  /** Owner record engine для identity экземпляров class plan. */
+  identityContext;
+  // Native records; plain views хранятся в записи raw (серия Raph Top-1).
+  _views = /* @__PURE__ */ new WeakMap();
+  _members = /* @__PURE__ */ new WeakMap();
+  _classActions;
+  _finalizers = /* @__PURE__ */ new Set();
+  _disposed = !1;
+  constructor(e) {
+    this.runtime = e, this.engine = e._getReactivity(), e.reactive({}), this.support = he(this.engine), this.unwrap = this.support.unwrap, this.write = this.support.write, this.identityContext = this.support.identity(this).context, e.rootScope.own(() => this.dispose());
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  /** Policy читается каждый раз: Runtime переключает её между быстрой и проверяющей. */
+  assertRead() {
+    this.support.policy.assertRead?.();
+  }
+  wrap(e, r = !0) {
+    if (this.assertRead(), e === null || typeof e != "object")
+      return e;
+    const n = this._members.get(e);
+    if (n !== void 0)
+      return Object.hasOwn(n, "view") ? n.view : e;
+    const o = this.support.observedView(e) ?? this._views.get(e);
+    if (o !== void 0) {
+      if (o.deep !== r)
+        throw new TypeError("[Raph] Observable depth is already fixed for this value.");
+      return o.view;
+    }
+    const s = this.support.unwrap(e), i = this._members.get(s);
+    if (i !== void 0)
+      return Object.hasOwn(i, "view") ? i.view : s;
+    if (U(s)) {
+      const c = this.support.wrap(s, this, r);
+      return this.support.observedView(s) === void 0 && this.support.setObservedView(s, c, r), c;
+    }
+    const a = this._views.get(s);
+    if (a !== void 0) {
+      if (a.deep !== r)
+        throw new TypeError("[Raph] Observable depth is already fixed for this value.");
+      return a.view;
+    }
+    return ye(this, s, r);
+  }
+  wrapChild(e, r) {
+    if (!r)
+      return this.support.unwrap(e), e;
+    if (e === null || typeof e != "object")
+      return e;
+    const n = this.support.observedView(e) ?? this._views.get(e);
+    if (n !== void 0) {
+      if (!n.deep)
+        throw new TypeError("[Raph] Observable depth is already fixed for this value.");
+      return n.view;
+    }
+    const o = this.support.unwrap(e);
+    return U(o) || this._members.has(o) || Me(o) ? this.wrap(o, !0) : e;
+  }
+  assertUnwrappedTarget(e) {
+    if (this.unwrap(e) !== e || this.support.hasView(e) || this.support.observedView(e) !== void 0 || this._views.has(e))
+      throw new TypeError("[Raph] Instrument the original value before observable wrapping.");
+  }
+  /**
+   * Проверка цели для экземпляра класса с готовым планом. Proxy view создаётся только для plain
+   * objects и arrays, native view — только для native prototypes, поэтому достаточно identity.
+   */
+  assertUnwrappedClassTarget(e) {
+    if (this.unwrap(e) !== e)
+      throw new TypeError("[Raph] Instrument the original value before observable wrapping.");
+  }
+  registerAdapterView(e, r) {
+    e === null || typeof e != "object" || this.unwrap(e) !== e || this._members.has(e) || (this.assertUnwrappedTarget(e), this.registerMember(e, r));
+  }
+  readValue(e, r) {
+    return this.wrapChild(e, r);
+  }
+  registerNative(e) {
+    this.support.claim(e.raw), this._views.set(e.raw, e);
+  }
+  native(e) {
+    const r = this._views.get(e);
+    return r !== void 0 && "raw" in r ? r : void 0;
+  }
+  member(e) {
+    return this._members.get(e);
+  }
+  registerMember(e, r) {
+    this.support.claim(e), this._members.set(e, r);
+  }
+  /**
+   * Регистрирует admin class plan без глобального rawOwners: владение публикует сам экземпляр
+   * через identity record. Read boundary проверяется так же, как в claim.
+   */
+  registerClassAdmin(e, r) {
+    this.assertRead(), this._members.set(e, r);
+  }
+  classAction(e, r) {
+    const n = this._classActions ??= /* @__PURE__ */ new WeakMap(), o = String(e), s = n.get(r);
+    if (s?.name === o)
+      return s.invoke;
+    if (!o.trim())
+      throw new Error("[Raph] Action name must not be empty.");
+    const i = (a, c, u) => this.runtime._invokeAction(o, this.runtime.rootScope, a, u, c);
+    return n.set(r, { name: o, invoke: i }), i;
+  }
+  track(e, r, n) {
+    const o = this.support.bridge;
+    if (!o.isTracking())
+      return;
+    let s = e.get(r);
+    s === void 0 && (s = o.createTransient(() => {
+      e.delete(r), n?.();
+    }), e.set(r, s)), o.track(s);
+  }
+  notify(e, r) {
+    const n = e.get(r);
+    n !== void 0 && this.support.bridge.trigger(n);
+  }
+  retainFinalizer(e) {
+    const r = new WeakRef(e);
+    if (this._finalizers.add(r), this._finalizers.size % 128 === 0)
+      for (const n of this._finalizers)
+        n.deref() === void 0 && this._finalizers.delete(n);
+  }
+  computed(e) {
+    let r, n;
+    const o = () => (this.assertRead(), r === void 0 && !this.engine._isTracking() ? e() : (n === void 0 && (n = { dispose: () => {
+      const s = r;
+      r = void 0, s?.dispose();
+    } }, this.retainFinalizer(n)), r ??= this.engine._ownedComputed(
+      () => this.engine.runWithOwner(this.engine._lifecycle, this.runtime.rootScope, e),
+      {
+        dependencyOwner: this.runtime.rootScope,
+        onDependency: () => () => {
+          r !== void 0 && !this.support.bridge.hasMultipleSubscribers(r.source) && n.dispose();
+        }
+      }
+    ), r.source.get()));
+    return { get: o, peek: () => this.runtime.untracked(o) };
+  }
+  adapterContext() {
+    const e = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Set();
+    let o;
+    const s = {
+      active: !0,
+      dispose: () => {
+        if (!s.active)
+          return;
+        s.active = !1, o?.();
+        const a = [];
+        for (const c of r.values()) {
+          const u = c.stop;
+          c.stop = void 0, c.count = 0;
+          try {
+            u?.();
+          } catch (d) {
+            a.push(d);
+          }
+        }
+        for (const c of e.values())
+          try {
+            this.support.bridge.release(c);
+          } catch (u) {
+            a.push(u);
+          }
+        e.clear(), r.clear();
+        for (const c of n)
+          try {
+            c();
+          } catch (u) {
+            a.push(u);
+          }
+        if (n.clear(), a.length > 0)
+          throw new AggregateError(a, "[Raph] Observable adapter cleanup failed.");
+      }
+    };
+    return this.retainFinalizer(s), { context: {
+      track: (a) => {
+        if (!s.active)
+          throw this.assertRead(), new Error("[Raph] Adapter is disposed.");
+        this.assertRead();
+        const c = this.support.bridge;
+        if (!c.isTracking())
+          return;
+        let u = e.get(a);
+        u === void 0 && (u = c.create({
+          onDependency: () => {
+            const d = r.get(a);
+            if (d !== void 0 && d.count++ === 0)
+              try {
+                d.stop = d.subscribe() ?? void 0;
+              } catch (p) {
+                throw --d.count, p;
+              }
+            return () => {
+              if (c.hasMultipleSubscribers(u) || e.delete(a), d !== void 0 && d.count > 0 && --d.count === 0) {
+                const p = d.stop;
+                d.stop = void 0, p?.();
+              }
+            };
+          }
+        }), e.set(a, u)), c.track(u);
+      },
+      notify: (a) => {
+        if (!s.active)
+          throw this.assertRead(), new Error("[Raph] Adapter is disposed.");
+        this.assertRead();
+        const c = () => this.support.bridge.batch(() => this.notify(e, a));
+        this.support.policy.runWrite === void 0 ? c() : this.support.policy.runWrite(c);
+      },
+      mutate: (a, c) => {
+        if (!s.active)
+          throw this.assertRead(), new Error("[Raph] Adapter is disposed.");
+        return this.write(() => {
+          try {
+            return c();
+          } finally {
+            this.notify(e, a);
+          }
+        });
+      },
+      onObserved: (a, c) => {
+        if (!s.active)
+          throw this.assertRead(), new Error("[Raph] Adapter is disposed.");
+        if (this.assertRead(), e.has(a) || r.has(a))
+          throw new TypeError("[Raph] onObserved must be registered before the first tracked read.");
+        if (typeof c != "function")
+          throw new TypeError("[Raph] subscribe must be a function.");
+        r.set(a, { subscribe: c, count: 0 });
+      },
+      onDispose: (a) => {
+        if (!s.active)
+          throw this.assertRead(), new Error("[Raph] Adapter is disposed.");
+        if (this.assertRead(), typeof a != "function")
+          throw new TypeError("[Raph] cleanup must be a function.");
+        n.add(a), o ??= this.runtime.rootScope.own(s.dispose);
+      }
+    }, dispose: s.dispose };
+  }
+  dispose() {
+    if (this._disposed)
+      return;
+    this._disposed = !0, C.delete(this.runtime), this._classActions = void 0;
+    const e = [];
+    for (const r of this._finalizers)
+      try {
+        r.deref()?.dispose();
+      } catch (n) {
+        e.push(n);
+      }
+    if (this._finalizers.clear(), e.length > 0)
+      throw new AggregateError(e, "[Raph] Observable cleanup failed.");
+  }
+}
+function V(t) {
+  t.rootScope._assertAlive();
+  let e = C.get(t);
+  return e === void 0 && (e = new Pe(t), C.set(t, e)), e;
+}
+const ie = /* @__PURE__ */ new Set([
+  Map.prototype,
+  Set.prototype,
+  WeakMap.prototype,
+  WeakSet.prototype,
+  Date.prototype,
+  URL.prototype,
+  URLSearchParams.prototype
+]);
+function Me(t) {
+  for (let e = Object.getPrototypeOf(t); e !== null && e !== Object.prototype; e = Object.getPrototypeOf(e))
+    if (ie.has(e))
+      return !0;
+  return !1;
+}
+const xe = /* @__PURE__ */ new Set([
+  ...ie,
+  ArrayBuffer.prototype,
+  ...typeof SharedArrayBuffer > "u" ? [] : [SharedArrayBuffer.prototype]
+]);
+function De(t) {
+  for (let e = Object.getPrototypeOf(t); e !== null && e !== Object.prototype; e = Object.getPrototypeOf(e))
+    if (xe.has(e))
+      return !0;
+  return ArrayBuffer.isView(t);
+}
+const G = /* @__PURE__ */ new WeakMap();
+function Xe(t, e) {
+  const r = V(t), n = ArrayBuffer.isView(e);
+  if (!n && !(e instanceof ArrayBuffer) && !(typeof SharedArrayBuffer < "u" && e instanceof SharedArrayBuffer))
+    throw new TypeError("[Raph] observableBuffer requires ArrayBuffer, SharedArrayBuffer, TypedArray or DataView.");
+  const o = n ? e.buffer : e;
+  r.support.claim(o), r.support.claim(e);
+  let s = G.get(r);
+  s === void 0 && G.set(r, s = /* @__PURE__ */ new WeakMap());
+  let i = s.get(o);
+  i === void 0 && (i = { context: r, ranges: /* @__PURE__ */ new Map() }, s.set(o, i));
+  const a = i, c = n ? e.byteOffset : 0;
+  function u(p) {
+    r.assertRead();
+    let l = e.byteLength;
+    if (l === 0 && o.byteLength === 0 && (l = new Uint8Array(o, 0, 0).byteLength), !Number.isSafeInteger(p.offset) || !Number.isSafeInteger(p.length) || p.offset < 0 || p.length < 0 || p.offset + p.length > l)
+      throw new RangeError("[Raph] Observable buffer range is outside the native view.");
+    return { start: c + p.offset, end: c + p.offset + p.length };
+  }
+  function d(p, l) {
+    for (const [h, f] of a.ranges) {
+      if (f.sources.size === 0) {
+        a.ranges.delete(h);
+        continue;
+      }
+      p < f.end && f.start < l && r.notify(f.sources, h);
+    }
+  }
+  return {
+    get value() {
+      return r.assertRead(), e;
+    },
+    read(p, l) {
+      const { start: h, end: f } = u(p);
+      if (h !== f && r.engine._isTracking()) {
+        const w = `${h}:${f}`;
+        let b = a.ranges.get(w);
+        b === void 0 && a.ranges.set(w, b = { start: h, end: f, sources: /* @__PURE__ */ new Map() }), r.track(b.sources, w, () => a.ranges.delete(w));
+      }
+      return Y(l(e));
+    },
+    mutate(p, l) {
+      const { start: h, end: f } = u(p);
+      return r.write(() => {
+        try {
+          return Y(l(e));
+        } finally {
+          d(h, f);
+        }
+      });
+    },
+    notify(p) {
+      const { start: l, end: h } = u(p), f = () => r.support.bridge.batch(() => d(l, h));
+      r.support.policy.runWrite === void 0 ? f() : r.support.policy.runWrite(f);
+    }
+  };
+}
+function Y(t) {
+  if (t !== null && (typeof t == "object" || typeof t == "function") && typeof t.then == "function")
+    throw new TypeError("[Raph] Observable buffer callbacks must be synchronous.");
+  return t;
+}
+const m = ee, g = Object.freeze([]);
+class L {
+  /** Кольцо членов строится лениво, только для повторной разметки. */
+  members = void 0;
+  options;
+  /** Identity contract engine: владелец и исходный объект. */
+  context;
+  raw;
+  observable;
+  plan;
+  /** Число полей плана, уже установленных на экземпляре (префикс `plan.fields`). */
+  fields = 0;
+  materialized = !1;
+  attached = !1;
+  /** Ленивые computed sources по slot плана. */
+  computed = void 0;
+  /** Значения полей плана по индексу `plan.fields`; общие accessors читают их через receiver. */
+  values;
+  /** Ленивые property sources полей по тому же индексу. */
+  sources = void 0;
+  constructor(e, r, n, o, s) {
+    this.context = e.identityContext, this.raw = r, this.observable = e, this.plan = n, this.options = o, this.values = s;
+  }
+}
+function S(t) {
+  if (t === null || typeof t != "object")
+    return;
+  const e = t[m];
+  return e instanceof L && e.raw === t ? e : void 0;
+}
+const M = { value: void 0, writable: !1, enumerable: !1, configurable: !0 };
+function ae(t) {
+  if (!t.attached) {
+    M.value = t;
+    try {
+      Object.defineProperty(t.raw, m, M);
+    } finally {
+      M.value = void 0;
+    }
+    t.attached = !0;
+  }
+}
+function W(t, e) {
+  const r = t.members;
+  e.next = r === void 0 ? e : r.next, r !== void 0 && (r.next = e), t.members = e;
+}
+const T = /* @__PURE__ */ new WeakMap(), F = Symbol("raph.observable.plan"), N = F, x = { value: void 0, writable: !0, enumerable: !1, configurable: !0 }, D = /* @__PURE__ */ new WeakMap(), ze = Object.prototype.__lookupGetter__;
+function q(t) {
+  const e = t[N], r = e !== void 0 && e.prototype === t ? e : T.get(t);
+  if (r == null)
+    return r;
+  const n = r.members;
+  for (let o = 0; o < n.length; o++) {
+    const s = n[o];
+    if ((s.kind === "method" ? t[s.key] : ze.call(t, s.key)) !== (s.kind === "method" ? s.wrapper : s.installed.get))
+      return;
+  }
+  return r;
+}
+function Ce(t, e) {
+  const r = T.get(t);
+  if (r === null)
+    return;
+  const n = [];
+  for (const c of Reflect.ownKeys(e)) {
+    if (c === m)
+      continue;
+    const u = Object.getOwnPropertyDescriptor(e, c);
+    if (u === void 0 || !("value" in u) || u.writable !== !0 || u.configurable !== !0 || u.enumerable !== !0)
+      return;
+    n.push(c);
+  }
+  const o = [], s = [];
+  let i = r?.slots ?? 0;
+  for (const c of Reflect.ownKeys(t)) {
+    if (c === "constructor" || c === m || c === N || n.includes(c))
+      continue;
+    const u = Object.getOwnPropertyDescriptor(t, c), d = String(c);
+    if (u.configurable !== !0 || !d.trim())
+      return J(t);
+    if (u.get !== void 0) {
+      const p = D.get(u.get);
+      if (p?.kind === "computed" && p.key === c && p.installed.set === u.set) {
+        o.push(p);
+        continue;
+      }
+      const l = Le(c, d, u, i++);
+      o.push(l), s.push({ member: l, installed: l.installed });
+    } else if (u.set === void 0 && typeof u.value == "function") {
+      const p = D.get(u.value);
+      if (p?.kind === "method" && p.key === c) {
+        o.push(p);
+        continue;
+      }
+      const l = Ue(c, d, u.value);
+      o.push(l), s.push({ member: l, installed: { configurable: !0, enumerable: u.enumerable ?? !1, writable: u.writable ?? !0, value: l.wrapper } });
+    } else
+      return J(t);
+  }
+  try {
+    for (const { member: c, installed: u } of s)
+      Object.defineProperty(t, c.key, u), D.set(c.kind === "method" ? c.wrapper : c.installed.get, c);
+  } catch {
+    return;
+  }
+  const a = { prototype: t, fields: n, fieldDescriptors: n.map(We), members: o, slots: i };
+  T.set(t, a), x.value = a;
+  try {
+    Object.defineProperty(t, N, x);
+  } catch {
+  } finally {
+    x.value = void 0;
+  }
+  return a;
+}
+function We(t, e) {
+  return {
+    configurable: !0,
+    enumerable: !0,
+    get() {
+      return Ne(H(this, t), e);
+    },
+    set(r) {
+      Ie(H(this, t), e, r);
+    }
+  };
+}
+function H(t, e) {
+  const r = S(t);
+  if (r === void 0)
+    throw new TypeError(`[Raph] Observable field accessor requires its annotated instance: ${String(e)}`);
+  return r;
+}
+function Ne(t, e) {
+  const r = t.observable;
+  r.assertRead();
+  const n = r.support.bridge, o = t.sources, s = o === void 0 ? void 0 : o[e];
+  s !== void 0 ? n.track(s) : n.isTracking() && Be(t, e, n);
+  const i = t.values[e];
+  return i === null || typeof i != "object" ? i : t.options.deep ? r.wrapChild(i, !0) : r.wrap(i, !1);
+}
+function Be(t, e, r) {
+  const n = r.createTransient(() => {
+    const o = t.sources;
+    o !== void 0 && o[e] === n && (o[e] = void 0);
+  });
+  (t.sources ??= [])[e] = n, r.track(n);
+}
+function Ie(t, e, r) {
+  const n = t.observable;
+  if (n.support.tryDirectWrite()) {
+    ce(t, e, n.unwrap(r));
+    return;
+  }
+  Ve(t, e, r);
+}
+function Ve(t, e, r) {
+  const n = t.observable;
+  n.write(() => {
+    ce(t, e, n.unwrap(r));
+  });
+}
+function ce(t, e, r) {
+  const n = t.values;
+  if (Object.is(r, n[e]))
+    return;
+  n[e] = r;
+  const o = t.sources, s = o === void 0 ? void 0 : o[e];
+  s !== void 0 && t.observable.support.bridge.trigger(s);
+}
+function J(t) {
+  T.set(t, null);
+}
+function Le(t, e, r, n) {
+  const o = r.get, s = r.set, i = { configurable: !0, enumerable: r.enumerable ?? !1 }, a = { kind: "computed", key: t, getter: o, setter: s, slot: n, installed: i };
+  return i.get = function() {
+    const c = S(this);
+    return c === void 0 ? Reflect.apply(o, this, g) : Fe(c, a);
+  }, s !== void 0 && (i.set = function(c) {
+    const u = S(this);
+    if (u === void 0) {
+      Reflect.apply(s, this, [c]);
+      return;
+    }
+    const d = u.observable.runtime;
+    d._invokeAction(e, d.rootScope, s, [c], u.raw);
+  }), a;
+}
+function Fe(t, e) {
+  const r = t.computed, n = r === void 0 ? void 0 : r[e.slot];
+  if (n !== void 0)
+    return n.get();
+  const o = t.observable;
+  o.assertRead();
+  const s = t.raw;
+  if (!o.engine._isTracking())
+    return Reflect.apply(e.getter, s, g);
+  const i = o.computed(Function.prototype.bind.call(e.getter, s));
+  return (t.computed ??= [])[e.slot] = i, i.get();
+}
+function Ue(t, e, r) {
+  return { kind: "method", key: t, original: r, wrapper: function() {
+    const o = arguments.length === 0 ? g : arguments, s = S(this);
+    if (s === void 0)
+      return Reflect.apply(r, this, o);
+    const i = s.observable;
+    if (i.assertRead(), i.engine._isTracking())
+      return Reflect.apply(r, this, o);
+    const a = i.runtime;
+    return a._invokeAction(e, a.rootScope, r, o, this);
+  } };
+}
+function Ke(t) {
+  if (t.materialized)
+    return;
+  t.materialized = !0;
+  const { plan: e, raw: r, options: n } = t;
+  for (let o = 0; o < t.fields; o++) {
+    const s = e.fields[o], i = Object.getOwnPropertyDescriptor(r, s), a = i !== void 0 && "value" in i;
+    W(t, { key: s, annotation: a ? "autoAction" : n.deep ? "observable" : "shallow", inherited: !1 });
+  }
+  for (const o of e.members)
+    W(t, o.kind === "computed" ? { key: o.key, annotation: "computed", inherited: !0, descriptor: o.installed, shared: !0 } : { key: o.key, annotation: "autoAction", inherited: !0, shared: !0 });
+  ae(t);
+}
+const k = Object.freeze({ deep: !0, autoBind: !1 }), _ = Object.freeze({});
+function et(t, e, r, n = k) {
+  return ue(t, e, r, n, !1);
+}
+function tt(t, e, r = _, n = k) {
+  return ue(t, e, r, n, !0);
+}
+function ue(t, e, r, n, o) {
+  const s = V(t);
+  if (e === null || typeof e != "object" || Array.isArray(e))
+    throw new TypeError("[Raph] makeObservable requires an initialized object or class instance.");
+  if (o && r === _ && n.autoBind !== !0) {
+    const f = Object.getPrototypeOf(e), w = f !== null && f !== Object.prototype ? q(f) : void 0;
+    if (w != null && (s.assertUnwrappedClassTarget(e), s.member(e) === void 0)) {
+      const b = Q(s, e, w, Z(n));
+      if (b !== void 0)
+        return b;
+    }
+  }
+  if (s.assertUnwrappedTarget(e), De(e))
+    throw new TypeError("[Raph] Native values use observable or observableBuffer, not class annotations.");
+  const i = Z(n), a = s.member(e);
+  if (a instanceof L && Ke(a), a !== void 0 && !Object.hasOwn(a, "members"))
+    throw new TypeError("[Raph] Target already uses a custom observable adapter.");
+  if (a !== void 0 && (a.options.deep !== i.deep || a.options.autoBind !== i.autoBind))
+    throw new TypeError("[Raph] Observable class options are already fixed.");
+  let c;
+  if (a !== void 0) {
+    c = /* @__PURE__ */ new Map();
+    const f = a.members;
+    if (f !== void 0) {
+      const w = f.next;
+      let b = w;
+      do
+        c.set(b.key, b), b = b.next;
+      while (b !== w);
+    }
+  }
+  const u = Object.getPrototypeOf(e);
+  if (o && u !== null && u !== Object.prototype && Object.getPrototypeOf(u) !== Object.prototype)
+    throw new TypeError("[Raph] makeAutoObservable does not support inheritance; use makeObservable and override.");
+  if (o && r === _ && a === void 0) {
+    if (!i.autoBind && u !== null && u !== Object.prototype) {
+      const f = q(u) ?? Ce(u, e);
+      if (f !== void 0) {
+        const w = Q(s, e, f, i);
+        if (w !== void 0)
+          return w;
+      }
+    }
+    return Ge(s, e, u, i);
+  }
+  const d = r === _, p = Reflect.ownKeys(o ? e : r);
+  if (o) {
+    if (u !== null && u !== Object.prototype)
+      for (const f of Reflect.ownKeys(u))
+        f !== "constructor" && f !== F && !Object.hasOwn(e, f) && p.push(f);
+    if (!d)
+      for (const f of Reflect.ownKeys(r))
+        p.includes(f) || p.push(f);
+  }
+  let l, h;
+  for (const f of p) {
+    if (f === "constructor" || f === m)
+      continue;
+    const w = Object.getOwnPropertyDescriptor(e, f), b = w ?? (o && u !== null && u !== Object.prototype ? Object.getOwnPropertyDescriptor(u, f) : Je(u, f));
+    if (b === void 0)
+      throw new TypeError(`[Raph] Observable member is not initialized: ${String(f)}`);
+    let v = d ? void 0 : r[f];
+    const O = c?.get(f);
+    if (d || !Object.hasOwn(r, f)) {
+      if (O !== void 0)
+        continue;
+      v = b.get !== void 0 ? "computed" : typeof b.value == "function" ? "autoAction" : i.deep ? "observable" : "shallow";
+    }
+    if (v === void 0)
+      throw new TypeError("[Raph] Missing observable annotation.");
+    const A = O?.annotation;
+    if (A !== void 0 && v !== "override") {
+      if (A === v)
+        continue;
+      throw new TypeError(`[Raph] Observable annotation is already fixed: ${String(f)}`);
+    }
+    if (v === "override") {
+      const R = O?.descriptor;
+      if (A === void 0 || R === void 0 || R.get !== b.get || R.set !== b.set || R.value !== b.value)
+        throw new TypeError("[Raph] override requires an inherited observable method or getter.");
+      if (w === void 0 && O?.shared !== !0)
+        throw new TypeError("[Raph] override requires a previously instrumented member.");
+      continue;
+    }
+    if (v !== !1) {
+      if (w !== void 0 && b.configurable === !1)
+        throw new TypeError(`[Raph] Observable member must be configurable: ${String(f)}`);
+      if (w === void 0 && !Object.isExtensible(e))
+        throw new TypeError("[Raph] Observable target is not extensible.");
+      if (v === "computed" ? typeof b.get != "function" : v === "action" || v === "action.bound" || v === "autoAction" ? typeof b.value != "function" : !(v === "observable" || v === "shallow" || v === "ref") || !("value" in b) || b.writable === !1)
+        throw new TypeError(`[Raph] Observable annotation does not match member: ${String(f)}`);
+      "value" in b && (b.value = s.unwrap(b.value));
+    }
+    const E = { key: f, descriptor: b, annotation: v, inherited: w === void 0, next: void 0 };
+    h === void 0 ? l = E : h.next = E, h = E;
+  }
+  return fe(s, e, l, i, a);
+}
+function Z(t) {
+  return t === k ? k : { deep: t.deep ?? !0, autoBind: t.autoBind ?? !1 };
+}
+function Q(t, e, r, n) {
+  const o = r.fields, s = o.length, i = e;
+  for (let l = 0; l < s; l++) {
+    const h = o[l];
+    if (!Object.hasOwn(e, h))
+      return;
+    const f = i[h];
+    f !== null && typeof f == "object" && t.unwrap(f);
+  }
+  if (!Object.isExtensible(e))
+    throw new TypeError("[Raph] Observable target is not extensible.");
+  const a = new Array(s), c = new L(t, e, r, n, a);
+  t.registerClassAdmin(e, c);
+  const u = n.deep ? "observable" : "shallow", d = r.fieldDescriptors;
+  let p = 0;
+  try {
+    for (; p < s; p++) {
+      const l = o[p], h = i[l], f = typeof h == "function";
+      a[p] = f || h === null || typeof h != "object" ? h : t.unwrap(h);
+      const w = f ? pe(t, e, l, !1, "autoAction", !1, { configurable: !0, enumerable: !0, writable: !0, value: h }) : d[p];
+      Object.defineProperty(e, l, w), c.fields = p + 1, c.materialized && W(c, { key: l, annotation: f ? "autoAction" : u, inherited: !1 });
+    }
+  } catch (l) {
+    const h = $e(e, c, p, l);
+    try {
+      t.support.claim(e);
+    } catch {
+    }
+    throw h;
+  }
+  return ae(c), e;
+}
+function $e(t, e, r, n) {
+  const o = e.plan.fields;
+  if (!e.materialized)
+    for (let s = r - 1; s >= 0; s--) {
+      try {
+        Object.defineProperty(t, o[s], { value: e.values[s], writable: !0, enumerable: !0, configurable: !0 });
+      } catch {
+        break;
+      }
+      e.fields = s;
+    }
+  return n instanceof TypeError && r < o.length && Object.getOwnPropertyDescriptor(t, o[r])?.configurable === !1 ? new TypeError(`[Raph] Observable member must be configurable: ${String(o[r])}`) : n;
+}
+function Ge(t, e, r, n) {
+  let o, s;
+  for (const i of Reflect.ownKeys(e)) {
+    if (i === "constructor" || i === m)
+      continue;
+    const a = X(t, e, i, Object.getOwnPropertyDescriptor(e, i), !1, n);
+    s === void 0 ? o = a : s.next = a, s = a;
+  }
+  if (r !== null && r !== Object.prototype)
+    for (const i of Reflect.ownKeys(r)) {
+      if (i === "constructor" || i === F || Object.hasOwn(e, i))
+        continue;
+      const a = X(t, e, i, Object.getOwnPropertyDescriptor(r, i), !0, n);
+      s === void 0 ? o = a : s.next = a, s = a;
+    }
+  return fe(t, e, o, n);
+}
+function X(t, e, r, n, o, s) {
+  if (n === void 0)
+    throw new TypeError(`[Raph] Observable member is not initialized: ${String(r)}`);
+  const i = n.get !== void 0 ? "computed" : typeof n.value == "function" ? "autoAction" : s.deep ? "observable" : "shallow";
+  if (!o && n.configurable === !1)
+    throw new TypeError(`[Raph] Observable member must be configurable: ${String(r)}`);
+  if (o && !Object.isExtensible(e))
+    throw new TypeError("[Raph] Observable target is not extensible.");
+  if ((i === "observable" || i === "shallow") && (!("value" in n) || n.writable === !1))
+    throw new TypeError(`[Raph] Observable annotation does not match member: ${String(r)}`);
+  return i !== "autoAction" && "value" in n && (n.value = t.unwrap(n.value)), { key: r, descriptor: n, annotation: i, inherited: o, next: void 0 };
+}
+function fe(t, e, r, n, o) {
+  const s = o ?? { members: void 0, options: n };
+  t.registerMember(e, s);
+  for (let i = r; i !== void 0; ) {
+    const a = i.next, { key: c, annotation: u } = i, d = i.descriptor;
+    if (i.descriptor = void 0, u === !1) {
+      const f = s.members;
+      i.next = f === void 0 ? i : f.next, f !== void 0 && (f.next = i), s.members = i, i = a;
+      continue;
+    }
+    const p = i.inherited && (u === "computed" || u === "action" || u === "action.bound"), l = Ye(t, e, i, d, n);
+    Object.defineProperty(e, c, l), p && (i.descriptor = l);
+    const h = s.members;
+    i.next = h === void 0 ? i : h.next, h !== void 0 && (h.next = i), s.members = i, i = a;
+  }
+  return e;
+}
+function Ye(t, e, r, n, o) {
+  const s = r.annotation;
+  return s === "computed" ? qe(t, e, r.key, n) : s === "action" || s === "action.bound" || s === "autoAction" ? pe(t, e, r.key, r.inherited, s, o.autoBind, n) : He(t, s, n.value, n.enumerable ?? !1);
+}
+function qe(t, e, r, n) {
+  const o = { configurable: !0, enumerable: n.enumerable ?? !1 }, s = n.get;
+  let i;
+  if (o.get = () => i !== void 0 ? i.get() : (t.assertRead(), t.engine._isTracking() ? (i = t.computed(Function.prototype.bind.call(s, e)), i.get()) : Reflect.apply(s, e, g)), n.set !== void 0) {
+    const a = n.set, c = t.classAction(r, a);
+    o.set = (u) => c(a, e, [u]);
+  }
+  return o;
+}
+function pe(t, e, r, n, o, s, i) {
+  const a = i;
+  a.configurable = !0;
+  const c = i.value, u = typeof r == "string" ? r : { key: r, name: String(r) };
+  if (!(typeof u == "string" ? u : u.name).trim())
+    throw new Error("[Raph] Action name must not be empty.");
+  const p = function() {
+    const l = arguments.length === 0 ? g : arguments;
+    t.assertRead();
+    const h = typeof u == "string" ? u : u.key, f = n ? Ze(Object.getPrototypeOf(e), h) ?? c : c;
+    return o === "autoAction" && t.engine._isTracking() ? Reflect.apply(f, this, l) : t.runtime._invokeAction(
+      typeof u == "string" ? u : u.name,
+      t.runtime.rootScope,
+      f,
+      l,
+      this
+    );
+  };
+  return a.value = o === "action.bound" || s ? p.bind(e) : p, a.writable = !0, a;
+}
+function He(t, e, r, n) {
+  const o = { configurable: !0, enumerable: n };
+  let s = r, i;
+  const a = t.support.bridge;
+  return o.get = () => (t.assertRead(), i !== void 0 ? a.track(i) : a.isTracking() && (i = a.createTransient(() => {
+    i = void 0;
+  }), a.track(i)), s === null || typeof s != "object" || e === "ref" ? s : e === "shallow" ? t.wrap(s, !1) : t.wrapChild(s, !0)), o.set = (c) => {
+    if (t.support.tryDirectWrite()) {
+      const u = t.unwrap(c);
+      if (Object.is(u, s))
+        return;
+      s = u, i !== void 0 && a.trigger(i);
+    } else {
+      const u = c;
+      t.write(() => {
+        const d = t.unwrap(u);
+        Object.is(d, s) || (s = d, i !== void 0 && a.trigger(i));
+      });
+    }
+  }, o;
+}
+function Je(t, e) {
+  for (let r = t; r !== null && r !== Object.prototype; r = Object.getPrototypeOf(r)) {
+    const n = Object.getOwnPropertyDescriptor(r, e);
+    if (n !== void 0)
+      return n;
+  }
+}
+function Ze(t, e) {
+  for (let r = t; r !== null && r !== Object.prototype; r = Object.getPrototypeOf(r)) {
+    const n = Object.getOwnPropertyDescriptor(r, e);
+    if (n !== void 0)
+      return n.value;
+  }
+}
+function rt(t, e, r = {}) {
+  const n = V(t);
+  if (e === null || typeof e != "object")
+    throw new TypeError("[Raph] observable requires an object; use signal for primitives.");
+  if (r.adapter === void 0)
+    return n.wrap(e, r.deep ?? !0);
+  n.assertRead();
+  const o = n.member(e);
+  if (o !== void 0) {
+    if (o.adapter !== r.adapter)
+      throw new TypeError("[Raph] Observable adapter is already fixed for this value.");
+    return o.view;
+  }
+  n.assertUnwrappedTarget(e), n.support.claim(e);
+  const s = n.adapterContext();
+  let i;
+  try {
+    i = r.adapter.create(e, s.context);
+    const a = { adapter: r.adapter, view: i };
+    Object.is(i, e) || n.registerAdapterView(i, a), n.registerMember(e, a);
+  } catch (a) {
+    try {
+      s.dispose();
+    } catch (c) {
+      throw new AggregateError([a, c], "[Raph] Observable adapter creation and cleanup failed.");
+    }
+    throw a;
+  }
+  return i;
+}
+function nt(t) {
+  if (typeof t?.create != "function")
+    throw new TypeError("[Raph] Observable adapter requires create().");
+  return Object.freeze({ create: t.create });
+}
+export {
+  nt as defineObservableAdapter,
+  tt as makeAutoObservable,
+  et as makeObservable,
+  rt as observable,
+  Xe as observableBuffer
+};