@fluixi/reactive 1.0.0-alpha.83 → 1.0.0-alpha.85

package/dist/lib/signal/list.mjs

@@ -1 +1,526 @@
-var ne="__fluixi_signal_next_state__",te=e=>{typeof queueMicrotask=="function"?queueMicrotask(e):Promise.resolve().then(e)},n=globalThis[ne]??={consumer:null,untracked:!1,owner:null,queue:[],scheduled:!1,flushing:!1,batchDepth:0,hostSchedule:te,onSuspend:null,onError:null,observer:null};var L="1.0.0-alpha.83";function re(e){return n.observer=e,()=>{n.observer===e&&(n.observer=null)}}var A=[],oe;function E(e){let o=n.observer;o&&o.created(e.parents===void 0?{...e,parents:A,origin:e.origin??oe}:e)}function K(e){return n.observer?(A.push(e),!0):!1}function V(){A.pop()}function W(e){n.observer?.ran?.(e)}function j(e,o){n.observer?.wrote?.(e,o)}function q(e){n.observer?.disposed?.(e)}var se="__FLUIXI_DEVTOOLS_HOOK__",M=globalThis[se];if(typeof M?.inject=="function")try{M.inject({observeReactiveNodes:re,version:L})}catch{}function D(){return n.observer!=null}var G=0,H=1,m=2,k=class{constructor(){this.observers=null;this.watchers=null;this.version=0}updateIfNecessary(){}track(){if(n.untracked)return;let o=n.consumer;o&&((this.observers??=new Set).add(o),(o.sources??=new Set).add(this))}},g=class extends k{constructor(o,t){super(),this._value=o,this._equals=t?.equals===!1?()=>!1:t?.equals??Object.is}get(){return this.track(),this._value}set(o){if(!this._equals(this._value,o)){if(this._value=o,this.version++,j(this,n.consumer),this.observers)for(let t of[...this.observers])t.markDirty(m);N(this)}}peek(){return this._value}},S=class extends k{constructor(t,s){super();this._threw=!1;this._initialized=!1;this.state=m;this.sources=null;this._fn=t,this._equals=s?.equals===!1?()=>!1:s?.equals??Object.is}get(){if(n.consumer===this)throw new Error("Signal.Computed cannot read itself");if(this.track(),this.updateIfNecessary(),this._threw)throw this._error;return this._value}updateIfNecessary(){if(this.state===H&&this.sources){for(let t of this.sources)if(t.updateIfNecessary(),this.state===m)break}(this.state===m||!this._initialized)&&this.recompute(),this.state=G}recompute(){if(this.sources){for(let l of this.sources)l.observers?.delete(this);this.sources.clear()}let t=n.consumer,s=n.untracked,a=K(this);n.consumer=this,n.untracked=!1;let u,i=!1,d;try{u=this._fn()}catch(l){i=!0,d=l,u=this._value}finally{n.consumer=t,n.untracked=s,a&&V()}let r=!this._initialized||this._threw!==i||(i?d!==this._error:!this._equals(this._value,u));if(this._initialized=!0,this._threw=i,this._error=d,this._value=u,W(this),r){if(this.version++,this.observers)for(let l of[...this.observers])l.markDirty(m);N(this)}}markDirty(t){if(this.state>=t)return;let s=this.state===G;if(this.state=t,s){if(this.observers)for(let a of[...this.observers])a.markDirty(H);N(this)}}peek(){if(this.updateIfNecessary(),this._threw)throw this._error;return this._value}};function N(e){if(e.watchers)for(let o of[...e.watchers])o._notify(e)}function z(e){if(n.untracked)return e();n.untracked=!0;try{return e()}finally{n.untracked=!1}}function ie(e){return{cleanups:null,owned:null,parent:e,contexts:null}}function F(e){return n.onSuspend?(n.onSuspend(e,n.owner),!0):!1}function I(){return n.owner}function P(e,o){let t=n.owner;n.owner=e;try{return o()}finally{n.owner=t}}function h(e){if(n.owner){if(n.owner.disposed){e();return}(n.owner.cleanups??=[]).push(e)}}function B(e,o=!0){if(!e.disposed){if(e.owned){for(let t=e.owned.length-1;t>=0;t--)B(e.owned[t]);e.owned=null}if(e.cleanups){for(let t=e.cleanups.length-1;t>=0;t--)e.cleanups[t]();e.cleanups=null}o&&(e.disposed=!0)}}function y(e){let o=ie(n.owner);n.owner&&(n.owner.owned??=[]).push(o);let t=n.owner;n.owner=o;try{return e(()=>B(o))}finally{n.owner=t}}function Y(e){n.hostSchedule=e??(o=>{Promise.resolve().then(o)})}function $(){if(n.scheduled=!1,n.flushing)return;n.flushing=!0;let e=0;try{for(;n.queue.length;){if(++e>1e5)throw new Error("[fluixi] effect flush did not settle (cycle?)");let o=n.queue;n.queue=[];for(let t of o)t.queued=!1,t.disposed||t.run()}}finally{n.flushing=!1}}function X(){n.batchDepth===0&&$()}function ue(e){return!!e&&typeof e.then=="function"}Y(()=>{});var J=Symbol.for("signal"),ae=Symbol.for("memo"),ce=Symbol.for("signal-node");function O(e,o){let t=new g(e,{equals:o?.equals}),s=(()=>t.get()),a=(u=>{let i=typeof u=="function"?u(t.peek()):u;return t.set(i),X(),i});return Object.defineProperty(s,J,{value:!0,enumerable:!0}),Object.defineProperty(s,ce,{value:{get value(){return t.peek()},get version(){return t.version}},enumerable:!1}),E({kind:"signal",node:t,handle:s,name:o?.name,set:a}),D()&&h(()=>q(t)),[s,a]}function b(e,o,t){let s=o,a=I(),u=new S(()=>P(a,()=>{try{return s=e(s)}catch(d){if(ue(d))return F(d),s;throw d}}),{equals:t?.equals}),i=(()=>u.get());return Object.defineProperty(i,J,{value:!0,enumerable:!0}),Object.defineProperty(i,ae,{value:!0,enumerable:!0}),E({kind:"memo",node:u,handle:i,name:t?.name}),D()&&h(()=>q(u)),i}function R(e){return z(e)}function Ee(e,o,t){let s=[];return h(()=>{for(let a of s)a.dispose();s=[]}),b(()=>{let a=e()||[];return R(()=>{if(a.length===0){for(let r of s)r.dispose();return s=[],t?.fallback?t.fallback():[]}let u=new Map;for(let r of s)u.has(r.item)||u.set(r.item,r);let i=[],d=new Set;for(let r=0;r<a.length;r++){let l=a[r],f=u.get(l);if(f&&!d.has(f))f.setIndex(r),i.push(f),d.add(f);else{let c,p,v;y(T=>{v=T;let[x,_]=O(r,{name:"row index"});p=_,c=o(l,x)});let w={item:l,rendered:c,dispose:v,setIndex:p};i.push(w),d.add(w)}}for(let r of s)d.has(r)||r.dispose();return s=i,i.map(r=>r.rendered)})},void 0,{name:"mapArray"})}function qe(e,o,t,s){let a=[],u=[];return h(()=>{for(let i of u)i.dispose();a=[],u=[]}),b(()=>{let i=e()||[];return R(()=>{if(i.length===0){for(let c of u)c.dispose();return a=[],u=[],s?.fallback?s.fallback():[]}let d=new Map;for(let c=0;c<a.length;c++)d.set(a[c],u[c]);let r=[],l=[],f=new Set;for(let c=0;c<i.length;c++){let p=o(i[c]),v=d.get(p);if(v&&!f.has(p))v.setIndex(c),r.push(v);else{let w,T,x;y(_=>{x=_;let[U,Q]=O(c,{name:"row index"});T=Q;let Z=b(ee=>{let C=(e()||[])[U()];return C??ee},i[c]);w=t(Z,U)}),r.push({rendered:w,dispose:x,setIndex:T})}l.push(p),f.add(p)}for(let[c,p]of d)f.has(c)||p.dispose();return a=l,u=r,r.map(c=>c.rendered)})},void 0,{name:"keyArray"})}function De(e,o,t){let s=[];return h(()=>{for(let a of s)a.dispose();s=[]}),b(()=>{let a=e()||[];return R(()=>{if(a.length===0){for(let r of s)r.dispose();return s=[],t?.fallback?t.fallback():[]}let u=s.length,i=a.length;for(let r=u;r<i;r++){let l,f,c,p=a[r];y(v=>{c=v;let[w,T]=O(p);f=T,l=o(w,r)}),s.push({rendered:l,setItem:f,dispose:c})}for(let r=i;r<u;r++)s[r].dispose();i<u&&(s=s.slice(0,i));let d=Math.min(u,i);for(let r=0;r<d;r++)s[r].setItem(a[r]);return s.map(r=>r.rendered)})},void 0,{name:"indexArray"})}export{De as indexArray,qe as keyArray,Ee as mapArray};
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.85";
+
+// src/lib/signal/graph/state.ts
+var MAJOR = VERSION.split(".")[0];
+var KEY = `__fluixi_signal_state_v${MAJOR}__`;
+var VERSIONS_KEY = `__fluixi_signal_builds_v${MAJOR}__`;
+var defaultSchedule = (run) => {
+  if (typeof queueMicrotask === "function") queueMicrotask(run);
+  else void Promise.resolve().then(run);
+};
+function defaults() {
+  return {
+    consumer: null,
+    untracked: false,
+    owner: null,
+    queue: [],
+    scheduled: false,
+    flushing: false,
+    batchDepth: 0,
+    hostSchedule: defaultSchedule,
+    onSuspend: null,
+    onError: null,
+    observer: null
+  };
+}
+var realm = globalThis;
+function backfillState(existing) {
+  const fresh = defaults();
+  const target = existing;
+  for (const field of Object.keys(fresh)) {
+    if (!(field in existing)) target[field] = fresh[field];
+  }
+  return existing;
+}
+function claim() {
+  const existing = realm[KEY];
+  return existing ? backfillState(existing) : realm[KEY] = defaults();
+}
+var G = claim();
+(realm[VERSIONS_KEY] ??= []).push(VERSION);
+
+// src/lib/signal/graph/observe.ts
+function observeReactiveNodes(next) {
+  G.observer = next;
+  return () => {
+    if (G.observer === next) G.observer = null;
+  };
+}
+var running = [];
+var origin;
+function reportReactiveNode(report) {
+  const observer = G.observer;
+  if (observer) {
+    observer.created(
+      report.parents === void 0 ? { ...report, parents: running, origin: report.origin ?? origin } : report
+    );
+  }
+}
+function enterReactiveRun(node) {
+  if (!G.observer) return false;
+  running.push(node);
+  return true;
+}
+function exitReactiveRun() {
+  running.pop();
+}
+function reportReactiveRun(node) {
+  G.observer?.ran?.(node);
+}
+function reportReactiveWrite(node, by) {
+  G.observer?.wrote?.(node, by);
+}
+function reportReactiveDispose(node) {
+  G.observer?.disposed?.(node);
+}
+var HOOK = "__FLUIXI_DEVTOOLS_HOOK__";
+var hook = globalThis[HOOK];
+if (typeof hook?.inject === "function") {
+  try {
+    hook.inject({ observeReactiveNodes, version: VERSION });
+  } catch {
+  }
+}
+function isObserved() {
+  return G.observer != null;
+}
+
+// src/lib/signal/graph/core.ts
+var CLEAN = 0;
+var CHECK = 1;
+var DIRTY = 2;
+var Source = class {
+  constructor() {
+    /** Computeds, and watched leaves, that read this node. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.observers = null;
+    /** Watchers eagerly observing this node, which is how `runtime.ts` schedules effects. */
+    this.watchers = null;
+    /** Bumped whenever this node's value actually changes (equality-gated). */
+    this.version = 0;
+  }
+  /** Settle this node so a reader sees a current value/version. Overridden by Computed. */
+  updateIfNecessary() {
+  }
+  /** Link the current consumer (if any) as an observer of this node. */
+  track() {
+    if (G.untracked) return;
+    const consumer = G.consumer;
+    if (!consumer) return;
+    (this.observers ??= /* @__PURE__ */ new Set()).add(consumer);
+    (consumer.sources ??= /* @__PURE__ */ new Set()).add(this);
+  }
+};
+var State = class extends Source {
+  constructor(value, options) {
+    super();
+    this._value = value;
+    this._equals = options?.equals === false ? () => false : options?.equals ?? Object.is;
+  }
+  get() {
+    this.track();
+    return this._value;
+  }
+  set(next) {
+    if (this._equals(this._value, next)) return;
+    this._value = next;
+    this.version++;
+    reportReactiveWrite(this, G.consumer);
+    if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+    notifyWatchers(this);
+  }
+  /** Read without subscribing (peek). */
+  peek() {
+    return this._value;
+  }
+};
+var Computed = class extends Source {
+  constructor(fn, options) {
+    super();
+    this._threw = false;
+    this._initialized = false;
+    this.state = DIRTY;
+    /** Nodes this computation read on its last run. Rebuilt on every run. */
+    this.sources = null;
+    this._fn = fn;
+    this._equals = options?.equals === false ? () => false : options?.equals ?? Object.is;
+  }
+  get() {
+    if (G.consumer === this) {
+      throw new Error("Signal.Computed cannot read itself");
+    }
+    this.track();
+    this.updateIfNecessary();
+    if (this._threw) throw this._error;
+    return this._value;
+  }
+  /** Settle, if CHECK, verify sources; if DIRTY (or never run), recompute. */
+  updateIfNecessary() {
+    if (this.state === CHECK) {
+      if (this.sources) {
+        for (const s of this.sources) {
+          s.updateIfNecessary();
+          if (this.state === DIRTY) break;
+        }
+      }
+    }
+    if (this.state === DIRTY || !this._initialized) this.recompute();
+    this.state = CLEAN;
+  }
+  recompute() {
+    if (this.sources) {
+      for (const s of this.sources) s.observers?.delete(this);
+      this.sources.clear();
+    }
+    const prevConsumer = G.consumer;
+    const prevUntracked = G.untracked;
+    const watched = enterReactiveRun(this);
+    G.consumer = this;
+    G.untracked = false;
+    let next;
+    let threw = false;
+    let err;
+    try {
+      next = this._fn();
+    } catch (e) {
+      threw = true;
+      err = e;
+      next = this._value;
+    } finally {
+      G.consumer = prevConsumer;
+      G.untracked = prevUntracked;
+      if (watched) exitReactiveRun();
+    }
+    const changed = !this._initialized || this._threw !== threw || (threw ? err !== this._error : !this._equals(this._value, next));
+    this._initialized = true;
+    this._threw = threw;
+    this._error = err;
+    this._value = next;
+    reportReactiveRun(this);
+    if (changed) {
+      this.version++;
+      if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+      notifyWatchers(this);
+    }
+  }
+  /**
+   * Push a maybe-dirty mark. A direct observer of a changed node gets DIRTY; its
+   * own observers get CHECK (recurse), stopping where already marked, so the
+   * push is O(newly-dirtied) and never recomputes.
+   */
+  markDirty(level) {
+    if (this.state >= level) return;
+    const wasClean = this.state === CLEAN;
+    this.state = level;
+    if (wasClean) {
+      if (this.observers) for (const o of [...this.observers]) o.markDirty(CHECK);
+      notifyWatchers(this);
+    }
+  }
+  peek() {
+    this.updateIfNecessary();
+    if (this._threw) throw this._error;
+    return this._value;
+  }
+};
+function notifyWatchers(node) {
+  if (!node.watchers) return;
+  for (const w of [...node.watchers]) w._notify(node);
+}
+function untrack(fn) {
+  if (G.untracked) return fn();
+  G.untracked = true;
+  try {
+    return fn();
+  } finally {
+    G.untracked = false;
+  }
+}
+
+// src/lib/signal/graph/runtime.ts
+function makeOwner(parent) {
+  return { cleanups: null, owned: null, parent, contexts: null };
+}
+function reportSuspend(promise) {
+  if (G.onSuspend) {
+    G.onSuspend(promise, G.owner);
+    return true;
+  }
+  return false;
+}
+function getOwner() {
+  return G.owner;
+}
+function runWithOwner(owner, fn) {
+  const prev = G.owner;
+  G.owner = owner;
+  try {
+    return fn();
+  } finally {
+    G.owner = prev;
+  }
+}
+function onCleanup(fn) {
+  if (!G.owner) return;
+  if (G.owner.disposed) {
+    fn();
+    return;
+  }
+  (G.owner.cleanups ??= []).push(fn);
+}
+function disposeOwner(owner, final = true) {
+  if (owner.disposed) return;
+  if (owner.owned) {
+    for (let i = owner.owned.length - 1; i >= 0; i--) disposeOwner(owner.owned[i]);
+    owner.owned = null;
+  }
+  if (owner.cleanups) {
+    for (let i = owner.cleanups.length - 1; i >= 0; i--) owner.cleanups[i]();
+    owner.cleanups = null;
+  }
+  if (final) owner.disposed = true;
+}
+function createRoot(fn) {
+  const owner = makeOwner(G.owner);
+  if (G.owner) (G.owner.owned ??= []).push(owner);
+  const prev = G.owner;
+  G.owner = owner;
+  try {
+    return fn(() => disposeOwner(owner));
+  } finally {
+    G.owner = prev;
+  }
+}
+function setScheduler(fn) {
+  G.hostSchedule = fn ?? ((run) => void Promise.resolve().then(run));
+}
+function flushSync() {
+  G.scheduled = false;
+  if (G.flushing) return;
+  G.flushing = true;
+  let guard = 0;
+  try {
+    while (G.queue.length) {
+      if (++guard > 1e5) throw new Error("[fluixi] effect flush did not settle (cycle?)");
+      const batchOf = G.queue;
+      G.queue = [];
+      for (const e of batchOf) {
+        e.queued = false;
+        if (!e.disposed) e.run();
+      }
+    }
+  } finally {
+    G.flushing = false;
+  }
+}
+function afterWrite() {
+  if (G.batchDepth === 0) flushSync();
+}
+
+// src/lib/signal/graph/compat.ts
+function isThenable(v) {
+  return !!v && typeof v.then === "function";
+}
+setScheduler(() => {
+});
+var $SIGNAL = /* @__PURE__ */ Symbol.for("signal");
+var $MEMO = /* @__PURE__ */ Symbol.for("memo");
+var $NODE = /* @__PURE__ */ Symbol.for("signal-node");
+function createSignal(value, options) {
+  const state = new State(value, { equals: options?.equals });
+  const read = (() => state.get());
+  const write = ((next) => {
+    const v = typeof next === "function" ? next(state.peek()) : next;
+    state.set(v);
+    afterWrite();
+    return v;
+  });
+  Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
+  Object.defineProperty(read, $NODE, {
+    value: {
+      get value() {
+        return state.peek();
+      },
+      get version() {
+        return state.version;
+      }
+    },
+    enumerable: false
+  });
+  reportReactiveNode({
+    kind: "signal",
+    node: state,
+    handle: read,
+    name: options?.name,
+    set: write
+  });
+  if (isObserved()) onCleanup(() => reportReactiveDispose(state));
+  return [read, write];
+}
+function createMemo(fn, value, options) {
+  let prev = value;
+  const owner = getOwner();
+  const c = new Computed(
+    () => runWithOwner(owner, () => {
+      try {
+        return prev = fn(prev);
+      } catch (e) {
+        if (isThenable(e)) {
+          reportSuspend(e);
+          return prev;
+        }
+        throw e;
+      }
+    }),
+    { equals: options?.equals }
+  );
+  const read = (() => c.get());
+  Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
+  Object.defineProperty(read, $MEMO, { value: true, enumerable: true });
+  reportReactiveNode({ kind: "memo", node: c, handle: read, name: options?.name });
+  if (isObserved()) onCleanup(() => reportReactiveDispose(c));
+  return read;
+}
+function untrack2(fn) {
+  return untrack(fn);
+}
+
+// src/lib/signal/list.ts
+function mapArray(list, mapFn, options) {
+  let items = [];
+  onCleanup(() => {
+    for (const e of items) e.dispose();
+    items = [];
+  });
+  return createMemo(() => {
+    const next = list() || [];
+    return untrack2(() => {
+      if (next.length === 0) {
+        for (const e of items) e.dispose();
+        items = [];
+        return options?.fallback ? options.fallback() : [];
+      }
+      const prevByItem = /* @__PURE__ */ new Map();
+      for (const e of items) if (!prevByItem.has(e.item)) prevByItem.set(e.item, e);
+      const result = [];
+      const used = /* @__PURE__ */ new Set();
+      for (let i = 0; i < next.length; i++) {
+        const value = next[i];
+        const reuse = prevByItem.get(value);
+        if (reuse && !used.has(reuse)) {
+          reuse.setIndex(i);
+          result.push(reuse);
+          used.add(reuse);
+        } else {
+          let rendered, setIndex, dispose;
+          createRoot((d) => {
+            dispose = d;
+            const [index, setIdx] = createSignal(i, { name: "row index" });
+            setIndex = setIdx;
+            rendered = mapFn(value, index);
+          });
+          const entry = { item: value, rendered, dispose, setIndex };
+          result.push(entry);
+          used.add(entry);
+        }
+      }
+      for (const e of items) if (!used.has(e)) e.dispose();
+      items = result;
+      return result.map((e) => e.rendered);
+    });
+  }, void 0, { name: "mapArray" });
+}
+function keyArray(list, keyFn, mapFn, options) {
+  let keys = [];
+  let entries = [];
+  onCleanup(() => {
+    for (const e of entries) e.dispose();
+    keys = [];
+    entries = [];
+  });
+  return createMemo(() => {
+    const next = list() || [];
+    return untrack2(() => {
+      if (next.length === 0) {
+        for (const e of entries) e.dispose();
+        keys = [];
+        entries = [];
+        return options?.fallback ? options.fallback() : [];
+      }
+      const prevByKey = /* @__PURE__ */ new Map();
+      for (let i = 0; i < keys.length; i++) prevByKey.set(keys[i], entries[i]);
+      const resultEntries = [];
+      const resultKeys = [];
+      const usedKeys = /* @__PURE__ */ new Set();
+      for (let i = 0; i < next.length; i++) {
+        const key = keyFn(next[i]);
+        const reuse = prevByKey.get(key);
+        if (reuse && !usedKeys.has(key)) {
+          reuse.setIndex(i);
+          resultEntries.push(reuse);
+        } else {
+          let rendered, setIndex, dispose;
+          createRoot((d) => {
+            dispose = d;
+            const [index, setIdx] = createSignal(i, { name: "row index" });
+            setIndex = setIdx;
+            const item = createMemo((prev) => {
+              const cur = list() || [];
+              const v = cur[index()];
+              return v !== void 0 && v !== null ? v : prev;
+            }, next[i]);
+            rendered = mapFn(item, index);
+          });
+          resultEntries.push({ rendered, dispose, setIndex });
+        }
+        resultKeys.push(key);
+        usedKeys.add(key);
+      }
+      for (const [key, e] of prevByKey) if (!usedKeys.has(key)) e.dispose();
+      keys = resultKeys;
+      entries = resultEntries;
+      return resultEntries.map((e) => e.rendered);
+    });
+  }, void 0, { name: "keyArray" });
+}
+function indexArray(list, mapFn, options) {
+  let slots = [];
+  onCleanup(() => {
+    for (const s of slots) s.dispose();
+    slots = [];
+  });
+  return createMemo(() => {
+    const next = list() || [];
+    return untrack2(() => {
+      if (next.length === 0) {
+        for (const s of slots) s.dispose();
+        slots = [];
+        return options?.fallback ? options.fallback() : [];
+      }
+      const prevLen = slots.length;
+      const nextLen = next.length;
+      for (let i = prevLen; i < nextLen; i++) {
+        let rendered, setItem, dispose;
+        const value = next[i];
+        createRoot((d) => {
+          dispose = d;
+          const [item, setVal] = createSignal(value);
+          setItem = setVal;
+          rendered = mapFn(item, i);
+        });
+        slots.push({ rendered, setItem, dispose });
+      }
+      for (let i = nextLen; i < prevLen; i++) slots[i].dispose();
+      if (nextLen < prevLen) slots = slots.slice(0, nextLen);
+      const survive = Math.min(prevLen, nextLen);
+      for (let i = 0; i < survive; i++) slots[i].setItem(next[i]);
+      return slots.map((s) => s.rendered);
+    });
+  }, void 0, { name: "indexArray" });
+}
+export {
+  indexArray,
+  keyArray,
+  mapArray
+};