mutts 1.0.9 → 1.0.11

package/dist/node.cjs

@@ -1,11 +1,11 @@
 'use strict';
 
-require('./chunks/async-node-C3DeIb0y.cjs');
+require('./chunks/async-node-3PrbVAbB.cjs');
 var browser = require('./browser.cjs');
-var debug = require('./chunks/index-VTO-b2vR.cjs');
+var proxy = require('./chunks/proxy-Cc79Lrzj.cjs');
 var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
 require('node:async_hooks');
-require('./chunks/async-browser-lvzLOCgk.cjs');
+require('./chunks/async-browser-Dgr5CreQ.cjs');
 
 
 
@@ -14,9 +14,9 @@ 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;
@@ -25,82 +25,88 @@ exports.chainPromise = browser.chainPromise;
 exports.debounce = browser.debounce;
 exports.deepWatch = browser.deepWatch;
 exports.deprecated = browser.deprecated;
-exports.describe = browser.describe;
 exports.descriptor = browser.descriptor;
 exports.destructor = browser.destructor;
 exports.forwardArray = browser.forwardArray;
-exports.getActiveProjection = browser.getActiveProjection;
 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.project;
-exports.register = browser.register;
-exports.scan = browser.scan;
+exports.project = browser.morph;
+exports.resource = browser.resource;
 exports.setAt = browser.setAt;
 exports.throttle = browser.throttle;
 exports.unreactive = browser.unreactive;
 exports.watch = browser.watch;
-exports.AZone = debug.AZone;
-exports.DecoratorError = debug.DecoratorError;
-exports.FoolProof = debug.FoolProof;
-exports.IterableWeakMap = debug.IterableWeakMap;
-exports.IterableWeakSet = debug.IterableWeakSet;
-exports.ReactiveBase = debug.ReactiveBase;
-exports.ReactiveError = debug.ReactiveError;
+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 debug.ReactiveErrorCode; }
+	get: function () { return proxy.ReactiveErrorCode; }
 });
-exports.Zone = debug.Zone;
-exports.ZoneAggregator = debug.ZoneAggregator;
-exports.ZoneHistory = debug.ZoneHistory;
-exports.addBatchCleanup = debug.addBatchCleanup;
-exports.arrayEquals = debug.arrayEquals;
-exports.asyncZone = debug.asyncZone;
-exports.atomic = debug.atomic;
-exports.biDi = debug.biDi;
-exports.cleanedBy = debug.cleanedBy;
-exports.cleanup = debug.cleanup;
-exports.contentRef = debug.contentRef;
-exports.createFlavor = debug.createFlavor;
-exports.decorator = debug.decorator;
-exports.deepCompare = debug.deepCompare;
-exports.defer = debug.defer;
-exports.derived = debug.derived;
-exports.effect = debug.effect;
-exports.effectAggregator = debug.effectAggregator;
-exports.flavorOptions = debug.flavorOptions;
-exports.flavored = debug.flavored;
-exports.getActivationLog = debug.getActivationLog;
-exports.getActiveEffect = debug.getActiveEffect;
-exports.getState = debug.getState;
-exports.immutables = debug.immutables;
-exports.isConstructor = debug.isConstructor;
-exports.isNonReactive = debug.isNonReactive;
-exports.isOwnAccessor = debug.isOwnAccessor;
-exports.isReactive = debug.isReactive;
-exports.legacyDecorator = debug.legacyDecorator;
-exports.mixin = debug.mixin;
-exports.modernDecorator = debug.modernDecorator;
-exports.named = debug.named;
-exports.onEffectThrow = debug.onEffectThrow;
-exports.onEffectTrigger = debug.onEffectTrigger;
-exports.reactive = debug.reactive;
-exports.reactiveOptions = debug.options;
-exports.registerNativeReactivity = debug.registerNativeReactivity;
-exports.renamed = debug.renamed;
-exports.reset = debug.reset;
-exports.root = debug.root;
-exports.tag = debug.tag;
-exports.touched = debug.touched;
-exports.touched1 = debug.touched1;
-exports.untracked = debug.untracked;
-exports.unwrap = debug.unwrap;
-exports.zip = debug.zip;
+exports.Zone = proxy.Zone;
+exports.ZoneAggregator = proxy.ZoneAggregator;
+exports.ZoneHistory = proxy.ZoneHistory;
+exports.addBatchCleanup = proxy.addBatchCleanup;
+exports.addUnreactiveProps = proxy.addUnreactiveProps;
+exports.arrayEquals = proxy.arrayEquals;
+exports.assertUntracked = proxy.assertUntracked;
+exports.asyncZone = proxy.asyncZone;
+exports.atom = proxy.atom;
+exports.atomic = proxy.atomic;
+exports.biDi = proxy.biDi;
+exports.captured = proxy.captured;
+exports.caught = proxy.caught;
+exports.createFlavor = proxy.createFlavor;
+exports.debugPreset = proxy.debugPreset;
+exports.decorator = proxy.decorator;
+exports.deepCompare = proxy.deepCompare;
+exports.defer = proxy.defer;
+exports.devPreset = proxy.devPreset;
+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.isConstructor = proxy.isConstructor;
+exports.isDev = proxy.isDev;
+exports.isNonReactive = proxy.isNonReactive;
+exports.isObject = proxy.isObject;
+exports.isProd = proxy.isProd;
+exports.isReactive = proxy.isReactive;
+exports.isTest = proxy.isTest;
+exports.legacyDecorator = proxy.legacyDecorator;
+exports.link = proxy.link;
+exports.mixin = proxy.mixin;
+exports.modernDecorator = proxy.modernDecorator;
+exports.named = proxy.named;
+exports.objectToProxy = proxy.objectToProxy;
+exports.onEffectThrow = proxy.onEffectThrow;
+exports.prodPreset = proxy.prodPreset;
+exports.proxyToObject = proxy.proxyToObject;
+exports.reactive = proxy.reactive;
+exports.reactiveOptions = proxy.options;
+exports.reset = proxy.reset;
+exports.root = proxy.root;
+exports.tag = proxy.tag;
+exports.touched = proxy.touched;
+exports.touched1 = proxy.touched1;
+exports.unlink = proxy.unlink;
+exports.untracked = proxy.untracked;
+exports.unwrap = proxy.unwrap;
+exports.zip = proxy.zip;
 exports.asyncHook = asyncCore.asyncHook;
 exports.asyncHooks = asyncCore.asyncHooks;
 exports.hooks = asyncCore.hooks;

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

