mutts 1.0.8 → 1.0.10

package/dist/node.cjs

@@ -1,105 +1,109 @@
 'use strict';
 
-require('./chunks/async-node-BYHuGTni.cjs');
+require('./chunks/async-node-3PrbVAbB.cjs');
 var browser = require('./browser.cjs');
-var asyncCore = require('./chunks/async-core-UqHzvJ-S.cjs');
+var proxy = require('./chunks/proxy-Dtg-bJ3T.cjs');
+var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
 require('node:async_hooks');
-require('./chunks/async-browser-CA0jPWIi.cjs');
+require('./chunks/async-browser-BU_IfxYD.cjs');
 
 
 
-exports.AZone = browser.AZone;
 exports.ArrayReadForward = browser.ArrayReadForward;
-exports.DecoratorError = browser.DecoratorError;
 exports.Destroyable = browser.Destroyable;
 exports.DestructionError = browser.DestructionError;
 exports.Eventful = browser.Eventful;
-exports.FoolProof = browser.FoolProof;
 exports.Indexable = browser.Indexable;
-exports.IterableWeakMap = browser.IterableWeakMap;
-exports.IterableWeakSet = browser.IterableWeakSet;
-exports.ReactiveBase = browser.ReactiveBase;
-exports.ReactiveError = browser.ReactiveError;
-Object.defineProperty(exports, "ReactiveErrorCode", {
-	enumerable: true,
-	get: function () { return browser.ReactiveErrorCode; }
-});
 exports.Register = browser.Register;
-exports.Zone = browser.Zone;
-exports.ZoneAggregator = browser.ZoneAggregator;
-exports.ZoneHistory = browser.ZoneHistory;
-exports.addBatchCleanup = browser.addBatchCleanup;
 exports.allocated = browser.allocated;
 exports.allocatedValues = browser.allocatedValues;
-exports.arrayEquals = browser.arrayEquals;
-exports.asyncZone = browser.asyncZone;
-exports.atomic = browser.atomic;
-exports.biDi = browser.biDi;
-exports.buildReactivityGraph = browser.buildReactivityGraph;
+exports.arrayDiff = browser.arrayDiff;
+exports.attend = browser.attend;
 exports.cache = browser.cache;
 exports.cached = browser.cached;
 exports.callOnGC = browser.callOnGC;
 exports.chainPromise = browser.chainPromise;
-exports.cleanedBy = browser.cleanedBy;
-exports.cleanup = browser.cleanup;
-exports.contentRef = browser.contentRef;
 exports.debounce = browser.debounce;
-exports.decorator = browser.decorator;
-exports.deepCompare = browser.deepCompare;
 exports.deepWatch = browser.deepWatch;
-exports.defer = browser.defer;
 exports.deprecated = browser.deprecated;
-exports.derived = browser.derived;
-exports.describe = browser.describe;
+exports.descriptor = browser.descriptor;
 exports.destructor = browser.destructor;
-exports.effect = browser.effect;
-exports.effectAggregator = browser.effectAggregator;
-exports.enableDevTools = browser.enableDevTools;
 exports.forwardArray = browser.forwardArray;
-exports.getActivationLog = browser.getActivationLog;
-exports.getActiveEffect = browser.getActiveEffect;
-exports.getActiveProjection = browser.getActiveProjection;
 exports.getAt = browser.getAt;
-exports.getState = browser.getState;
-exports.immutables = browser.immutables;
 exports.isCached = browser.isCached;
-exports.isConstructor = browser.isConstructor;
-exports.isDevtoolsEnabled = browser.isDevtoolsEnabled;
-exports.isNonReactive = browser.isNonReactive;
-exports.isOwnAccessor = browser.isOwnAccessor;
-exports.isReactive = browser.isReactive;
-exports.legacyDecorator = browser.legacyDecorator;
+exports.lift = browser.lift;
 exports.memoize = browser.memoize;
-exports.mixin = browser.mixin;
-exports.modernDecorator = browser.modernDecorator;
-exports.named = browser.named;
+exports.morph = browser.morph;
 exports.organize = browser.organize;
 exports.organized = browser.organized;
 exports.profileInfo = browser.profileInfo;
-exports.project = browser.project;
-exports.reactive = browser.reactive;
-exports.reactiveOptions = browser.reactiveOptions;
+exports.project = browser.morph;
 exports.register = browser.register;
