sia-reactor 0.0.9 → 0.0.11

package/dist/{chunk-JWR2Y4OV.js → chunk-DW7Z7YEA.js}

@@ -1,10 +1,7 @@
 // src/utils/obj.ts
 var arrRx = /^([^\[\]]+)\[(\d+)\]$/;
 function isDef(val) {
-  return val !== void 0;
-}
-function isArr(obj) {
-  return Array.isArray(obj);
+  return "undefined" !== typeof val;
 }
 function isObj(obj, checkArr = true) {
   return "object" === typeof obj && obj !== null && (checkArr ? !Array.isArray(obj) : true);
@@ -12,12 +9,6 @@ function isObj(obj, checkArr = true) {
 function isStrictObj(obj, crossRealms = false, typecheck = true) {
   return (typecheck ? isObj(obj, false) : true) && (crossRealms ? Object.prototype.toString.call(obj) === "[object Object]" : obj.constructor === Object);
 }
-function isIter(obj) {
-  return obj != null && "function" === typeof obj[Symbol.iterator];
-}
-function inBoolArrOpt(opt, str) {
-  return opt?.includes?.(str) ?? opt;
-}
 function setAny(target, key, value, separator = ".", keyFunc) {
   if (!key.includes(separator)) return void (target[keyFunc ? keyFunc(key) : key] = value);
   const keys = key.split(separator);
@@ -25,7 +16,7 @@ function setAny(target, key, value, separator = ".", keyFunc) {
     const key2 = keyFunc ? keyFunc(keys[i]) : keys[i], match = key2.includes("[") && key2.match(arrRx);
     if (match) {
       const [, key3, iStr] = match;
-      if (!isArr(currObj[key3])) currObj[key3] = [];
+      if (!Array.isArray(currObj[key3])) currObj[key3] = [];
       if (i === len - 1) currObj[key3][Number(iStr)] = value;
       else currObj[key3][Number(iStr)] ||= {}, currObj = currObj[key3][Number(iStr)];
     } else {
@@ -42,7 +33,7 @@ function getAny(source, key, separator = ".", keyFunc) {
     const key2 = keyFunc ? keyFunc(keys[i]) : keys[i], match = key2.includes("[") && key2.match(arrRx);
     if (match) {
       const [, key3, iStr] = match;
-      if (!isArr(currObj[key3]) || !(key3 in currObj)) return void 0;
+      if (!Array.isArray(currObj[key3]) || !(key3 in currObj)) return void 0;
       currObj = currObj[key3][Number(iStr)];
     } else {
       if (!isObj(currObj) || !(key2 in currObj)) return void 0;
@@ -58,7 +49,7 @@ function deleteAny(target, key, separator = ".", keyFunc) {
     const key2 = keyFunc ? keyFunc(keys[i]) : keys[i], match = key2.includes("[") && key2.match(arrRx);
     if (match) {
       const [, key3, iStr] = match;
-      if (!isArr(currObj[key3]) || !(key3 in currObj)) return;
+      if (!Array.isArray(currObj[key3]) || !(key3 in currObj)) return;
       if (i === len - 1) delete currObj[key3][Number(iStr)];
       else currObj = currObj[key3][Number(iStr)];
     } else {
@@ -75,7 +66,7 @@ function inAny(source, key, separator = ".", keyFunc) {
     const key2 = keyFunc ? keyFunc(keys[i]) : keys[i], match = key2.includes("[") && key2.match(arrRx);
     if (match) {
       const [, key3, iStr] = match;
-      if (!isArr(currObj[key3]) || !(key3 in currObj)) return false;
+      if (!Array.isArray(currObj[key3]) || !(key3 in currObj)) return false;
       if (i === len - 1) return true;
       currObj = currObj[key3][Number(iStr)];
     } else {
@@ -93,7 +84,7 @@ function parseAnyObj(obj, separator = ".", keyFunc = (p) => p, visited = /* @__P
   Object.keys(obj).forEach((k) => k.includes(separator) ? setAny(result, k, parseAnyObj(obj[k], separator, keyFunc, visited), separator, keyFunc) : result[k] = isObj(obj[k]) ? parseAnyObj(obj[k], separator, keyFunc, visited) : obj[k]);
   return result;
 }
-function parseEvOpts(options, opts, boolOpt = opts[0], result = {}) {
+function parseEvtOpts(options, opts, boolOpt = opts[0], result = {}) {
   return Object.assign(result, "boolean" === typeof options ? { [boolOpt]: options } : options), result;
 }
 function mergeObjs(o1 = {}, o2 = {}) {
@@ -113,8 +104,8 @@ function getTrailRecords(obj, path) {
   return record;
 }
 function deepClone(obj, crossRealms, visited = /* @__PURE__ */ new WeakMap()) {
-  if (!(isStrictObj(obj, crossRealms) || isArr(obj)) || visited.has(obj)) return obj;
-  const clone = isArr(obj) ? [] : {};
+  if (!(isStrictObj(obj, crossRealms) || Array.isArray(obj)) || visited.has(obj)) return obj;
+  const clone = Array.isArray(obj) ? [] : {};
   visited.set(obj, clone);
   const keys = Object.keys(obj);
   for (let i = 0, len = keys.length; i < len; i++) clone[keys[i]] = deepClone(obj[keys[i]], crossRealms, visited);
@@ -136,17 +127,14 @@ function nuke(target) {
 
 export {
   isDef,
-  isArr,
   isObj,
   isStrictObj,
-  isIter,
-  inBoolArrOpt,
   setAny,
   getAny,
   deleteAny,
   inAny,
   parseAnyObj,
-  parseEvOpts,
+  parseEvtOpts,
   mergeObjs,
   getTrailPaths,
   getTrailRecords,

package/dist/{chunk-LVKZA2YH.js → chunk-KFPA5OPK.js}

@@ -4,13 +4,13 @@ import {
   getTrailPaths,
   getTrailRecords,
   inAny,
-  isArr,
+  isDef,
   isStrictObj,
   mergeObjs,
   nuke,
-  parseEvOpts,
+  parseEvtOpts,
   setAny
-} from "./chunk-JWR2Y4OV.js";
+} from "./chunk-DW7Z7YEA.js";
 
 // src/core/reactor.ts
 var RAW = /* @__PURE__ */ Symbol.for("S.I.A_RAW");
@@ -20,12 +20,13 @@ var INDIFFABLE = /* @__PURE__ */ Symbol.for("S.I.A_INDIFFABLE");
 var TERMINATOR = /* @__PURE__ */ Symbol.for("S.I.A_TERMINATOR");
 var VERSION = /* @__PURE__ */ Symbol.for("S.I.A_VERSION");
 var SSVERSION = /* @__PURE__ */ Symbol.for("S.I.A_SNAPSHOT_VERSION");
+var NIL = Object.freeze({});
 var NOOP = () => {
 };
-var R_BATCH = ("undefined" !== typeof queueMicrotask ? queueMicrotask : setTimeout).bind(window);
-var R_LOG = console.log.bind(console, "[S.I.A Reactor]");
-var EV_WARN = console.warn.bind(console, "[S.I.A Event]");
-var EV_OPTS = { LISTENER: ["capture", "depth", "once", "signal", "immediate"], MEDIATOR: ["lazy", "signal", "immediate"] };
+var RTR_BATCH = (isDef(queueMicrotask) ? queueMicrotask : setTimeout).bind(window);
+var RTR_LOG = console.log.bind(console, "[S.I.A Reactor]");
+var EVT_WARN = console.warn.bind(console, "[S.I.A Event]");
+var EVT_OPTS = { LISTENER: ["capture", "depth", "once", "signal", "immediate"], MEDIATOR: ["lazy", "signal", "immediate"] };
 var ReactorEvent = class _ReactorEvent {
   static NONE = 0;
   static CAPTURING_PHASE = 1;
@@ -41,24 +42,24 @@ var ReactorEvent = class _ReactorEvent {
   value;
   oldValue;
   rejectable;
-  // readonly timestamp: number;
   bubbles;
-  _propagationStopped = false;
-  _immediatePropagationStopped = false;
+  // readonly timestamp: number;
+  _warn = NOOP;
   _resolved = "";
   _rejected = "";
-  _warn = NOOP;
+  _propagationStopped = false;
+  _immediatePropagationStopped = false;
   constructor(payload, bubbles = false, canWarn = true) {
     this.type = this.staticType = payload.type;
     this.target = payload.target;
     this.currentTarget = payload.currentTarget;
     this.root = payload.root;
+    this.path = payload.target.path;
     this.value = payload.target.value;
     this.oldValue = payload.target.oldValue;
-    this.path = payload.target.path;
     this.rejectable = payload.rejectable;
     this.bubbles = bubbles;
-    if (canWarn) this._warn = EV_WARN;
+    if (canWarn) this._warn = EVT_WARN;
   }
   get propagationStopped() {
     return this._propagationStopped;
@@ -93,26 +94,14 @@ var ReactorEvent = class _ReactorEvent {
     return getTrailPaths(this.path);
   }
   get canWarn() {
-    return this._warn === EV_WARN;
+    return this._warn !== NOOP;
   }
 };
 var Reactor = class {
-  getters;
-  setters;
-  deleters;
-  watchers;
-  listeners;
-  lineage;
-  // { parent, key }: uses maths to avoid extra allocations for pairs
-  queue;
-  // Tasks to run after flush
-  batch;
-  proxyCache = /* @__PURE__ */ new WeakMap();
-  snapshotCache;
   log = NOOP;
-  config;
   core;
   // `?:`s | pay the ~800 byte price upfront for what u might never use
+  config;
   isLogging = false;
   // keeping track so API getter doesn't slow down internal iterations in any way
   isTracing = false;
@@ -125,19 +114,32 @@ var Reactor = class {
   // Async Batching
   isCascading = false;
   // Setter Cascading
+  queue;
+  // Tasks to run after flush
+  batch;
+  // Batched payloads to flush async
+  lineage;
+  // { parent, key }: uses maths to avoid extra allocations for pairs
+  snapCache;
+  proxyCache = /* @__PURE__ */ new WeakMap();
+  getters;
+  setters;
+  deleters;
+  watchers;
+  listeners;
   constructor(obj = {}, options) {
     this[INERTIA] = true;
-    this.config = { crossRealms: false, eventBubbling: true, preserveContext: false, equalityFunction: Object.is, batchingFunction: R_BATCH, ...options };
+    this.config = { crossRealms: false, eventBubbling: true, preserveContext: false, equalityFunction: Object.is, batchingFunction: RTR_BATCH, ...options };
     this.core = this.proxied(obj);
     if (!options) return;
     this.canLog = !!options.debug;
     if (this.isTracking = !!options.referenceTracking) this.lineage = /* @__PURE__ */ new WeakMap();
-    if (this.isSCloning = this.isTracking && !!options.smartCloning) this.snapshotCache = /* @__PURE__ */ new WeakMap();
+    if (this.isSCloning = this.isTracking && !!options.smartCloning) this.snapCache = /* @__PURE__ */ new WeakMap();
     this.isTracing = this.isTracking && !!options.lineageTracing;
   }
   proxied(obj, rejectable = false, indiffable = false, parent, key, path) {
-    if (!obj || typeof obj !== "object") return obj;
-    if (!(isStrictObj(obj, this.config.crossRealms, false) || isArr(obj)) || obj[INERTIA]) return obj;
+    if (!obj || "object" !== typeof obj) return obj;
+    if (!(isStrictObj(obj, this.config.crossRealms, false) || Array.isArray(obj)) || obj[INERTIA]) return obj;
     obj = obj[RAW] || obj;
     if (this.isTracking && parent && key) this.link(obj, parent, key, false);
     if (this.proxyCache.has(obj)) return this.proxyCache.get(obj);
@@ -246,13 +248,13 @@ var Reactor = class {
   }
   // won't be called without `.isTracking` so internal guard avoided
   link(target, parent, key, typecheck = true, es) {
-    if (typecheck && !(isStrictObj(target, this.config.crossRealms) || isArr(target))) return;
+    if (typecheck && !(isStrictObj(target, this.config.crossRealms) || Array.isArray(target))) return;
     es = this.lineage.get(target) ?? (this.lineage.set(target, es = []), es);
     for (let i = 0, len = es.length; i < len; i += 2) if (Object.is(es[i], parent) && es[i + 1] === key) return;
     es.push(parent, key);
   }
   unlink(target, parent, key) {
-    if (!(isStrictObj(target, this.config.crossRealms) || isArr(target))) return;
+    if (!(isStrictObj(target, this.config.crossRealms) || Array.isArray(target))) return;
     const es = this.lineage.get(target);
     if (es) {
       for (let i = 0, len = es.length; i < len; i += 2) if (Object.is(es[i], parent) && es[i + 1] === key) return void es.splice(i, 2);
@@ -351,32 +353,31 @@ var Reactor = class {
   nostall(task) {
     return this.queue?.delete(task);
   }
-  bind(cord, signal) {
-    signal?.aborted ? cord.clup() : signal?.addEventListener("abort", cord.clup, { once: true });
-    if (signal && !signal.aborted) cord.sclup = () => signal.removeEventListener("abort", cord.clup);
-    return cord.clup;
+  bind(cord, sig) {
+    if (sig) sig.aborted ? cord.clup() : sig.addEventListener("abort", cord.clup, { once: true });
+    return cord.sclup = !sig || sig.aborted ? NOOP : () => sig.removeEventListener("abort", cord.clup), cord.clup;
   }
   clone(obj, raw, visited = /* @__PURE__ */ new WeakMap()) {
-    if (!(isStrictObj(obj, this.config.crossRealms) || isArr(obj)) || visited.has(obj)) return obj;
-    const version = obj[VERSION] || 0, cached = !raw && this.isSCloning && this.snapshotCache.get(obj);
+    if (!(isStrictObj(obj, this.config.crossRealms) || Array.isArray(obj)) || visited.has(obj)) return obj;
+    const version = obj[VERSION] || 0, cached = !raw && this.isSCloning && this.snapCache.get(obj);
     if (cached && obj[SSVERSION] === version) return cached;
-    const clone = !raw ? isArr(obj) ? [] : {} : obj[RAW] || obj;
+    const clone = !raw ? Array.isArray(obj) ? [] : {} : obj[RAW] || obj;
     visited.set(obj, clone);
     const keys = Object.keys(obj);
     for (let i = 0, len = keys.length; i < len; i++) clone[keys[i]] = this.clone(obj[keys[i]], raw, visited);
-    if (!raw && this.isSCloning) this.snapshotCache.set(obj, clone), obj[SSVERSION] = version;
+    if (!raw && this.isSCloning) this.snapCache.set(obj, clone), obj[SSVERSION] = version;
     return clone;
   }
-  getDepth(p, d = !p ? 0 : 1) {
-    for (let i = 0, len = p.length; i < len; i++) if (p.charCodeAt(i) === 46) d++;
+  getDepth(path, d = !path ? 0 : 1) {
+    for (let i = 0, len = path.length; i < len; i++) if (path.charCodeAt(i) === 46) d++;
     return d;
   }
   getContext(path) {
     const lastDot = path.lastIndexOf("."), value = path === "*" ? this.core : getAny(this.core, path), object = lastDot === -1 ? this.core : getAny(this.core, path.slice(0, lastDot));
     return { path, value, key: path.slice(lastDot + 1) || "", object };
   }
-  syncAdd(key, path, cb, opts, onImmediate) {
-    const { lazy = false, once = false, signal, immediate = false } = parseEvOpts(opts, EV_OPTS.MEDIATOR), store = this[`${key}${key.endsWith("t") ? "t" : ""}ers`] ??= /* @__PURE__ */ new Map();
+  syncAdd(key, path, cb, opts, onImmediate = NOOP) {
+    const { lazy = false, once = false, signal, immediate = false } = parseEvtOpts(opts, EVT_OPTS.MEDIATOR), store = this[`${key}${key.endsWith("t") ? "t" : ""}ers`] ??= /* @__PURE__ */ new Map();
     let cords = store.get(path), cord;
     if (cords) {
       for (let i = 0, len = cords.length; i < len; i++)
@@ -388,7 +389,7 @@ var Reactor = class {
     if (cord) return cord.clup;
     let task;
     cord = { cb, once, clup: () => (lazy && this.nostall(task), this[`no${key}`](path, cb)) };
-    immediate && onImmediate?.(immediate);
+    immediate && onImmediate(immediate);
     task = () => (cords ?? (store.set(path, cords = []), cords)).push(cord);
     lazy ? this.stall(task) : task();
     return this.bind(cord, signal);
@@ -396,80 +397,80 @@ var Reactor = class {
   syncDrop(store, path, cb) {
     const cords = store?.get(path);
     if (!cords) return void 0;
-    for (let i = 0, len = cords.length; i < len; i++) if (Object.is(cords[i].cb, cb)) return cords[i].sclup?.(), cords.splice(i--, 1), !cords.length && store.delete(path), true;
+    for (let i = 0, len = cords.length; i < len; i++) if (Object.is(cords[i].cb, cb)) return cords[i].sclup(), cords.splice(i--, 1), !cords.length && store.delete(path), true;
     return false;
   }
-  get(path, cb, opts) {
-    return this.syncAdd("get", path, cb, opts, (imm) => (imm !== "auto" || inAny(this.core, path)) && getAny(this.core, path));
+  get(path, callback, options) {
+    return this.syncAdd("get", path, callback, options, (imm) => (imm !== "auto" || inAny(this.core, path)) && getAny(this.core, path));
   }
-  gonce(path, cb, opts) {
-    return this.get(path, cb, { ...parseEvOpts(opts, EV_OPTS.MEDIATOR), once: true });
+  gonce(path, callback, options) {
+    return this.get(path, callback, { ...parseEvtOpts(options, EVT_OPTS.MEDIATOR), once: true });
   }
-  noget(path, cb) {
-    return this.syncDrop(this.getters, path, cb);
+  noget(path, callback) {
+    return this.syncDrop(this.getters, path, callback);
   }
-  set(path, cb, opts) {
-    return this.syncAdd("set", path, cb, opts, (imm) => (imm !== "auto" || inAny(this.core, path)) && setAny(this.core, path, getAny(this.core, path)));
+  set(path, callback, options) {
+    return this.syncAdd("set", path, callback, options, (imm) => (imm !== "auto" || inAny(this.core, path)) && setAny(this.core, path, getAny(this.core, path)));
   }
-  sonce(path, cb, opts) {
-    return this.set(path, cb, Object.assign(parseEvOpts(opts, EV_OPTS.MEDIATOR), { once: true }));
+  sonce(path, callback, options) {
+    return this.set(path, callback, Object.assign(parseEvtOpts(options, EVT_OPTS.MEDIATOR), { once: true }));
   }
-  noset(path, cb) {
-    return this.syncDrop(this.setters, path, cb);
+  noset(path, callback) {
+    return this.syncDrop(this.setters, path, callback);
   }
-  delete(path, cb, opts) {
-    return this.syncAdd("delete", path, cb, opts, (imm) => (imm !== "auto" || inAny(this.core, path)) && deleteAny(this.core, path, void 0));
+  delete(path, callback, options) {
+    return this.syncAdd("delete", path, callback, options, (imm) => (imm !== "auto" || inAny(this.core, path)) && deleteAny(this.core, path, void 0));
   }
-  donce(path, cb, opts) {
-    return this.delete(path, cb, Object.assign(parseEvOpts(opts, EV_OPTS.MEDIATOR), { once: true }));
+  donce(path, callback, options) {
+    return this.delete(path, callback, Object.assign(parseEvtOpts(options, EVT_OPTS.MEDIATOR), { once: true }));
   }
-  nodelete(path, cb) {
-    return this.syncDrop(this.deleters, path, cb);
+  nodelete(path, callback) {
+    return this.syncDrop(this.deleters, path, callback);
   }
-  watch(path, cb, opts) {
-    return this.syncAdd("watch", path, cb, opts, (imm) => imm !== "auto" && inAny(this.core, path) && ((target) => cb(target.value, { type: "init", target, currentTarget: target, root: this.core, rejectable: false }))(this.getContext(path)));
+  watch(path, callback, options) {
+    return this.syncAdd("watch", path, callback, options, (imm) => imm !== "auto" && inAny(this.core, path) && ((target) => callback(target.value, { type: "init", target, currentTarget: target, root: this.core, rejectable: false }))(this.getContext(path)));
   }
-  wonce(path, cb, opts) {
-    return this.watch(path, cb, Object.assign(parseEvOpts(opts, EV_OPTS.MEDIATOR), { once: true }));
+  wonce(path, callback, options) {
+    return this.watch(path, callback, Object.assign(parseEvtOpts(options, EVT_OPTS.MEDIATOR), { once: true }));
   }
-  nowatch(path, cb) {
-    return this.syncDrop(this.watchers, path, cb);
+  nowatch(path, callback) {
+    return this.syncDrop(this.watchers, path, callback);
   }
-  on(path, cb, options) {
+  on(path, callback, options) {
     this.listeners ??= /* @__PURE__ */ new Map();
-    const { capture = false, once = false, signal, immediate = false, depth } = parseEvOpts(options, EV_OPTS.LISTENER);
+    const { capture = false, once = false, signal, immediate = false, depth } = parseEvtOpts(options, EVT_OPTS.LISTENER);
     let cords = this.listeners.get(path), cord;
     if (cords) {
       for (let i = 0, len = cords.length; i < len; i++)
-        if (Object.is(cords[i].cb, cb) && capture === cords[i].capture) {
+        if (Object.is(cords[i].cb, callback) && capture === cords[i].capture) {
           cord = cords[i];
           break;
         }
     }
     if (cord) return cord.clup;
-    cord = { cb, capture, depth, once, clup: () => this.off(path, cb, options) };
+    cord = { cb: callback, capture, depth, once, clup: () => this.off(path, callback, options) };
     if (immediate && (immediate !== "auto" || inAny(this.core, path))) {
       const target = this.getContext(path);
-      cb(new ReactorEvent({ type: "init", target, currentTarget: target, root: this.core, rejectable: false }, this.config.eventBubbling, this.isLogging));
+      callback(new ReactorEvent({ type: "init", target, currentTarget: target, root: this.core, rejectable: false }, this.config.eventBubbling, this.isLogging));
     }
     (cords ?? (this.listeners.set(path, cords = []), cords)).push(cord);
     return this.bind(cord, signal);
   }
-  once(path, cb, options) {
-    return this.on(path, cb, Object.assign(parseEvOpts(options, EV_OPTS.LISTENER), { once: true }));
+  once(path, callback, options) {
+    return this.on(path, callback, Object.assign(parseEvtOpts(options, EVT_OPTS.LISTENER), { once: true }));
   }
-  off(path, cb, options) {
+  off(path, callback, options) {
     const cords = this.listeners?.get(path);
     if (!cords) return void 0;
-    const { capture } = parseEvOpts(options, EV_OPTS.LISTENER);
-    for (let i = 0, len = cords.length; i < len; i++) if (Object.is(cords[i].cb, cb) && cords[i].capture === capture) return cords[i].sclup?.(), cords.splice(i--, 1), !cords.length && this.listeners.delete(path), true;
+    const { capture } = parseEvtOpts(options, EVT_OPTS.LISTENER);
+    for (let i = 0, len = cords.length; i < len; i++) if (Object.is(cords[i].cb, callback) && cords[i].capture === capture) return cords[i].sclup(), cords.splice(i--, 1), !cords.length && this.listeners.delete(path), true;
     return false;
   }
   snapshot(raw = !this.isSCloning, branch = this.core) {
     return this.clone(branch, raw);
   }
   cascade({ type, currentTarget: { path, value: news, oldValue: olds } }, objSafe = true) {
-    if (type !== "set" && type !== "delete" || !(isStrictObj(news, this.config.crossRealms) || isArr(news)) || (objSafe ? !(isStrictObj(olds, this.config.crossRealms) || isArr(olds)) : false)) return;
+    if (type !== "set" && type !== "delete" || !(isStrictObj(news, this.config.crossRealms) || Array.isArray(news)) || (objSafe ? !(isStrictObj(olds, this.config.crossRealms) || Array.isArray(olds)) : false)) return;
     const obj = objSafe ? mergeObjs(olds, news) : news, keys = Object.keys(obj);
     this.isCascading = true;
     for (let i = 0, len = keys.length; i < len; i++) setAny(this.core, path + "." + keys[i], obj[keys[i]]);
@@ -483,10 +484,10 @@ var Reactor = class {
     this.reset(), nuke(this);
   }
   get canLog() {
-    return this.isLogging;
+    return this.isLogging = this.log !== NOOP;
   }
   set canLog(value) {
-    this.log = (this.isLogging = value) ? R_LOG : NOOP;
+    this.log = (this.isLogging = value) ? RTR_LOG : NOOP;
   }
   get canTrackReferences() {
     return this.isTracking;
@@ -501,11 +502,13 @@ var Reactor = class {
 
 // src/utils/mixins.ts
 var methods = ["tick", "stall", "nostall", "get", "gonce", "noget", "set", "sonce", "noset", "delete", "donce", "nodelete", "watch", "wonce", "nowatch", "on", "once", "off", "cascade", "snapshot", "reset", "destroy"];
-function reactive(target, options, prefs) {
-  const descriptors = {}, rtr = target instanceof Reactor ? target : new Reactor(target, options), locks = { enumerable: false, configurable: true, writable: false }, hasAffix = !!(prefs?.prefix || prefs?.suffix);
-  for (let key of methods) {
-    if (hasAffix) (prefs?.whitelist?.includes(key) ?? true) && (key = `${prefs?.prefix || ""}${key}${prefs?.suffix || ""}`);
-    else if (prefs?.whitelist?.includes(key)) continue;
+function reactive(target, options, prefs = NIL) {
+  if ("__Reactor__" in target) return target;
+  const descriptors = {}, rtr = target instanceof Reactor ? target : new Reactor(target, options), locks = { enumerable: false, configurable: true, writable: false }, hasAffix = !!(prefs.prefix || prefs.suffix);
+  for (let i = 0, len = methods.length; i < len; i++) {
+    let key = methods[i];
+    if (hasAffix) (prefs.whitelist?.includes(key) ?? true) && (key = `${prefs.prefix || ""}${key}${prefs.suffix || ""}`);
+    else if (prefs.whitelist?.includes(key)) continue;
     descriptors[key] = { value: rtr[key].bind(rtr), ...locks };
   }
   descriptors["__Reactor__"] = { value: rtr, ...locks };
@@ -553,6 +556,8 @@ function getSnapshotVersion(target) {
 
 export {
   TERMINATOR,
+  NIL,
+  NOOP,
   ReactorEvent,
   Reactor,
   methods,