package/dist/node.dev.cjs

@@ -0,0 +1,114 @@
+'use strict';
+
+require('./debug.cjs');
+require('./chunks/async-node-3PrbVAbB.cjs');
+var browser = require('./browser.cjs');
+var proxy = require('./chunks/proxy-Cc79Lrzj.cjs');
+var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
+require('node:async_hooks');
+require('./chunks/async-browser-Dgr5CreQ.cjs');
+
+
+
+exports.ArrayReadForward = browser.ArrayReadForward;
+exports.Destroyable = browser.Destroyable;
+exports.DestructionError = browser.DestructionError;
+exports.Eventful = browser.Eventful;
+exports.Indexable = browser.Indexable;
+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.resource = browser.resource;
+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.addUnreactiveProps = proxy.addUnreactiveProps;
+exports.arrayEquals = proxy.arrayEquals;
+exports.assertUntracked = proxy.assertUntracked;
+exports.asyncZone = proxy.asyncZone;
+exports.atom = proxy.atom;
+exports.atomic = proxy.atomic;
+exports.biDi = proxy.biDi;
+exports.captured = proxy.captured;
+exports.caught = proxy.caught;
+exports.createFlavor = proxy.createFlavor;
+exports.debugPreset = proxy.debugPreset;
+exports.decorator = proxy.decorator;
+exports.deepCompare = proxy.deepCompare;
+exports.defer = proxy.defer;
+exports.devPreset = proxy.devPreset;
+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.isConstructor = proxy.isConstructor;
+exports.isDev = proxy.isDev;
+exports.isNonReactive = proxy.isNonReactive;
+exports.isObject = proxy.isObject;
+exports.isProd = proxy.isProd;
+exports.isReactive = proxy.isReactive;
+exports.isTest = proxy.isTest;
+exports.legacyDecorator = proxy.legacyDecorator;
+exports.link = proxy.link;
+exports.mixin = proxy.mixin;
+exports.modernDecorator = proxy.modernDecorator;
+exports.named = proxy.named;
+exports.objectToProxy = proxy.objectToProxy;
+exports.onEffectThrow = proxy.onEffectThrow;
+exports.prodPreset = proxy.prodPreset;
+exports.proxyToObject = proxy.proxyToObject;
+exports.reactive = proxy.reactive;
+exports.reactiveOptions = proxy.options;
+exports.reset = proxy.reset;
+exports.root = proxy.root;
+exports.tag = proxy.tag;
+exports.touched = proxy.touched;
+exports.touched1 = proxy.touched1;
+exports.unlink = proxy.unlink;
+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, C as CleanupReason, c as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, G as GetterWrapper, H as HistoryValue, P as PropTrigger, R as ReactiveError, h as ReactiveErrorCode, S as ScopedCallback, i as Zone, Z as ZoneAggregator, j as ZoneHistory, k as asyncZone, l as debugPreset, m as devPreset, n as formatCleanupReason, o as isReactive, p as objectToProxy, q as prodPreset, r as proxyToObject, s as reactiveOptions, u as unwrap } from './types-Bx2PhORg.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, Resource, Restorer, addBatchCleanup, addUnreactiveProps, allocated, allocatedValues, arrayDiff, arrayEquals, assertUntracked, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, captured, caught, chainPromise, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, isCached, isConstructor, isDev, isNonReactive, isObject, isProd, isTest, legacyDecorator, lift, link, memoize, mixin, modernDecorator, morph, named, onEffectThrow, organize, organized, profileInfo, morph as project, reactive, reset, resource, root, setAt, tag, throttle, touched, touched1, unlink, 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-Bo7WU5S2.esm.js';
+export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, 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 resource, y as setAt, z as throttle, B as unreactive, C as watch, F as when } from './chunks/index-Sf74wXTV.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 addUnreactiveProps, h as arrayEquals, i as assertUntracked, j as asyncHook, k as asyncHooks, l as asyncZone, m as atom, n as atomic, o as biDi, p as captured, q as caught, r as createFlavor, s as debugPreset, t as decorator, u as deepCompare, v as defer, w as devPreset, x as effect, y as effectAggregator, z as flavorOptions, B as flavored, C as formatCleanupReason, E as getActivationLog, F as getActiveEffect, G as getState, H as hooks, J as isConstructor, K as isDev, L as isNonReactive, M as isObject, N as isProd, O as isReactive, P as isTest, Q as legacyDecorator, S as link, T as mixin, U as modernDecorator, V as named, W as objectToProxy, X as onEffectThrow, Y as prodPreset, _ as proxyToObject, $ as reactive, a0 as reactiveOptions, a1 as reset, a2 as root, a3 as tag, a4 as touched, a5 as touched1, a6 as unlink, a7 as untracked, a8 as unwrap, a9 as zip } from './chunks/proxy-D2C49sXH.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,98 +1,5 @@
-import { createHook } from 'node:async_hooks';
-import { h as hooks } from './chunks/index-CtA2AWl3.esm.js';
-export { A as AZone, D as DecoratorError, F as FoolProof, I as IterableWeakMap, b as IterableWeakSet, R as ReactiveBase, c as ReactiveError, d as ReactiveErrorCode, Z as Zone, e as ZoneAggregator, f as ZoneHistory, g as addBatchCleanup, i as arrayEquals, j as asyncHook, a as asyncHooks, k as asyncZone, l as atomic, m as biDi, n as cleanedBy, o as cleanup, p as contentRef, q as createFlavor, r as decorator, s as deepCompare, t as defer, u as derived, v as effect, w as effectAggregator, x as flavorOptions, y as flavored, z as getActivationLog, B as getActiveEffect, C as getState, E as immutables, G as isConstructor, H as isNonReactive, J as isOwnAccessor, K as isReactive, L as legacyDecorator, M as mixin, N as modernDecorator, O as named, P as onEffectThrow, Q as onEffectTrigger, S as reactive, T as reactiveOptions, U as registerNativeReactivity, V as renamed, W as reset, X as root, Y as tag, _ as touched, $ as touched1, a0 as untracked, a1 as unwrap, a2 as zip } from './chunks/index-CtA2AWl3.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 attend, e as cache, f as cached, g as callOnGC, h as chainPromise, i as debounce, j as deepWatch, k as deprecated, l as describe, m as descriptor, n as destructor, o as forwardArray, p as getActiveProjection, q as getAt, r as isCached, s as lift, t as memoize, u as organize, v as organized, w as profileInfo, x as project, y as register, z as scan, B as setAt, C as throttle, F as unreactive, G as watch } from './chunks/index-2vea86wD.esm.js';
-
-// 1. Generic async_hooks implementation for Hooks
-// This maintains support for 'asyncHooks.addHook' for generic use cases.
-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 { hooks };
+import './chunks/node-Bo7WU5S2.esm.js';
+export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, 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 resource, y as setAt, z as throttle, B as unreactive, C as watch, F as when } from './chunks/index-Sf74wXTV.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 addUnreactiveProps, h as arrayEquals, i as assertUntracked, j as asyncHook, k as asyncHooks, l as asyncZone, m as atom, n as atomic, o as biDi, p as captured, q as caught, r as createFlavor, s as debugPreset, t as decorator, u as deepCompare, v as defer, w as devPreset, x as effect, y as effectAggregator, z as flavorOptions, B as flavored, C as formatCleanupReason, E as getActivationLog, F as getActiveEffect, G as getState, H as hooks, J as isConstructor, K as isDev, L as isNonReactive, M as isObject, N as isProd, O as isReactive, P as isTest, Q as legacyDecorator, S as link, T as mixin, U as modernDecorator, V as named, W as objectToProxy, X as onEffectThrow, Y as prodPreset, _ as proxyToObject, $ as reactive, a0 as reactiveOptions, a1 as reset, a2 as root, a3 as tag, a4 as touched, a5 as touched1, a6 as unlink, a7 as untracked, a8 as unwrap, a9 as zip } from './chunks/proxy-D2C49sXH.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 { hooks, type Restorer } from '.'\n\n// 1. Generic async_hooks implementation for Hooks\n// This maintains support for 'asyncHooks.addHook' for generic use cases.\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// 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"],"names":[],"mappings":"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"}
+{"version":3,"file":"node.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}