-exports.registerEffectForDebug = browser.registerEffectForDebug;
-exports.registerNativeReactivity = browser.registerNativeReactivity;
-exports.registerObjectForDebug = browser.registerObjectForDebug;
-exports.renamed = browser.renamed;
-exports.resolve = browser.resolve;
-exports.root = browser.root;
+exports.resource = browser.resource;
 exports.scan = browser.scan;
 exports.setAt = browser.setAt;
-exports.setEffectName = browser.setEffectName;
-exports.setObjectName = browser.setObjectName;
-exports.tag = browser.tag;
 exports.throttle = browser.throttle;
-exports.touched = browser.touched;
-exports.touched1 = browser.touched1;
-exports.trackEffect = browser.trackEffect;
 exports.unreactive = browser.unreactive;
-exports.untracked = browser.untracked;
-exports.unwrap = browser.unwrap;
 exports.watch = browser.watch;
-exports.zip = browser.zip;
+exports.when = browser.when;
+exports.AZone = proxy.AZone;
+exports.DecoratorError = proxy.DecoratorError;
+exports.IterableWeakMap = proxy.IterableWeakMap;
+exports.IterableWeakSet = proxy.IterableWeakSet;
+exports.ReactiveBase = proxy.ReactiveBase;
+exports.ReactiveError = proxy.ReactiveError;
+Object.defineProperty(exports, "ReactiveErrorCode", {
+	enumerable: true,
+	get: function () { return proxy.ReactiveErrorCode; }
+});
+exports.Zone = proxy.Zone;
+exports.ZoneAggregator = proxy.ZoneAggregator;
+exports.ZoneHistory = proxy.ZoneHistory;
+exports.addBatchCleanup = proxy.addBatchCleanup;
+exports.arrayEquals = proxy.arrayEquals;
+exports.asyncZone = proxy.asyncZone;
+exports.atom = proxy.atom;
+exports.atomic = proxy.atomic;
+exports.biDi = proxy.biDi;
+exports.caught = proxy.caught;
+exports.cleanedBy = proxy.cleanedBy;
+exports.cleanup = proxy.cleanup;
+exports.createFlavor = proxy.createFlavor;
+exports.decorator = proxy.decorator;
+exports.deepCompare = proxy.deepCompare;
+exports.defer = proxy.defer;
+exports.effect = proxy.effect;
+exports.effectAggregator = proxy.effectAggregator;
+exports.flavorOptions = proxy.flavorOptions;
+exports.flavored = proxy.flavored;
+exports.formatCleanupReason = proxy.formatCleanupReason;
+exports.getActivationLog = proxy.getActivationLog;
+exports.getActiveEffect = proxy.getActiveEffect;
+exports.getState = proxy.getState;
+exports.immutables = proxy.immutables;
+exports.isConstructor = proxy.isConstructor;
+exports.isNonReactive = proxy.isNonReactive;
+exports.isObject = proxy.isObject;
+exports.isReactive = proxy.isReactive;
+exports.legacyDecorator = proxy.legacyDecorator;
+exports.mixin = proxy.mixin;
+exports.modernDecorator = proxy.modernDecorator;
+exports.named = proxy.named;
+exports.objectToProxy = proxy.objectToProxy;
+exports.onEffectThrow = proxy.onEffectThrow;
+exports.proxyToObject = proxy.proxyToObject;
+exports.reactive = proxy.reactive;
+exports.reactiveOptions = proxy.options;
+exports.reset = proxy.reset;
+exports.root = proxy.root;
+exports.stopped = proxy.stopped;
+exports.tag = proxy.tag;
+exports.touched = proxy.touched;
+exports.touched1 = proxy.touched1;
+exports.untracked = proxy.untracked;
+exports.unwrap = proxy.unwrap;
+exports.zip = proxy.zip;
 exports.asyncHook = asyncCore.asyncHook;
 exports.asyncHooks = asyncCore.asyncHooks;
+exports.hooks = asyncCore.hooks;
 //# sourceMappingURL=node.cjs.map

package/dist/node.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"node.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"node.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/node.d.ts

