sia-reactor 0.0.6 → 0.0.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OLUWATOBILOBA OKETADE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,8 +1,264 @@
-# sia-reactor
+# sia-reacor
 
-The Programmable Data DOM. A high-performance State Intent Architecture (S.I.A.) Engine with zero-allocation loops, event propagation, and structural sharing.
+> The Programmable Data DOM. A high-performance State & Intent Architecture (S.I.A.) Engine featuring zero-allocation loops, DOM-style event propagation, microtask batching, and structural sharing.
 
-## Installation
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![NPM Version](https://img.shields.io/npm/v/sia-reactor.svg)](https://www.npmjs.com/package/sia-reactor)
+
+[Live Demo & Benchmarks](https://tobi007-del.github.io/t007-tools/packages/sia-reactor/src/index.html) | [Report Bug](https://github.com/Tobi007-del/t007-tools/issues)
+
+[CHRONICLES](https://github.com/Tobi007-del/tmg-media-player/blob/main/CHRONICLES.md) | [FOLKLORE](https://github.com/Tobi007-del/tmg-media-player/blob/main/FOLKLORE.md)
+
+---
+
+## Table of contents
+
+- [sia-reacor](#sia-reacor)
+  - [Table of contents](#table-of-contents)
+  - [Overview: The Paradigm Shift](#overview-the-paradigm-shift)
+  - [The Philosophy: Collecting Like Terms](#the-philosophy-collecting-like-terms)
+  - [State vs. Intent](#state-vs-intent)
+  - [The Art of Resolution: The Power Line](#the-art-of-resolution-the-power-line)
+  - [The Triad of Notifications](#the-triad-of-notifications)
+  - [Tech Stack](#tech-stack)
+  - [Getting Started](#getting-started)
+  - [Usage](#usage)
+  - [API Reference](#api-reference)
+  - [Benchmarks](#benchmarks)
+  - [Author](#author)
+  - [Acknowledgments](#acknowledgments)
+
+---
+
+## Overview: The Paradigm Shift
+
+**sia-reactor** is not just another state management library. It is an architectural paradigm shift. 
+
+Instead of treating your application's data as a flat object, the S.I.A. Engine converts your data into a **Programmable Data DOM**. Deeply nested object properties now possess the exact same lifecycle as HTML elements: they support strict event phases (Capture, Target, Bubble), they can intercept intents before memory is written, and they batch mutations synchronously to guarantee 60FPS UI renders.
+
+Built for engineer surgeons, this engine allows you to wire up massive, deeply nested UIs with zero-allocation performance.
+
+---
+
+## The Philosophy: Collecting Like Terms
+
+Most developers build systems that are entirely too rigid. They create Adapters, Contexts, and Request Managers just to make two different entities behave the same way. 
+
+> Picture a room with air conditioners. When the entity inside gets hot, the AC should turn on.
+> A standard developer sees a human in the room and writes: *"When human sweats, AC on."*
+> Then, the human is replaced by a pig. Pigs don't sweat. Now the developer has to build an entire adapter layer just to simulate fake sweat so the AC will trigger.
+
+**The S.I.A. approach is declarative state pluralism.** We do not care *why* or *how* the entity gets hot. We establish a stable core and collect like terms: **"If entity is hot, turn AC on."** The adapter simply gives the entity a state (`hot = false`). When the entity gets hot, it flips the state to `true`. We just listen.
+
+---
+
+## State vs. Intent
+
+We divide the world into two concepts to completely eliminate the need for bloated class methods (`makeNervous()`, `straightenNose()`).
+
+1. **State (Fact):** The current reality of the system. It can only be determined *after* something happens. The UI is a mirror reflecting this state.
+2. **Intent (Request/Wish):** A request to change reality. 
+
+Instead of learning complex APIs to trigger actions, you simply declare your intent:
+`pig.intent.hot = true` (The Request) 
+↳ *The system internally evaluates* ↳ `pig.state.hot = true` (The Fact).
+
+This brings the "appeal" directly into the state tree. 
+
+---
+
+### Semantic Structuring: Plain State vs. Intentful State
+
+You are not forced to use Intents. If you are building a simple application where data updates are immediate and undisputed, the S.I.A. engine functions perfectly as a hyper-fast, standard state manager. You can strictly use plain state and ignore the complexities of the rejection event loop.
+
+However, the moment you introduce Intents into your architecture, **semantics matter**. 
+
+> If you use an `intent` object to capture user requests, your `state` object must act strictly as the factual mirror to that `intent`. Because `state` is now semantically locked to your intents, you must separate your other data. 
+
+Do not pollute your `state` object with data that doesn't require an intent. Instead, categorize them semantically:
+- **`intent`**: For asynchronous requests or delayed validations (e.g., `intent.playing = true`).
+- **`state`**: The factual mirror of granted intents (e.g., `state.playing = true`).
+- **`settings` / `config`**: For immediate, undisputed user preferences (e.g., `settings.playbackRate = 2`).
+- **`status`**: For read-only system facts (e.g., `status.network = "offline"`).
+
+```javascript
+import { reactive, intent } from 'sia-reactor';
+
+// A perfectly structured S.I.A. Data DOM
+const player = reactive({
+  intent: intent({ playing: false, fullscreen: false }), // Can be rejected
+  state: { playing: false, fullscreen: false },          // The factual mirror
+  settings: { volume: 50, theme: "dark" },               // Immediate, plain state
+  status: { buffering: false, duration: 120 }            // System facts
+});
+```
+
+---
+
+## The Art of Resolution: The Power Line
+
+Because an **Intent** is just a wish, the system must be able to reject it. This introduces a political hierarchy; a Chain of Responsibility driven by the Event Loop.
+
+### The Parable of the King
+Imagine a King wishes to fly: `man.intent.flying = true`.
+You cannot stop him from wishing it. But the system can determine if it will grant the wish. 
+
+Everything crucial happens in the **Capture Phase**:
+1. **The Higher Power:** A plugin that registers first. It intercepts the wish and can choose to `resolve(message)` or `reject(reason)`.
+2. **The Adviser (The Tech):** Listens further down the capture line. If it sees `e.resolved`, it stands down. If it sees `e.rejected`, it knows the Higher Power failed and can attempt to save the situation or allow the failure.
+3. **The Observers (The UI):** Listens on the **Bubble Phase**. They don't get involved in politics; they just watch the aftermath.
+
+#### The Observer Types
+- **The Smart Optimist (Court Man):** Checks if the intent was rejected before updating the UI.
+- **The Reckless Optimist (Artist):** Doesn't care about rejections and paints the wish immediately, trusting the system will snap back later if needed.
+
+---
+
+## The Triad of Notifications
+
+This architecture replaces the chaos of traditional state management with three distinct layers of surgical precision.
+
+### 1. The Gatekeepers (Mediators) - `get`, `set`, `delete`
+Synchronous operations that occur *before* or *during* a state change. 
+- Use `.set()` for data integrity and sanitization. You can intercept a value, modify it, or completely block the memory write by returning the `TERMINATOR` symbol.
+- Use `.get()` to format or derive output on the fly without altering the underlying data.
+
+### 2. The Rule of Survival (Watchers) - `watch`
+Synchronous operations that occur *immediately after* a state change.
+- Use `.watch()` when the very next line of code will crash if a system isn't updated instantly (e.g., `video.src`, internal engine states). This bypasses the async event loop for immediate execution.
+
+### 3. The Rule of the Cloud (Listeners) - `on`
+Asynchronous operations that run in the next microtask.
+- Use `.on()` for **all UI updates** (e.g., `volume`, `brightness`). The reactor will automatically smash 1,000 synchronous mutations into a single `queueMicrotask` UI render tick. 
+
+---
+
+## Tech Stack
+
+### Built with
+- ECMAScript 2015+ Proxy API
+- `queueMicrotask` Async Batching
+- Bitwise Operations & Zero-Allocation Caching
+- Bundled via `tsup` (ESM, CJS, IIFE outputs)
+
+---
+
+## Getting Started
+
+### Installation
+
+Install via your preferred package manager:
 
 ```bash
-npm install sia-reactor
+npm install sia-reactor
+# or
+yarn add sia-reactor
+# or
+pnpm add sia-reactor
+```
+
+```javascript
+// 1. Core Engine
+import { reactive, Reactor, TERMINATOR } from 'sia-reactor';
+
+// 2. Deep Object Utilities
+import { setAny, getAny, mergeObjs } from 'sia-reactor/utils';
+```
+
+---
+
+## Usage
+
+### Modern Bundlers (ESM)
+
+```javascript
+import { reactive, Reactor } from 'sia-reactor'; // also attached to window.sia in non-module scripts
+```
+
+### CDN / Browser (Global)
+
+```javascript
+const { reactive, Reactor } = window.sia;
+```
+
+## API Reference
+
+### Initialization (`reactive` & `Reactor`)
+
+The primary way to use the engine is to wrap an object using `reactive()`, which directly mixes the reactor methods into your target object for a pristine, flat API.
+
+```javascript
+const state = reactive({ player: { volume: 50 } });
+
+// Methods are attached directly to the object!
+state.set("player.volume", (val) => Math.min(val, 100));
+state.on("player.volume", (e) => console.log(e.value));
+
+state.player.volume = 150; // Triggers mediation, clamps to 100, fires listener.
+```
+
+Alternatively, you can instantiate the `Reactor` class directly to keep the API separate from your data:
+```javascript
+const engine = new Reactor({ player: { volume: 50 } }, { debug: true, referenceTracking: true });
+engine.core.player.volume = 100;
+```
+
+### Memory & Granular Control Flags
+
+You can wrap properties in special flags *before* initializing the reactor to dictate exactly how the Proxy treats them.
+
+- **`inert(obj)` / `live(obj)`**: Tells the proxy to completely ignore an object. It will not be deeply tracked.
+- **`intent(obj)` / `state(obj)`**: Marks an object as rejectable. Allows listeners to call `e.reject()` during the Capture phase.
+- **`volatile(obj)` / `stable(obj)`**: Forces the engine to fire event waves even if the new value is identical to the old value (bypassing the Proxy's unchanged performance check).
+
+```javascript
+import { reactive, intent, volatile, inert } from 'sia-reactor';
+
+const data = reactive({
+  apiResponse: inert({ heavy: "data" }), // Proxy won't traverse this
+  userWish: intent({ flying: false }),  // Can be rejected by a Higher Power
+  trigger: volatile({ clickCount: 0 })  // Fires events even if set to 0 again
+});
+```
+
+### Core Methods
+
+All methods are available on `Reactor` instances or objects wrapped in `reactive()`.
+
+#### **Mediators (Synchronous Gatekeepers)**
+- **`set(path, callback, options)`**: Intercept memory writes. Return a value to modify it, or return `TERMINATOR` to block the write entirely.
+- **`get(path, callback, options)`**: Intercept and format data during retrieval.
+- **`delete(path, callback, options)`**: Intercept property deletion.
+
+#### **Watchers (Synchronous Observers)**
+- **`watch(path, callback, options)`**: Fires instantly after a mutation. Use strictly for critical internal engine syncing.
+
+#### **Listeners (Asynchronous/Batched UI Observers)**
+- **`on(path, callback, options)`**: Attach DOM-style event listeners. Supports `{ capture: true, depth: 1, once: true, immediate: true }`.
+- **`once(path, callback, options)`**: Fires once and self-destructs.
+- **`off(path, callback, options)`**: Removes a listener.
+
+#### **Lifecycle & Utilities**
+- **`tick(path)`**: Forces a synchronous flush of the batch queue for a specific path.
+- **`stall(task)` / `nostall(task)`**: Manually stall the queue to wait for calculations before rendering.
+- **`cascade(payload)`**: Manually trigger deep-object event waves, bypassing strict unchanged-proxy traps. Perfect for dumping massive API payloads into the tree.
+- **`snapshot(raw)`**: Generates a strict, structurally-shared, un-proxied clone of the current state tree.
+
+---
+
+## Benchmarks
+
+No fancy screenshots here. True engineers look at performance metrics.
+
+To see the S.I.A Engine handle deep DAG mutations, DOM-style event routing, and microtask batching in real-time, visit the **[Live Demo](https://tobi007-del.github.io/t007-tools/packages/sia-reactor/src/index.html)**, open your DevTools console, and run the built-in Grand Master Stress Suite directly on your own CPU.
+
+---
+
+## Author
+
+- Architect & Developer - [Oketade Oluwatobiloba (Tobi007-del)](https://github.com/Tobi007-del)
+- Project - [t007-tools](https://github.com/Tobi007-del/t007-tools)
+
+## Acknowledgments
+
+Designed to bring absolute architectural dominance and rendering efficiency to complex front-end systems. The foundational data layer of the `@t007` ecosystem.

package/dist/index.cjs

@@ -255,10 +255,15 @@ var Reactor = class {
   isLogging = false;
   // keeping track so API getter doesn't slow down internal iterations in any way
   isTracing = false;
+  // Lineage Tracing
   isTracking = false;
+  // Reference Tracking
   isSCloning = false;
   // Smart Cloning
   isBatching = false;
+  // Async Batching
+  isCascading = false;
+  // Setter Cascading
   constructor(obj = {}, options) {
     this[INERTIA] = true;
     this.config = { crossRealms: false, eventBubbling: true, batchingFunction: R_BATCH, ...options };
@@ -307,7 +312,7 @@ var Reactor = class {
           safeValue = value?.[RAW] || value;
           unchanged = Object.is(safeValue, safeOldValue);
         }
-        if (!indiffable && unchanged) return true;
+        if (!indiffable && unchanged && !this.isCascading) return true;
         this.log(`\u270F\uFE0F [SET Trap] Initiated for "${safeKey}" on "${paths}"`);
         if (this.config.set) terminated = (value = this.config.set(object, key2, value, oldValue, receiver, paths)) === TERMINATOR;
         if (this.setters) {
@@ -605,7 +610,9 @@ var Reactor = class {
   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;
     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]]);
+    this.isCascading = false;
   }
   reset() {
     this.getters?.clear(), this.setters?.clear(), this.deleters?.clear(), this.watchers?.clear(), this.listeners?.clear(), this.queue?.clear(), this.batch?.clear();
@@ -615,7 +622,7 @@ var Reactor = class {
     this.reset(), nuke(this);
   }
   get canLog() {
-    return this.log === R_LOG;
+    return this.isLogging;
   }
   set canLog(value) {
     this.log = (this.isLogging = value) ? R_LOG : NOOP;

package/dist/index.global.js

@@ -255,10 +255,15 @@ var sia = (() => {
     isLogging = false;
     // keeping track so API getter doesn't slow down internal iterations in any way
     isTracing = false;
+    // Lineage Tracing
     isTracking = false;
+    // Reference Tracking
     isSCloning = false;
     // Smart Cloning
     isBatching = false;
+    // Async Batching
+    isCascading = false;
+    // Setter Cascading
     constructor(obj = {}, options) {
       this[INERTIA] = true;
       this.config = { crossRealms: false, eventBubbling: true, batchingFunction: R_BATCH, ...options };
@@ -307,7 +312,7 @@ var sia = (() => {
             safeValue = value?.[RAW] || value;
             unchanged = Object.is(safeValue, safeOldValue);
           }
-          if (!indiffable && unchanged) return true;
+          if (!indiffable && unchanged && !this.isCascading) return true;
           this.log(`\u270F\uFE0F [SET Trap] Initiated for "${safeKey}" on "${paths}"`);
           if (this.config.set) terminated = (value = this.config.set(object, key2, value, oldValue, receiver, paths)) === TERMINATOR;
           if (this.setters) {
@@ -605,7 +610,9 @@ var sia = (() => {
     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;
       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]]);
+      this.isCascading = false;
     }
     reset() {
       this.getters?.clear(), this.setters?.clear(), this.deleters?.clear(), this.watchers?.clear(), this.listeners?.clear(), this.queue?.clear(), this.batch?.clear();
@@ -615,7 +622,7 @@ var sia = (() => {
       this.reset(), nuke(this);
     }
     get canLog() {
-      return this.log === R_LOG;
+      return this.isLogging;
     }
     set canLog(value) {
       this.log = (this.isLogging = value) ? R_LOG : NOOP;

package/dist/index.js

@@ -1,16 +1,114 @@
-import {
-  deleteAny,
-  getAny,
-  getTrailPaths,
-  getTrailRecords,
-  inAny,
-  isArr,
-  isStrictObj,
-  mergeObjs,
-  nuke,
-  parseEvOpts,
-  setAny
-} from "./chunk-GN5OE7KB.js";
+// src/utils/obj.ts
+var arrRx = /^([^\[\]]+)\[(\d+)\]$/;
+function isArr(obj) {
+  return Array.isArray(obj);
+}
+function isObj(obj, checkArr = true) {
+  return "object" === typeof obj && obj !== null && (checkArr ? !Array.isArray(obj) : 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 setAny(target, key, value, separator = ".", keyFunc) {
+  if (!key.includes(separator)) return void (target[keyFunc ? keyFunc(key) : key] = value);
+  const keys = key.split(separator);
+  for (let currObj = target, i = 0, len = keys.length; i < len; i++) {
+    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 (i === len - 1) currObj[key3][Number(iStr)] = value;
+      else currObj[key3][Number(iStr)] ||= {}, currObj = currObj[key3][Number(iStr)];
+    } else {
+      if (i === len - 1) currObj[key2] = value;
+      else currObj[key2] ||= {}, currObj = currObj[key2];
+    }
+  }
+}
+function getAny(source, key, separator = ".", keyFunc) {
+  if (!key.includes(separator)) return source[keyFunc ? keyFunc(key) : key];
+  const keys = key.split(separator);
+  let currObj = source;
+  for (let i = 0, len = keys.length; i < len; i++) {
+    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;
+      currObj = currObj[key3][Number(iStr)];
+    } else {
+      if (!isObj(currObj) || !(key2 in currObj)) return void 0;
+      currObj = currObj[key2];
+    }
+  }
+  return currObj;
+}
+function deleteAny(target, key, separator = ".", keyFunc) {
+  if (!key.includes(separator)) return void delete target[keyFunc ? keyFunc(key) : key];
+  const keys = key.split(separator);
+  for (let currObj = target, i = 0, len = keys.length; i < len; i++) {
+    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 (i === len - 1) delete currObj[key3][Number(iStr)];
+      else currObj = currObj[key3][Number(iStr)];
+    } else {
+      if (!isObj(currObj) || !(key2 in currObj)) return;
+      if (i === len - 1) delete currObj[key2];
+      else currObj = currObj[key2];
+    }
+  }
+}
+function inAny(source, key, separator = ".", keyFunc) {
+  if (!key.includes(separator)) return key in source;
+  const keys = key.split(separator);
+  for (let currObj = source, i = 0, len = keys.length; i < len; i++) {
+    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 (i === len - 1) return true;
+      currObj = currObj[key3][Number(iStr)];
+    } else {
+      if (!isObj(currObj) || !(key2 in currObj)) return false;
+      if (i === len - 1) return true;
+      currObj = currObj[key2];
+    }
+  }
+  return true;
+}
+function parseEvOpts(options, opts, boolOpt = opts[0], result = {}) {
+  return Object.assign(result, "boolean" === typeof options ? { [boolOpt]: options } : options), result;
+}
+function mergeObjs(o1 = {}, o2 = {}) {
+  const merged = { ...o1 || {}, ...o2 || {} };
+  return Object.keys(merged).forEach((k) => isObj(o1?.[k]) && isObj(o2?.[k]) && (merged[k] = mergeObjs(o1[k], o2[k]))), merged;
+}
+function getTrailPaths(path, reverse = true) {
+  const parts = path.split("."), chain = ["*"];
+  let acc = "";
+  for (let i = 0, len = parts.length; i < len; i++) chain.push(acc += (i === 0 ? "" : ".") + parts[i]);
+  return reverse ? chain.reverse() : chain;
+}
+function getTrailRecords(obj, path) {
+  const parts = path.split("."), record = [["*", obj, obj]];
+  let acc = "", currObj = obj;
+  for (let i = 0, len = parts.length; i < len; i++) record.push([acc += (i ? "." : "") + parts[i], currObj, currObj = currObj?.[parts[i]]]);
+  return record;
+}
+function nuke(target) {
+  let proto = target;
+  while (proto && proto !== Object.prototype) {
+    const keys = Object.getOwnPropertyNames(proto);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      if (keys[i] === "constructor") continue;
+      const desc = Object.getOwnPropertyDescriptor(proto, keys[i]);
+      if (desc && ("function" === typeof desc.value || desc.get || desc.set)) continue;
+      proto[keys[i]] = null;
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+}
 
 // src/core/reactor.ts
 var RAW = /* @__PURE__ */ Symbol.for("S.I.A_RAW");
@@ -116,10 +214,15 @@ var Reactor = class {
   isLogging = false;
   // keeping track so API getter doesn't slow down internal iterations in any way
   isTracing = false;
+  // Lineage Tracing
   isTracking = false;
+  // Reference Tracking
   isSCloning = false;
   // Smart Cloning
   isBatching = false;
+  // Async Batching
+  isCascading = false;
+  // Setter Cascading
   constructor(obj = {}, options) {
     this[INERTIA] = true;
     this.config = { crossRealms: false, eventBubbling: true, batchingFunction: R_BATCH, ...options };
@@ -168,7 +271,7 @@ var Reactor = class {
           safeValue = value?.[RAW] || value;
           unchanged = Object.is(safeValue, safeOldValue);
         }
-        if (!indiffable && unchanged) return true;
+        if (!indiffable && unchanged && !this.isCascading) return true;
         this.log(`\u270F\uFE0F [SET Trap] Initiated for "${safeKey}" on "${paths}"`);
         if (this.config.set) terminated = (value = this.config.set(object, key2, value, oldValue, receiver, paths)) === TERMINATOR;
         if (this.setters) {
@@ -466,7 +569,9 @@ var Reactor = class {
   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;
     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]]);
+    this.isCascading = false;
   }
   reset() {
     this.getters?.clear(), this.setters?.clear(), this.deleters?.clear(), this.watchers?.clear(), this.listeners?.clear(), this.queue?.clear(), this.batch?.clear();
@@ -476,7 +581,7 @@ var Reactor = class {
     this.reset(), nuke(this);
   }
   get canLog() {
-    return this.log === R_LOG;
+    return this.isLogging;
   }
   set canLog(value) {
     this.log = (this.isLogging = value) ? R_LOG : NOOP;

package/dist/utils.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
+  deepClone: () => deepClone,
   deleteAny: () => deleteAny,
   getAny: () => getAny,
   getTrailPaths: () => getTrailPaths,
@@ -153,6 +154,14 @@ function getTrailRecords(obj, path) {
   for (let i = 0, len = parts.length; i < len; i++) record.push([acc += (i ? "." : "") + parts[i], currObj, currObj = currObj?.[parts[i]]]);
   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) ? [] : {};
+  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);
+  return clone;
+}
 function nuke(target) {
   let proto = target;
   while (proto && proto !== Object.prototype) {
@@ -168,6 +177,7 @@ function nuke(target) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  deepClone,
   deleteAny,
   getAny,
   getTrailPaths,

package/dist/utils.d.cts

@@ -386,6 +386,7 @@ declare function mergeObjs<T1 extends object>(o1: T1): T1;
 declare function mergeObjs<T2 extends object>(o1: undefined | null, o2: T2): T2;
 declare function getTrailPaths<T>(path: WildPaths<T>, reverse?: boolean): WildPaths<T>[];
 declare function getTrailRecords<T extends object>(obj: T, path: WildPaths<T>): [WildPaths<T>, PathValue<T, WildPaths<T>>, PathValue<T, WildPaths<T>>][];
+declare function deepClone<T>(obj: T, crossRealms?: boolean, visited?: WeakMap<WeakKey, any>): T;
 declare function nuke(target: any): void;
 
 declare const INERTIA: unique symbol;
@@ -444,6 +445,7 @@ declare class Reactor<T extends object> {
     protected isTracking: boolean;
     protected isSCloning: boolean;
     protected isBatching: boolean;
+    protected isCascading: boolean;
     constructor(obj?: T, options?: ReactorOptions<T>);
     protected proxied<O extends object>(obj: O, rejectable?: boolean, indiffable?: boolean, parent?: object, key?: string, path?: string): O;
     protected trace(target: object, path: string, paths?: string[], visited?: WeakSet<object>): Paths<T>[];
@@ -494,4 +496,4 @@ declare class Reactor<T extends object> {
     get canSmartClone(): boolean;
 }
 
-export { live as $, type StrictPathKey as A, type SyncOptions as B, type ChildPaths as C, type DeepKeys as D, type SyncOptionsTuple as E, type Target as F, type Getter as G, type UnionToIntersection as H, type Inert as I, type UpdatePayload as J, type WatcherRecord as K, type Listener as L, type WildPaths as M, getSnapshotVersion as N, getVersion as O, type PathBranch as P, inert as Q, type REvent as R, type Setter as S, TERMINATOR as T, type Unflatten as U, type Volatile as V, type Watcher as W, intent as X, isInert as Y, isIntent as Z, isVolatile as _, type DeepMerge as a, methods as a0, reactive as a1, stable as a2, state as a3, volatile as a4, type DeepPartial as b, type DeepRequired as c, type Deleter as d, deleteAny, type DeleterRecord as e, type DirectPayload as f, type GetterRecord as g, getAny, getTrailPaths, getTrailRecords, type Intent as h, type ListenerOptions as i, inAny, inBoolArrOpt, isArr, isDef, isIter, isObj, isStrictObj, type ListenerOptionsTuple as j, type ListenerRecord as k, type Live as l, type PathBranchValue as m, mergeObjs, type PathKey as n, nuke, type PathLeaf as o, type PathValue as p, parseAnyObj, parseEvOpts, type Paths as q, type Payload as r, type Reactive as s, setAny, type ReactivePrefs as t, Reactor as u, ReactorEvent as v, type ReactorOptions as w, type SetterRecord as x, type Stable as y, type State as z };
+export { live as $, type StrictPathKey as A, type SyncOptions as B, type ChildPaths as C, type DeepKeys as D, type SyncOptionsTuple as E, type Target as F, type Getter as G, type UnionToIntersection as H, type Inert as I, type UpdatePayload as J, type WatcherRecord as K, type Listener as L, type WildPaths as M, getSnapshotVersion as N, getVersion as O, type PathBranch as P, inert as Q, type REvent as R, type Setter as S, TERMINATOR as T, type Unflatten as U, type Volatile as V, type Watcher as W, intent as X, isInert as Y, isIntent as Z, isVolatile as _, type DeepMerge as a, methods as a0, reactive as a1, stable as a2, state as a3, volatile as a4, type DeepPartial as b, type DeepRequired as c, type Deleter as d, deepClone, deleteAny, type DeleterRecord as e, type DirectPayload as f, type GetterRecord as g, getAny, getTrailPaths, getTrailRecords, type Intent as h, type ListenerOptions as i, inAny, inBoolArrOpt, isArr, isDef, isIter, isObj, isStrictObj, type ListenerOptionsTuple as j, type ListenerRecord as k, type Live as l, type PathBranchValue as m, mergeObjs, type PathKey as n, nuke, type PathLeaf as o, type PathValue as p, parseAnyObj, parseEvOpts, type Paths as q, type Payload as r, type Reactive as s, setAny, type ReactivePrefs as t, Reactor as u, ReactorEvent as v, type ReactorOptions as w, type SetterRecord as x, type Stable as y, type State as z };

package/dist/utils.d.ts

@@ -386,6 +386,7 @@ declare function mergeObjs<T1 extends object>(o1: T1): T1;
 declare function mergeObjs<T2 extends object>(o1: undefined | null, o2: T2): T2;
 declare function getTrailPaths<T>(path: WildPaths<T>, reverse?: boolean): WildPaths<T>[];
 declare function getTrailRecords<T extends object>(obj: T, path: WildPaths<T>): [WildPaths<T>, PathValue<T, WildPaths<T>>, PathValue<T, WildPaths<T>>][];
+declare function deepClone<T>(obj: T, crossRealms?: boolean, visited?: WeakMap<WeakKey, any>): T;
 declare function nuke(target: any): void;
 
 declare const INERTIA: unique symbol;
@@ -444,6 +445,7 @@ declare class Reactor<T extends object> {
     protected isTracking: boolean;
     protected isSCloning: boolean;
     protected isBatching: boolean;
+    protected isCascading: boolean;
     constructor(obj?: T, options?: ReactorOptions<T>);
     protected proxied<O extends object>(obj: O, rejectable?: boolean, indiffable?: boolean, parent?: object, key?: string, path?: string): O;
     protected trace(target: object, path: string, paths?: string[], visited?: WeakSet<object>): Paths<T>[];
@@ -494,4 +496,4 @@ declare class Reactor<T extends object> {
     get canSmartClone(): boolean;
 }
 
-export { live as $, type StrictPathKey as A, type SyncOptions as B, type ChildPaths as C, type DeepKeys as D, type SyncOptionsTuple as E, type Target as F, type Getter as G, type UnionToIntersection as H, type Inert as I, type UpdatePayload as J, type WatcherRecord as K, type Listener as L, type WildPaths as M, getSnapshotVersion as N, getVersion as O, type PathBranch as P, inert as Q, type REvent as R, type Setter as S, TERMINATOR as T, type Unflatten as U, type Volatile as V, type Watcher as W, intent as X, isInert as Y, isIntent as Z, isVolatile as _, type DeepMerge as a, methods as a0, reactive as a1, stable as a2, state as a3, volatile as a4, type DeepPartial as b, type DeepRequired as c, type Deleter as d, deleteAny, type DeleterRecord as e, type DirectPayload as f, type GetterRecord as g, getAny, getTrailPaths, getTrailRecords, type Intent as h, type ListenerOptions as i, inAny, inBoolArrOpt, isArr, isDef, isIter, isObj, isStrictObj, type ListenerOptionsTuple as j, type ListenerRecord as k, type Live as l, type PathBranchValue as m, mergeObjs, type PathKey as n, nuke, type PathLeaf as o, type PathValue as p, parseAnyObj, parseEvOpts, type Paths as q, type Payload as r, type Reactive as s, setAny, type ReactivePrefs as t, Reactor as u, ReactorEvent as v, type ReactorOptions as w, type SetterRecord as x, type Stable as y, type State as z };
+export { live as $, type StrictPathKey as A, type SyncOptions as B, type ChildPaths as C, type DeepKeys as D, type SyncOptionsTuple as E, type Target as F, type Getter as G, type UnionToIntersection as H, type Inert as I, type UpdatePayload as J, type WatcherRecord as K, type Listener as L, type WildPaths as M, getSnapshotVersion as N, getVersion as O, type PathBranch as P, inert as Q, type REvent as R, type Setter as S, TERMINATOR as T, type Unflatten as U, type Volatile as V, type Watcher as W, intent as X, isInert as Y, isIntent as Z, isVolatile as _, type DeepMerge as a, methods as a0, reactive as a1, stable as a2, state as a3, volatile as a4, type DeepPartial as b, type DeepRequired as c, type Deleter as d, deepClone, deleteAny, type DeleterRecord as e, type DirectPayload as f, type GetterRecord as g, getAny, getTrailPaths, getTrailRecords, type Intent as h, type ListenerOptions as i, inAny, inBoolArrOpt, isArr, isDef, isIter, isObj, isStrictObj, type ListenerOptionsTuple as j, type ListenerRecord as k, type Live as l, type PathBranchValue as m, mergeObjs, type PathKey as n, nuke, type PathLeaf as o, type PathValue as p, parseAnyObj, parseEvOpts, type Paths as q, type Payload as r, type Reactive as s, setAny, type ReactivePrefs as t, Reactor as u, ReactorEvent as v, type ReactorOptions as w, type SetterRecord as x, type Stable as y, type State as z };

package/dist/utils.global.js

@@ -21,6 +21,7 @@ var sia = (() => {
   // src/utils.ts
   var utils_exports = {};
   __export(utils_exports, {
+    deepClone: () => deepClone,
     deleteAny: () => deleteAny,
     getAny: () => getAny,
     getTrailPaths: () => getTrailPaths,
@@ -153,6 +154,14 @@ var sia = (() => {
     for (let i = 0, len = parts.length; i < len; i++) record.push([acc += (i ? "." : "") + parts[i], currObj, currObj = currObj?.[parts[i]]]);
     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) ? [] : {};
+    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);
+    return clone;
+  }
   function nuke(target) {
     let proto = target;
     while (proto && proto !== Object.prototype) {

package/dist/utils.js

@@ -1,22 +1,140 @@
-import {
-  deleteAny,
-  getAny,
-  getTrailPaths,
-  getTrailRecords,
-  inAny,
-  inBoolArrOpt,
-  isArr,
-  isDef,
-  isIter,
-  isObj,
-  isStrictObj,
-  mergeObjs,
-  nuke,
-  parseAnyObj,
-  parseEvOpts,
-  setAny
-} from "./chunk-GN5OE7KB.js";
+// src/utils/obj.ts
+var arrRx = /^([^\[\]]+)\[(\d+)\]$/;
+function isDef(val) {
+  return val !== void 0;
+}
+function isArr(obj) {
+  return Array.isArray(obj);
+}
+function isObj(obj, checkArr = true) {
+  return "object" === typeof obj && obj !== null && (checkArr ? !Array.isArray(obj) : 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);
+  for (let currObj = target, i = 0, len = keys.length; i < len; i++) {
+    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 (i === len - 1) currObj[key3][Number(iStr)] = value;
+      else currObj[key3][Number(iStr)] ||= {}, currObj = currObj[key3][Number(iStr)];
+    } else {
+      if (i === len - 1) currObj[key2] = value;
+      else currObj[key2] ||= {}, currObj = currObj[key2];
+    }
+  }
+}
+function getAny(source, key, separator = ".", keyFunc) {
+  if (!key.includes(separator)) return source[keyFunc ? keyFunc(key) : key];
+  const keys = key.split(separator);
+  let currObj = source;
+  for (let i = 0, len = keys.length; i < len; i++) {
+    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;
+      currObj = currObj[key3][Number(iStr)];
+    } else {
+      if (!isObj(currObj) || !(key2 in currObj)) return void 0;
+      currObj = currObj[key2];
+    }
+  }
+  return currObj;
+}
+function deleteAny(target, key, separator = ".", keyFunc) {
+  if (!key.includes(separator)) return void delete target[keyFunc ? keyFunc(key) : key];
+  const keys = key.split(separator);
+  for (let currObj = target, i = 0, len = keys.length; i < len; i++) {
+    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 (i === len - 1) delete currObj[key3][Number(iStr)];
+      else currObj = currObj[key3][Number(iStr)];
+    } else {
+      if (!isObj(currObj) || !(key2 in currObj)) return;
+      if (i === len - 1) delete currObj[key2];
+      else currObj = currObj[key2];
+    }
+  }
+}
+function inAny(source, key, separator = ".", keyFunc) {
+  if (!key.includes(separator)) return key in source;
+  const keys = key.split(separator);
+  for (let currObj = source, i = 0, len = keys.length; i < len; i++) {
+    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 (i === len - 1) return true;
+      currObj = currObj[key3][Number(iStr)];
+    } else {
+      if (!isObj(currObj) || !(key2 in currObj)) return false;
+      if (i === len - 1) return true;
+      currObj = currObj[key2];
+    }
+  }
+  return true;
+}
+function parseAnyObj(obj, separator = ".", keyFunc = (p) => p, visited = /* @__PURE__ */ new WeakSet()) {
+  if (!isObj(obj) || visited.has(obj)) return obj;
+  visited.add(obj);
+  const result = {};
+  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 = {}) {
+  return Object.assign(result, "boolean" === typeof options ? { [boolOpt]: options } : options), result;
+}
+function mergeObjs(o1 = {}, o2 = {}) {
+  const merged = { ...o1 || {}, ...o2 || {} };
+  return Object.keys(merged).forEach((k) => isObj(o1?.[k]) && isObj(o2?.[k]) && (merged[k] = mergeObjs(o1[k], o2[k]))), merged;
+}
+function getTrailPaths(path, reverse = true) {
+  const parts = path.split("."), chain = ["*"];
+  let acc = "";
+  for (let i = 0, len = parts.length; i < len; i++) chain.push(acc += (i === 0 ? "" : ".") + parts[i]);
+  return reverse ? chain.reverse() : chain;
+}
+function getTrailRecords(obj, path) {
+  const parts = path.split("."), record = [["*", obj, obj]];
+  let acc = "", currObj = obj;
+  for (let i = 0, len = parts.length; i < len; i++) record.push([acc += (i ? "." : "") + parts[i], currObj, currObj = currObj?.[parts[i]]]);
+  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) ? [] : {};
+  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);
+  return clone;
+}
+function nuke(target) {
+  let proto = target;
+  while (proto && proto !== Object.prototype) {
+    const keys = Object.getOwnPropertyNames(proto);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      if (keys[i] === "constructor") continue;
+      const desc = Object.getOwnPropertyDescriptor(proto, keys[i]);
+      if (desc && ("function" === typeof desc.value || desc.get || desc.set)) continue;
+      proto[keys[i]] = null;
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+}
 export {
+  deepClone,
   deleteAny,
   getAny,
   getTrailPaths,

package/package.json

@@ -1,23 +1,24 @@
 {
   "name": "sia-reactor",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "The Programmable Data DOM. A high-performance State Intent Architecture (S.I.A.) Engine with zero-allocation loops, event propagation, and structural sharing.",
   "author": "Oketade Oluwatobiloba <tobioketade007@gmail.com>",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tobi007-del/t007-tools.git",
+    "url": "git+https://github.com/Tobi007-del/t007-tools.git",
     "directory": "packages/sia-reactor"
   },
-  "homepage": "https://github.com/tobi007-del/tree/main/packages/sia-reactor#readme",
+  "homepage": "https://github.com/Tobi007-del/tree/main/packages/sia-reactor#readme",
   "bugs": {
-    "url": "https://github.com/tobi007-del/sia-reactor/issues"
+    "url": "https://github.com/Tobi007-del/sia-reactor/issues"
   },
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "browser": "./dist/index.global.js",
   "unpkg": "./dist/index.global.js",
+  "jsdelivr": "./dist/index.global.js",
   "types": "./dist/index.d.ts",
   "sideEffects": false,
   "exports": {
@@ -34,13 +35,19 @@
       "default": "./dist/utils.js"
     }
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "build": "tsup src/index.ts src/utils.ts src/types.ts --format cjs,esm,iife --global-name sia --dts --clean"
+    "build": "tsup src/index.ts src/utils.ts src/types.ts --format cjs,esm,iife --global-name sia --dts --clean --no-splitting",
+    "prepublishOnly": "shx cp ../../LICENSE ."
   },
   "files": [
     "dist"
   ],
   "keywords": [
+    "t007",
+    "ecosystem",
     "reactor",
     "sia",
     "state",

package/dist/chunk-GN5OE7KB.js

@@ -1,146 +0,0 @@
-// src/utils/obj.ts
-var arrRx = /^([^\[\]]+)\[(\d+)\]$/;
-function isDef(val) {
-  return val !== void 0;
-}
-function isArr(obj) {
-  return Array.isArray(obj);
-}
-function isObj(obj, checkArr = true) {
-  return "object" === typeof obj && obj !== null && (checkArr ? !Array.isArray(obj) : 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);
-  for (let currObj = target, i = 0, len = keys.length; i < len; i++) {
-    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 (i === len - 1) currObj[key3][Number(iStr)] = value;
-      else currObj[key3][Number(iStr)] ||= {}, currObj = currObj[key3][Number(iStr)];
-    } else {
-      if (i === len - 1) currObj[key2] = value;
-      else currObj[key2] ||= {}, currObj = currObj[key2];
-    }
-  }
-}
-function getAny(source, key, separator = ".", keyFunc) {
-  if (!key.includes(separator)) return source[keyFunc ? keyFunc(key) : key];
-  const keys = key.split(separator);
-  let currObj = source;
-  for (let i = 0, len = keys.length; i < len; i++) {
-    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;
-      currObj = currObj[key3][Number(iStr)];
-    } else {
-      if (!isObj(currObj) || !(key2 in currObj)) return void 0;
-      currObj = currObj[key2];
-    }
-  }
-  return currObj;
-}
-function deleteAny(target, key, separator = ".", keyFunc) {
-  if (!key.includes(separator)) return void delete target[keyFunc ? keyFunc(key) : key];
-  const keys = key.split(separator);
-  for (let currObj = target, i = 0, len = keys.length; i < len; i++) {
-    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 (i === len - 1) delete currObj[key3][Number(iStr)];
-      else currObj = currObj[key3][Number(iStr)];
-    } else {
-      if (!isObj(currObj) || !(key2 in currObj)) return;
-      if (i === len - 1) delete currObj[key2];
-      else currObj = currObj[key2];
-    }
-  }
-}
-function inAny(source, key, separator = ".", keyFunc) {
-  if (!key.includes(separator)) return key in source;
-  const keys = key.split(separator);
-  for (let currObj = source, i = 0, len = keys.length; i < len; i++) {
-    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 (i === len - 1) return true;
-      currObj = currObj[key3][Number(iStr)];
-    } else {
-      if (!isObj(currObj) || !(key2 in currObj)) return false;
-      if (i === len - 1) return true;
-      currObj = currObj[key2];
-    }
-  }
-  return true;
-}
-function parseAnyObj(obj, separator = ".", keyFunc = (p) => p, visited = /* @__PURE__ */ new WeakSet()) {
-  if (!isObj(obj) || visited.has(obj)) return obj;
-  visited.add(obj);
-  const result = {};
-  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 = {}) {
-  return Object.assign(result, "boolean" === typeof options ? { [boolOpt]: options } : options), result;
-}
-function mergeObjs(o1 = {}, o2 = {}) {
-  const merged = { ...o1 || {}, ...o2 || {} };
-  return Object.keys(merged).forEach((k) => isObj(o1?.[k]) && isObj(o2?.[k]) && (merged[k] = mergeObjs(o1[k], o2[k]))), merged;
-}
-function getTrailPaths(path, reverse = true) {
-  const parts = path.split("."), chain = ["*"];
-  let acc = "";
-  for (let i = 0, len = parts.length; i < len; i++) chain.push(acc += (i === 0 ? "" : ".") + parts[i]);
-  return reverse ? chain.reverse() : chain;
-}
-function getTrailRecords(obj, path) {
-  const parts = path.split("."), record = [["*", obj, obj]];
-  let acc = "", currObj = obj;
-  for (let i = 0, len = parts.length; i < len; i++) record.push([acc += (i ? "." : "") + parts[i], currObj, currObj = currObj?.[parts[i]]]);
-  return record;
-}
-function nuke(target) {
-  let proto = target;
-  while (proto && proto !== Object.prototype) {
-    const keys = Object.getOwnPropertyNames(proto);
-    for (let i = 0, len = keys.length; i < len; i++) {
-      if (keys[i] === "constructor") continue;
-      const desc = Object.getOwnPropertyDescriptor(proto, keys[i]);
-      if (desc && ("function" === typeof desc.value || desc.get || desc.set)) continue;
-      proto[keys[i]] = null;
-    }
-    proto = Object.getPrototypeOf(proto);
-  }
-}
-
-export {
-  isDef,
-  isArr,
-  isObj,
-  isStrictObj,
-  isIter,
-  inBoolArrOpt,
-  setAny,
-  getAny,
-  deleteAny,
-  inAny,
-  parseAnyObj,
-  parseEvOpts,
-  mergeObjs,
-  getTrailPaths,
-  getTrailRecords,
-  nuke
-};