@@ -1 +1,2 @@
-export { AZone, ArrayReadForward, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, DependencyAccess, Destroyable, DestructionError, Eventful, EventsBase, Evolution, FoolProof, FunctionWrapper, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, ReactiveBase, ReactiveError, ReactiveErrorCode, ReactivityGraph, Register, Restorer, ScanResult, ScopedCallback, Zone, ZoneAggregator, ZoneHistory, addBatchCleanup, allocated, allocatedValues, arrayEquals, asyncHook, asyncHooks, asyncZone, atomic, biDi, buildReactivityGraph, cache, cached, callOnGC, chainPromise, cleanedBy, cleanup, contentRef, debounce, decorator, deepCompare, deepWatch, defer, deprecated, derived, describe, destructor, effect, effectAggregator, enableDevTools, forwardArray, getActivationLog, getActiveEffect, getActiveProjection, getAt, getState, immutables, isCached, isConstructor, isDevtoolsEnabled, isNonReactive, isOwnAccessor, isReactive, legacyDecorator, memoize, mixin, modernDecorator, named, organize, organized, profileInfo, project, reactive, reactiveOptions, register, registerEffectForDebug, registerNativeReactivity, registerObjectForDebug, renamed, resolve, root, scan, setAt, setEffectName, setObjectName, tag, throttle, touched, touched1, trackEffect, unreactive, untracked, unwrap, watch, zip } from './browser.js';
+export { ArrayDiffResult, ArrayReadForward, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, Eventful, EventsBase, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, ReactiveBase, Register, Resource, Restorer, ScanResult, addBatchCleanup, allocated, allocatedValues, arrayDiff, arrayEquals, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, caught, chainPromise, cleanedBy, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, immutables, isCached, isConstructor, isNonReactive, isObject, legacyDecorator, lift, memoize, mixin, modernDecorator, morph, named, onEffectThrow, organize, organized, profileInfo, morph as project, reactive, register, reset, resource, root, scan, setAt, tag, throttle, touched, touched1, unreactive, untracked, watch, when, zip } from './index.js';
+export { A as AZone, h as CleanupReason, e as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, F as FunctionWrapper, P as PropTrigger, R as ReactiveError, i as ReactiveErrorCode, S as ScopedCallback, j as Zone, Z as ZoneAggregator, k as ZoneHistory, l as asyncZone, c as cleanup, m as formatCleanupReason, n as isReactive, o as objectToProxy, p as proxyToObject, q as reactiveOptions, s as stopped, u as unwrap } from './types-W5vD6m2n.js';

package/dist/node.dev.cjs

@@ -0,0 +1,110 @@
+'use strict';
+
+require('./debug.cjs');
+require('./chunks/async-node-3PrbVAbB.cjs');
+var browser = require('./browser.cjs');
+var proxy = require('./chunks/proxy-Dtg-bJ3T.cjs');
+var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
+require('node:async_hooks');
+require('./chunks/async-browser-BU_IfxYD.cjs');
+
+
+
+exports.ArrayReadForward = browser.ArrayReadForward;
+exports.Destroyable = browser.Destroyable;
+exports.DestructionError = browser.DestructionError;
+exports.Eventful = browser.Eventful;
+exports.Indexable = browser.Indexable;
+exports.Register = browser.Register;
+exports.allocated = browser.allocated;
+exports.allocatedValues = browser.allocatedValues;
+exports.arrayDiff = browser.arrayDiff;
+exports.attend = browser.attend;
+exports.cache = browser.cache;
+exports.cached = browser.cached;
+exports.callOnGC = browser.callOnGC;
+exports.chainPromise = browser.chainPromise;
+exports.debounce = browser.debounce;
+exports.deepWatch = browser.deepWatch;
+exports.deprecated = browser.deprecated;
+exports.descriptor = browser.descriptor;
+exports.destructor = browser.destructor;
+exports.forwardArray = browser.forwardArray;
+exports.getAt = browser.getAt;
+exports.isCached = browser.isCached;
+exports.lift = browser.lift;
+exports.memoize = browser.memoize;
+exports.morph = browser.morph;
+exports.organize = browser.organize;
+exports.organized = browser.organized;
+exports.profileInfo = browser.profileInfo;
+exports.project = browser.morph;
+exports.register = browser.register;
+exports.resource = browser.resource;
+exports.scan = browser.scan;
+exports.setAt = browser.setAt;
+exports.throttle = browser.throttle;
+exports.unreactive = browser.unreactive;
+exports.watch = browser.watch;
+exports.when = browser.when;
+exports.AZone = proxy.AZone;
+exports.DecoratorError = proxy.DecoratorError;
+exports.IterableWeakMap = proxy.IterableWeakMap;
+exports.IterableWeakSet = proxy.IterableWeakSet;
+exports.ReactiveBase = proxy.ReactiveBase;
+exports.ReactiveError = proxy.ReactiveError;
+Object.defineProperty(exports, "ReactiveErrorCode", {
+	enumerable: true,
+	get: function () { return proxy.ReactiveErrorCode; }
+});
+exports.Zone = proxy.Zone;
+exports.ZoneAggregator = proxy.ZoneAggregator;
+exports.ZoneHistory = proxy.ZoneHistory;
+exports.addBatchCleanup = proxy.addBatchCleanup;
+exports.arrayEquals = proxy.arrayEquals;
+exports.asyncZone = proxy.asyncZone;
+exports.atom = proxy.atom;
+exports.atomic = proxy.atomic;
+exports.biDi = proxy.biDi;
+exports.caught = proxy.caught;
+exports.cleanedBy = proxy.cleanedBy;
+exports.cleanup = proxy.cleanup;
+exports.createFlavor = proxy.createFlavor;
+exports.decorator = proxy.decorator;
+exports.deepCompare = proxy.deepCompare;
+exports.defer = proxy.defer;
+exports.effect = proxy.effect;
+exports.effectAggregator = proxy.effectAggregator;
+exports.flavorOptions = proxy.flavorOptions;
+exports.flavored = proxy.flavored;
+exports.formatCleanupReason = proxy.formatCleanupReason;
+exports.getActivationLog = proxy.getActivationLog;
+exports.getActiveEffect = proxy.getActiveEffect;
+exports.getState = proxy.getState;
+exports.immutables = proxy.immutables;
+exports.isConstructor = proxy.isConstructor;
+exports.isNonReactive = proxy.isNonReactive;
+exports.isObject = proxy.isObject;
+exports.isReactive = proxy.isReactive;
+exports.legacyDecorator = proxy.legacyDecorator;
+exports.mixin = proxy.mixin;
+exports.modernDecorator = proxy.modernDecorator;
+exports.named = proxy.named;
+exports.objectToProxy = proxy.objectToProxy;
+exports.onEffectThrow = proxy.onEffectThrow;
+exports.proxyToObject = proxy.proxyToObject;
+exports.reactive = proxy.reactive;
+exports.reactiveOptions = proxy.options;
+exports.reset = proxy.reset;
+exports.root = proxy.root;
+exports.stopped = proxy.stopped;
+exports.tag = proxy.tag;
+exports.touched = proxy.touched;
+exports.touched1 = proxy.touched1;
+exports.untracked = proxy.untracked;
+exports.unwrap = proxy.unwrap;
+exports.zip = proxy.zip;
+exports.asyncHook = asyncCore.asyncHook;
+exports.asyncHooks = asyncCore.asyncHooks;
+exports.hooks = asyncCore.hooks;
+//# sourceMappingURL=node.dev.cjs.map

package/dist/node.dev.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.dev.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/node.dev.d.ts

@@ -0,0 +1,2 @@
+export { A as AZone, h as CleanupReason, e as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, F as FunctionWrapper, P as PropTrigger, R as ReactiveError, i as ReactiveErrorCode, S as ScopedCallback, j as Zone, Z as ZoneAggregator, k as ZoneHistory, l as asyncZone, c as cleanup, m as formatCleanupReason, n as isReactive, o as objectToProxy, p as proxyToObject, q as reactiveOptions, s as stopped, u as unwrap } from './types-W5vD6m2n.js';
+export { ArrayDiffResult, ArrayReadForward, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, Eventful, EventsBase, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, ReactiveBase, Register, Resource, Restorer, ScanResult, addBatchCleanup, allocated, allocatedValues, arrayDiff, arrayEquals, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, caught, chainPromise, cleanedBy, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, immutables, isCached, isConstructor, isNonReactive, isObject, legacyDecorator, lift, memoize, mixin, modernDecorator, morph, named, onEffectThrow, organize, organized, profileInfo, morph as project, reactive, register, reset, resource, root, scan, setAt, tag, throttle, touched, touched1, unreactive, untracked, watch, when, zip } from './index.js';

package/dist/node.dev.esm.js

@@ -0,0 +1,6 @@
+import './debug.esm.js';
+import './chunks/node-nKJBk8iJ.esm.js';
+export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, R as Register, b as allocated, c as allocatedValues, d as arrayDiff, e as attend, f as cache, g as cached, h as callOnGC, i as chainPromise, j as debounce, k as deepWatch, l as deprecated, m as descriptor, n as destructor, o as forwardArray, p as getAt, q as isCached, r as lift, s as memoize, t as morph, u as organize, v as organized, w as profileInfo, t as project, x as register, y as resource, z as scan, B as setAt, C as throttle, F as unreactive, G as watch, H as when } from './chunks/index-CaaQQlPJ.esm.js';
+export { A as AZone, D as DecoratorError, I as IterableWeakMap, a as IterableWeakSet, R as ReactiveBase, b as ReactiveError, c as ReactiveErrorCode, Z as Zone, d as ZoneAggregator, e as ZoneHistory, f as addBatchCleanup, g as arrayEquals, h as asyncHook, i as asyncHooks, j as asyncZone, k as atom, l as atomic, m as biDi, n as caught, o as cleanedBy, p as cleanup, q as createFlavor, r as decorator, s as deepCompare, t as defer, u as effect, v as effectAggregator, w as flavorOptions, x as flavored, y as formatCleanupReason, z as getActivationLog, B as getActiveEffect, C as getState, E as hooks, F as immutables, G as isConstructor, H as isNonReactive, J as isObject, K as isReactive, L as legacyDecorator, M as mixin, N as modernDecorator, O as named, P as objectToProxy, Q as onEffectThrow, S as proxyToObject, T as reactive, U as reactiveOptions, V as reset, W as root, X as stopped, Y as tag, _ as touched, $ as touched1, a0 as untracked, a1 as unwrap, a2 as zip } from './chunks/proxy-r7lARftl.esm.js';
+import 'node:async_hooks';
+//# sourceMappingURL=node.dev.esm.js.map

package/dist/node.dev.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.dev.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/node.esm.js

@@ -1,104 +1,5 @@
-import { createHook } from 'node:async_hooks';
-import { a as asyncHooks } from './chunks/index-DhaOVusv.esm.js';
-export { A as AZone, b as ArrayReadForward, D as DecoratorError, c as Destroyable, d as DestructionError, E as Eventful, F as FoolProof, I as Indexable, e as IterableWeakMap, f as IterableWeakSet, R as ReactiveBase, g as ReactiveError, h as ReactiveErrorCode, i as Register, Z as Zone, j as ZoneAggregator, k as ZoneHistory, l as addBatchCleanup, m as allocated, n as allocatedValues, o as arrayEquals, p as asyncHook, q as asyncZone, r as atomic, s as biDi, t as buildReactivityGraph, u as cache, v as cached, w as callOnGC, x as chainPromise, y as cleanedBy, z as cleanup, B as contentRef, C as debounce, G as decorator, H as deepCompare, J as deepWatch, K as defer, L as deprecated, M as derived, N as describe, O as destructor, P as effect, Q as effectAggregator, S as enableDevTools, T as forwardArray, U as getActivationLog, V as getActiveEffect, W as getActiveProjection, X as getAt, Y as getState, _ as immutables, $ as isCached, a0 as isConstructor, a1 as isDevtoolsEnabled, a2 as isNonReactive, a3 as isOwnAccessor, a4 as isReactive, a5 as legacyDecorator, a6 as memoize, a7 as mixin, a8 as modernDecorator, a9 as named, aa as organize, ab as organized, ac as profileInfo, ad as project, ae as reactive, af as reactiveOptions, ag as register, ah as registerEffectForDebug, ai as registerNativeReactivity, aj as registerObjectForDebug, ak as renamed, al as resolve, am as root, an as scan, ao as setAt, ap as setEffectName, aq as setObjectName, ar as tag, as as throttle, at as touched, au as touched1, av as trackEffect, aw as unreactive, ax as untracked, ay as unwrap, az as watch, aA as zip } from './chunks/index-DhaOVusv.esm.js';
-
-// 1. Generic async_hooks implementation for Hooks
-// This maintains support for 'asyncHooks.addHook' for generic use cases.
-const hooks = new Set();
-asyncHooks.addHook = function (hook) {
-    hooks.add(hook);
-    return () => {
-        hooks.delete(hook);
-    };
-};
-const contexts = new Map();
-const activeUndoers = new Map();
-// Helper to capture current hooks state
-function captureRestorers() {
-    if (hooks.size === 0)
-        return [];
-    const restorers = [];
-    for (const h of hooks) {
-        const r = h();
-        if (r)
-            restorers.push(r);
-    }
-    return restorers;
-}
-// Manual Wrap function to handle Promise callbacks
-function wrap(fn) {
-    if (typeof fn !== 'function')
-        return fn;
-    const restorers = captureRestorers();
-    if (restorers.length === 0)
-        return fn;
-    return function (...args) {
-        const undoers = [];
-        for (const restore of restorers) {
-            const u = restore();
-            if (u)
-                undoers.push(u);
-        }
-        try {
-            return fn.apply(this, args);
-        }
-        finally {
-            for (let i = undoers.length - 1; i >= 0; i--)
-                undoers[i]();
-        }
-    };
-}
-const hook = createHook({
-    init(asyncId, type, triggerId, resource) {
-        // Used for native resources like Timers
-        const restorers = captureRestorers();
-        if (restorers.length > 0)
-            contexts.set(asyncId, restorers);
-    },
-    before(asyncId) {
-        const restorers = contexts.get(asyncId);
-        if (!restorers)
-            return;
-        const undoers = [];
-        for (const restore of restorers) {
-            const u = restore();
-            if (u)
-                undoers.push(u);
-        }
-        if (undoers.length > 0)
-            activeUndoers.set(asyncId, undoers);
-    },
-    after(asyncId) {
-        const undoers = activeUndoers.get(asyncId);
-        if (!undoers)
-            return;
-        for (let i = undoers.length - 1; i >= 0; i--)
-            undoers[i]();
-        activeUndoers.delete(asyncId);
-    },
-    destroy(asyncId) {
-        contexts.delete(asyncId);
-        activeUndoers.delete(asyncId);
-    },
-});
-hook.enable();
-// 2. Shadow Promise Implementation
-// Ensures V8 await resumptions are visible as .then callbacks, wrapping them to restore context.
-const OriginalPromise = globalThis.Promise;
-const originalMethods = {
-    then: OriginalPromise.prototype.then,
-    catch: OriginalPromise.prototype.catch,
-    finally: OriginalPromise.prototype.finally};
-// Patch prototype
-OriginalPromise.prototype.then = function (onFulfilled, onRejected) {
-    return originalMethods.then.call(this, wrap(onFulfilled), wrap(onRejected));
-};
-OriginalPromise.prototype.catch = function (onRejected) {
-    return originalMethods.catch.call(this, wrap(onRejected));
-};
-OriginalPromise.prototype.finally = function (onFinally) {
-    return originalMethods.finally.call(this, wrap(onFinally));
-};
-
-export { asyncHooks };
+import './chunks/node-nKJBk8iJ.esm.js';
+export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, R as Register, b as allocated, c as allocatedValues, d as arrayDiff, e as attend, f as cache, g as cached, h as callOnGC, i as chainPromise, j as debounce, k as deepWatch, l as deprecated, m as descriptor, n as destructor, o as forwardArray, p as getAt, q as isCached, r as lift, s as memoize, t as morph, u as organize, v as organized, w as profileInfo, t as project, x as register, y as resource, z as scan, B as setAt, C as throttle, F as unreactive, G as watch, H as when } from './chunks/index-CaaQQlPJ.esm.js';
+export { A as AZone, D as DecoratorError, I as IterableWeakMap, a as IterableWeakSet, R as ReactiveBase, b as ReactiveError, c as ReactiveErrorCode, Z as Zone, d as ZoneAggregator, e as ZoneHistory, f as addBatchCleanup, g as arrayEquals, h as asyncHook, i as asyncHooks, j as asyncZone, k as atom, l as atomic, m as biDi, n as caught, o as cleanedBy, p as cleanup, q as createFlavor, r as decorator, s as deepCompare, t as defer, u as effect, v as effectAggregator, w as flavorOptions, x as flavored, y as formatCleanupReason, z as getActivationLog, B as getActiveEffect, C as getState, E as hooks, F as immutables, G as isConstructor, H as isNonReactive, J as isObject, K as isReactive, L as legacyDecorator, M as mixin, N as modernDecorator, O as named, P as objectToProxy, Q as onEffectThrow, S as proxyToObject, T as reactive, U as reactiveOptions, V as reset, W as root, X as stopped, Y as tag, _ as touched, $ as touched1, a0 as untracked, a1 as unwrap, a2 as zip } from './chunks/proxy-r7lARftl.esm.js';
+import 'node:async_hooks';
 //# sourceMappingURL=node.esm.js.map

package/dist/node.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"node.esm.js","sources":["../src/async/node.ts"],"sourcesContent":["import { createHook } from 'node:async_hooks'\nimport { Hook, Restorer, asyncHooks } from '.'\n\n// 1. Generic async_hooks implementation for Hooks\n// This maintains support for 'asyncHooks.addHook' for generic use cases.\n\nconst hooks = new Set<Hook>()\nasyncHooks.addHook = function (hook: Hook) {\n\thooks.add(hook)\n\treturn () => {\n\t\thooks.delete(hook)\n\t}\n}\n\nconst contexts = new Map<number, Restorer[]>()\nconst activeUndoers = new Map<number, (() => void)[]>()\n\n// Helper to capture current hooks state\nfunction captureRestorers() {\n\tif (hooks.size === 0) return []\n\tconst restorers: Restorer[] = []\n\tfor (const h of hooks) {\n\t\tconst r = h()\n\t\tif (r) restorers.push(r)\n\t}\n\treturn restorers\n}\n\n// Manual Wrap function to handle Promise callbacks\nfunction wrap<Args extends any[], R>(fn: ((...args: Args) => R) | null | undefined) {\n\tif (typeof fn !== 'function') return fn\n\tconst restorers = captureRestorers()\n\tif (restorers.length === 0) return fn\n\n\treturn function (this: any, ...args: Args) {\n\t\tconst undoers: (() => void)[] = []\n\t\tfor (const restore of restorers) {\n\t\t\tconst u = restore()\n\t\t\tif (u) undoers.push(u)\n\t\t}\n\t\ttry {\n\t\t\treturn fn.apply(this, args)\n\t\t} finally {\n\t\t\tfor (let i = undoers.length - 1; i >= 0; i--) undoers[i]()\n\t\t}\n\t}\n}\n\nconst hook = createHook({\n\tinit(asyncId, type, triggerId, resource) {\n\t\t// Used for native resources like Timers\n\t\tconst restorers = captureRestorers()\n\t\tif (restorers.length > 0) contexts.set(asyncId, restorers)\n\t},\n\tbefore(asyncId) {\n\t\tconst restorers = contexts.get(asyncId)\n\t\tif (!restorers) return\n\t\tconst undoers: (() => void)[] = []\n\t\tfor (const restore of restorers) {\n\t\t\tconst u = restore()\n\t\t\tif (u) undoers.push(u)\n\t\t}\n\t\tif (undoers.length > 0) activeUndoers.set(asyncId, undoers)\n\t},\n\tafter(asyncId) {\n\t\tconst undoers = activeUndoers.get(asyncId)\n\t\tif (!undoers) return\n\t\tfor (let i = undoers.length - 1; i >= 0; i--) undoers[i]()\n\t\tactiveUndoers.delete(asyncId)\n\t},\n\tdestroy(asyncId) {\n\t\tcontexts.delete(asyncId)\n\t\tactiveUndoers.delete(asyncId)\n\t},\n})\nhook.enable()\n\n// 2. Shadow Promise Implementation\n// Ensures V8 await resumptions are visible as .then callbacks, wrapping them to restore context.\n\nconst OriginalPromise = globalThis.Promise\nconst originalMethods = {\n\tthen: OriginalPromise.prototype.then,\n\tcatch: OriginalPromise.prototype.catch,\n\tfinally: OriginalPromise.prototype.finally,\n\tresolve: OriginalPromise.resolve,\n\treject: OriginalPromise.reject,\n\tall: OriginalPromise.all,\n}\n\n\n\n// Patch prototype\nOriginalPromise.prototype.then = function(onFulfilled, onRejected) {\n\treturn originalMethods.then.call(this, wrap(onFulfilled), wrap(onRejected))\n} as any\nOriginalPromise.prototype.catch = function(onRejected) {\n\treturn originalMethods.catch.call(this, wrap(onRejected))\n} as any\nOriginalPromise.prototype.finally = function(onFinally) {\n\treturn originalMethods.finally.call(this, wrap(onFinally))\n} as any\n\n\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"node.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}