mutts 1.0.12 → 1.0.13

package/dist/chunks/{index-yK0HVxHv.cjs → index-CAdnMJev.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var proxy = require('./proxy-BvM4yewA.cjs');
+var proxy = require('./proxy-DBHj3kGK.cjs');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 // Integrated with `using` statement via Symbol.dispose
@@ -259,46 +259,57 @@ function buildPatches(history, A, B, offset, finalX, finalY, finalD, finalK, vOf
 var _a, _b;
 const events = Symbol('events');
 const hooks = Symbol('hooks');
+function getEventMap(target) {
+    return target[events];
+}
+function getHookSet(target) {
+    return target[hooks];
+}
 const eventBehavior = {
     on(eventOrEvents, cb) {
+        const self = this;
+        const eventMap = getEventMap(self);
         if (typeof eventOrEvents === 'object') {
             for (const e of Object.keys(eventOrEvents)) {
                 this.on(e, eventOrEvents[e]);
             }
         }
         else if (cb !== undefined) {
-            const callbacks = this[events].get(eventOrEvents) ?? new Set();
+            const callbacks = eventMap.get(eventOrEvents) ?? new Set();
             if (!callbacks.has(cb))
                 callbacks.add(cb);
-            this[events].set(eventOrEvents, callbacks);
+            eventMap.set(eventOrEvents, callbacks);
         }
         return () => this.off(eventOrEvents, cb);
     },
     off(eventOrEvents, cb) {
+        const self = this;
+        const eventMap = getEventMap(self);
         if (typeof eventOrEvents === 'object') {
             for (const e of Object.keys(eventOrEvents)) {
                 this.off(e, eventOrEvents[e]);
             }
         }
         else if (cb !== null && cb !== undefined) {
-            const callbacks = this[events].get(eventOrEvents);
+            const callbacks = eventMap.get(eventOrEvents);
             if (callbacks) {
                 callbacks.delete(cb);
                 if (!callbacks.size)
-                    this[events].delete(eventOrEvents);
+                    eventMap.delete(eventOrEvents);
             }
         }
         else {
             // Remove all listeners for this event
-            this[events].delete(eventOrEvents);
+            eventMap.delete(eventOrEvents);
         }
     },
     emit(event, ...args) {
-        const callbacks = this[events].get(event);
+        const self = this;
+        const callbacks = getEventMap(self).get(event);
         if (callbacks)
             for (const cb of callbacks)
                 cb.apply(this, args);
-        for (const cb of this[hooks])
+        for (const cb of getHookSet(self))
             cb.call(this, event, ...args);
     },
 };
@@ -308,7 +319,7 @@ function perEvent(eventful, fct, use) {
         get(target, prop) {
             if (typeof prop !== 'string')
                 return target[prop];
-            if (use && !eventful[events].has(prop) && !eventful[hooks].size)
+            if (use && !getEventMap(eventful).has(prop) && !getHookSet(eventful).size)
                 return () => { };
             // Return cached function or create and cache
             let cached = cache.get(prop);
@@ -747,7 +758,7 @@ function chainPromise(given) {
     return chained;
 }
 
-function attend(source, callback) {
+const attend = proxy.captioned(function attend(source, callback) {
     const enumerate = typeof source === 'function'
         ? source
         : Array.isArray(source)
@@ -758,14 +769,16 @@ function attend(source, callback) {
                     ? () => source.values()
                     : () => Object.keys(source);
     const keyEffects = new Map();
-    const outer = proxy.effect.named('attend')(({ ascend }) => {
+    const callbackLabel = callback.name ? callback.name : '';
+    const outer = proxy.effect `attend`(({ ascend }) => {
         const keys = new Set();
         for (const key of enumerate())
             keys.add(key);
         for (const key of keys) {
             if (keyEffects.has(key))
                 continue;
-            keyEffects.set(key, ascend(() => proxy.effect.named(`attend:${key}`)((access) => callback(key, access))));
+            const indexRef = { value: key };
+            keyEffects.set(key, ascend(() => proxy.effect `attend${callbackLabel ? `:${callbackLabel}` : ''}:${key}`((access) => callback(indexRef.value, access))));
         }
         for (const key of Array.from(keyEffects.keys())) {
             if (!keys.has(key)) {
@@ -780,17 +793,50 @@ function attend(source, callback) {
             stop(reason);
         keyEffects.clear();
     };
-}
-function lift(cb) {
+}, {
+    name: 'attend',
+    callbackIndex: 1,
+    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
+});
+/**
+ * Lifts a callback that returns an object into a reactive object that automatically
+ * synchronizes with the source object returned by the callback.
+ *
+ * The returned reactive object will update whenever the callback's dependencies change,
+ * efficiently syncing only the properties that differ from the previous result using
+ * Object.assign(). Properties that no longer exist in the source are automatically removed.
+ *
+ * @example
+ * ```typescript
+ * const user = reactive({ name: 'John', age: 30 })
+ * const profile = lift(() => ({
+ *   displayName: user.name.toUpperCase(),
+ *   isAdult: user.age >= 18,
+ *   description: `${user.name} is ${user.age} years old`
+ * }))
+ *
+ * console.log(profile.displayName) // JOHN
+ * console.log(profile.isAdult) // true
+ *
+ * user.name = 'Jane'
+ * console.log(profile.displayName) // JANE
+ * console.log(profile.description) // Jane is 30 years old
+ * ```
+ *
+ * @param cb Callback function that returns an object
+ * @returns A reactive object synchronized with the callback's result, with a [cleanup] property to stop tracking
+ */
+const lift = proxy.captioned(function lift(cb) {
     let result;
     let rawResult;
-    const liftCleanup = proxy.effect.named(`lift:${cb.name}`)(proxy.markWithRoot((access) => {
+    const resultName = `lift:${cb.name || 'anonymous'}`;
+    const liftCleanup = proxy.effect `lift:${cb.name}`(proxy.markWithRoot((access) => {
         const source = cb(access);
         if (!source || typeof source !== 'object')
             throw new Error('lift callback must return an array or object');
         const sourceProto = Object.getPrototypeOf(source);
         if (!result) {
-            rawResult = Array.isArray(source) ? [] : Object.create(sourceProto);
+            rawResult = proxy.tag(resultName, Array.isArray(source) ? [] : Object.create(sourceProto));
             result = proxy.reactive(rawResult);
         }
         if (sourceProto !== Object.getPrototypeOf(result))
@@ -801,6 +847,7 @@ function lift(cb) {
                 res.splice(indexA, sliceA.length, ...sliceB);
         }
         else {
+            const recordResult = rawResult;
             for (const key of Object.keys(source)) {
                 const had = key in rawResult;
                 const newDesc = Object.getOwnPropertyDescriptor(source, key);
@@ -809,7 +856,7 @@ function lift(cb) {
                     const sameAccessor = oldDesc && newDesc.get && oldDesc.get === newDesc.get;
                     Object.defineProperty(rawResult, key, newDesc);
                     if (!sameAccessor &&
-                        rawResult[key] !==
+                        recordResult[key] !==
                             (oldDesc ? (oldDesc.get ? oldDesc.get() : oldDesc.value) : undefined))
                         proxy.touched1(rawResult, { type: 'set', prop: key }, key);
                 }
@@ -820,13 +867,16 @@ function lift(cb) {
             }
             for (const key of Object.keys(rawResult))
                 if (!(key in source)) {
-                    delete rawResult[key];
+                    delete recordResult[key];
                     proxy.touched1(rawResult, { type: 'del', prop: key }, key);
                 }
         }
     }, cb));
     return proxy.link(result, liftCleanup);
-}
+}, {
+    name: 'lift',
+    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
+});
 /**
  * Reactively maps an array source through `fn`, producing a lazy reactive output array.
  *
@@ -850,12 +900,18 @@ function morphArray(source, fn, options) {
     }
     let track;
     const itemEffects = new Map();
-    const cache = [];
+    const cache = proxy.tag(`morph:${fn.name || 'anonymous'}`, []);
     let input = [];
     function stopItem(key) {
         const entry = itemEffects.get(key);
         if (entry) {
-            entry.stop({ type: 'stopped' });
+            const activeEffect = proxy.getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = proxy.getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            entry.stop(proxy.chainExternalReason({ type: 'stopped', chain }));
             itemEffects.delete(key);
         }
     }
@@ -868,12 +924,22 @@ function morphArray(source, fn, options) {
         }
         else {
             const indexRef = { value: key };
-            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+            const stop = track(() => proxy.effect.opaque `morph:${fn.name}:${key}`((access) => {
                 cache[indexRef.value] = fn(input, access);
                 return (reason) => {
                     delete cache[indexRef.value];
                     proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
+                    const activeEffect = proxy.getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = proxy.getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: proxy.chainExternalReason(chain),
+                    });
                 };
             }));
             itemEffects.set(key, { stop, index: indexRef });
@@ -892,7 +958,7 @@ function morphArray(source, fn, options) {
             return Reflect.has(input, prop);
         },
     });
-    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
+    const stopMain = proxy.effect `morph:${fn.name}`(({ ascend }) => {
         track = ascend;
         const newInput = [...(typeof source === 'function' ? source() : source)];
         const diffs = arrayDiff(input, newInput).toSorted((a, b) => b.indexA - a.indexA);
@@ -966,12 +1032,18 @@ function morphMap(source, fn, options) {
     }
     let track;
     const itemEffects = new Map();
-    const cache = new Map();
+    const cache = proxy.tag(`morph:${fn.name || 'anonymous'}`, new Map());
     Object.defineProperty(cache, 'constructor', { value: Object, enumerable: false });
     function stopItem(key) {
         const stop = itemEffects.get(key);
         if (stop) {
-            stop({ type: 'stopped' });
+            const activeEffect = proxy.getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = proxy.getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            stop({ type: 'stopped', chain });
             itemEffects.delete(key);
         }
     }
@@ -981,12 +1053,25 @@ function morphMap(source, fn, options) {
             cache.set(key, track(() => fn(val, key)));
         }
         else {
-            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
-                cache.set(key, fn(source.get(key), key, access));
+            const stop = track(() => proxy.effect.opaque `morph:${fn.name}:${key}`((access) => {
+                const next = source.get(key);
+                if (next === undefined && !source.has(key))
+                    return;
+                cache.set(key, fn(next, key, access));
                 return (reason) => {
                     cache.delete(key);
                     proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
+                    const activeEffect = proxy.getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = proxy.getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: proxy.chainExternalReason(chain),
+                    });
                 };
             }));
             itemEffects.set(key, stop);
@@ -1030,7 +1115,7 @@ function morphMap(source, fn, options) {
         },
     });
     let stateSnapshot = proxy.getState(source);
-    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
+    const stopMain = proxy.effect `morph:${fn.name}`(({ ascend }) => {
         track = ascend;
         proxy.dependant(source, proxy.keysOf);
         while ('evolution' in stateSnapshot) {
@@ -1077,7 +1162,13 @@ function morphRecord(source, fn, options) {
     function stopItem(key) {
         const stop = itemEffects.get(key);
         if (stop) {
-            stop({ type: 'stopped' });
+            const activeEffect = proxy.getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = proxy.getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            stop({ type: 'stopped', chain });
             itemEffects.delete(key);
         }
     }
@@ -1087,12 +1178,22 @@ function morphRecord(source, fn, options) {
             cache[key] = track(() => fn(val, key));
         }
         else {
-            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+            const stop = track(() => proxy.effect.opaque `morph:${fn.name}:${key}`((access) => {
                 cache[key] = fn(source[key], key, access);
                 return (reason) => {
                     delete cache[key];
                     proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
+                    const activeEffect = proxy.getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = proxy.getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: proxy.chainExternalReason(chain),
+                    });
                 };
             }));
             itemEffects.set(key, stop);
@@ -1119,7 +1220,7 @@ function morphRecord(source, fn, options) {
         },
     });
     let stateSnapshot = proxy.getState(source);
-    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
+    const stopMain = proxy.effect `morph:${fn.name}`(({ ascend }) => {
         track = ascend;
         // Track only structural changes on source
         proxy.dependant(source, proxy.keysOf);
@@ -1160,7 +1261,7 @@ function morphRecord(source, fn, options) {
  * // Changing users[0].name only recomputes names[0]
  * ```
  */
-const morph = proxy.flavored(function morph(source, fn, options) {
+const morph = proxy.captioned(proxy.flavored(function morph(source, fn, options) {
     if (Array.isArray(source) || typeof source === 'function')
         return morphArray(source, fn, options);
     if (source instanceof Map)
@@ -1170,6 +1271,10 @@ const morph = proxy.flavored(function morph(source, fn, options) {
     get pure() {
         return (source, fn, _opt) => this(source, fn, { pure: true });
     },
+}), {
+    name: 'morph',
+    callbackIndex: 1,
+    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
 });
 
 /**
@@ -1195,7 +1300,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
     const wrappedCallback = proxy.markWithRoot((() => callback(target)), callback);
     proxy.registerDeepWatcher();
     // Use the existing effect system to register dependencies
-    return proxy.effect.named('deepWatch')(() => {
+    return proxy.effect `deepWatch`(() => {
         // Mark the target object as having deep watchers
         proxy.objectsWithDeepWatchers.add(target);
         // Track which objects this effect is watching for cleanup
@@ -1259,7 +1364,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
         traverseAndTrack(target);
         // Only call the callback if immediate is true or if it's not the first run
         if (immediate) {
-            proxy.untracked(() => callback(target));
+            proxy.untracked `deepWatch:callback`(() => callback(target));
         }
         immediate = true;
         // Return a cleanup function that properly removes deep watcher tracking
@@ -1326,7 +1431,7 @@ function memoizeFunction(fn, opts) {
                 const wasVerification = proxy.options.isVerificationRun;
                 proxy.options.isVerificationRun = true;
                 try {
-                    const fresh = proxy.untracked(() => fn.apply(this, args));
+                    const fresh = proxy.untracked `memoize:verify-calculation`(() => fn.apply(this, args));
                     if (!proxy.deepCompare(node.result, fresh)) {
                         proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
                     }
@@ -1339,7 +1444,7 @@ function memoizeFunction(fn, opts) {
         }
         // Create memoize internal effect to track dependencies and invalidate cache
         // Use untracked to prevent the effect creation from being affected by parent effects
-        node.cleanup = proxy.root(() => proxy.effect.named('memoize')(() => {
+        node.cleanup = proxy.root `memoize:root`(() => proxy.effect `memoize`(() => {
             // Execute the function and track its dependencies
             // The function execution will automatically track dependencies on reactive objects
             node.result = fn.apply(this, args);
@@ -1350,7 +1455,17 @@ function memoizeFunction(fn, opts) {
                 // Lazy memoization: stop the effect so it doesn't re-run immediately.
                 // It will be re-created on next access.
                 if (node.cleanup) {
-                    node.cleanup({ type: 'invalidate', cause: reason });
+                    const activeEffect = proxy.getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const effectNode = proxy.getEffectNode(activeEffect);
+                        chain = effectNode.currentReason;
+                    }
+                    node.cleanup({
+                        type: 'invalidate',
+                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: proxy.chainExternalReason(chain),
+                    });
                     node.cleanup = undefined;
                 }
             };
@@ -1359,7 +1474,7 @@ function memoizeFunction(fn, opts) {
             const wasVerification = proxy.options.isVerificationRun;
             proxy.options.isVerificationRun = true;
             try {
-                const fresh = proxy.untracked(() => fn.apply(this, args));
+                const fresh = proxy.untracked `memoize:verify-comparison`(() => fn.apply(this, args));
                 if (!proxy.deepCompare(node.result, fresh)) {
                     proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
                 }
@@ -1551,12 +1666,12 @@ const memoize = proxy.flavored(makeMemoizeDecorator(), {
 function organized(source, apply, baseTarget = {}) {
     const observedSource = proxy.reactive(source);
     const target = proxy.reactive(baseTarget);
-    const stop = attend(() => {
+    const stop = attend `organized:entries`(function enumerateObservedSourceKeys() {
         const keys = [];
         for (const key in observedSource)
             keys.push(key);
         return keys;
-    }, (key) => {
+    }, function applyObservedSourceKey(key) {
         const sourceKey = key;
         const accessBase = {
             key: sourceKey,
@@ -1594,7 +1709,7 @@ function organize(target, property, access) {
 
 //#region watch
 const unsetYet = Symbol('unset-yet');
-const watch = proxy.flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
+const watch = proxy.captioned(proxy.flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
 changed, options = {}) {
     return typeof value === 'function'
         ? watchCallBack(value, changed, options)
@@ -1610,11 +1725,14 @@ changed, options = {}) {
     get immediate() {
         return proxy.flavorOptions(this, { immediate: true });
     },
+}), {
+    name: 'watch',
+    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
 });
 function watchObject(value, changed, { immediate = false, deep = false } = {}) {
     if (deep)
         return deepWatch(value, changed, { immediate });
-    return proxy.effect.named('watch:object')(() => {
+    return proxy.effect `watch:object`(() => {
         proxy.dependant(value);
         if (immediate)
             changed(value);
@@ -1624,16 +1742,16 @@ function watchObject(value, changed, { immediate = false, deep = false } = {}) {
 function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
     let oldValue = unsetYet;
     let deepCleanup;
-    const cbCleanup = proxy.effect.named('watch:callback')(proxy.markWithRoot((access) => {
+    const cbCleanup = proxy.effect `watch:callback`(proxy.markWithRoot((access) => {
         const newValue = value(access);
         if (oldValue !== newValue) {
             const old = oldValue;
             if (old === unsetYet) {
                 if (immediate)
-                    proxy.untracked(() => changed(newValue));
+                    proxy.untracked `watch:changed`(() => changed(newValue));
             }
             else
-                proxy.untracked(() => changed(newValue, old));
+                proxy.untracked `watch:changed`(() => changed(newValue, old));
         }
         oldValue = newValue;
         if (deep) {
@@ -1660,7 +1778,7 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
 function when(predicate, timeout) {
     return new Promise((resolve, reject) => {
         let timer;
-        const stop = proxy.effect.named('watch:when')((access) => {
+        const stop = proxy.effect `watch:when`((access) => {
             try {
                 const value = predicate(access);
                 if (value) {
@@ -1767,7 +1885,7 @@ function resource(fetcher, options = {}) {
     // Solve race conditions: make sure a new fast request is not overloaded by a slow old one
     let counter = 0;
     return lazyInit(resource, () => {
-        proxy.link(resource, proxy.effect.named('watch:resource')((access) => {
+        proxy.link(resource, proxy.effect `watch:resource`((access) => {
             // Track reload signal to enable manual reloading
             void reloadSignal.value;
             const id = ++counter;
@@ -1933,6 +2051,7 @@ let ReactiveArrayWrapper = (() => {
                 return super.findLastIndex((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
             }
             flat(depth) {
+                proxy.dependant(this, proxy.keysOf);
                 return proxy.reactive(super.flat(depth));
             }
             flatMap(callbackfn, thisArg) {
@@ -2359,59 +2478,62 @@ function isCached(object, propertyKey) {
 function cache(object, propertyKey, value) {
     Object.defineProperty(object, propertyKey, { value });
 }
+function descriptorBase(descriptor) {
+    return function descriptorDecorator(...properties) {
+        return (Base) => {
+            return class extends Base {
+                constructor(...args) {
+                    super(...args);
+                    for (const key of properties) {
+                        const existing = Object.getOwnPropertyDescriptor(this, key);
+                        Object.defineProperty(this, key, Object.assign(existing || {}, descriptor));
+                    }
+                }
+            };
+        };
+    };
+}
 /**
  * Creates a decorator that modifies property descriptors for specified properties
  * @param descriptor - The descriptor properties to apply
  * @returns A class decorator that applies the descriptor to specified properties
  */
-const descriptor = proxy.flavored(function descriptor(descriptor) {
-    return (...properties) => (Base) => {
-        return class extends Base {
-            constructor(...args) {
-                super(...args);
-                for (const key of properties) {
-                    const existing = Object.getOwnPropertyDescriptor(this, key);
-                    Object.defineProperty(this, key, Object.assign(existing || {}, descriptor));
-                }
-            }
-        };
-    };
-}, {
+const descriptor = Object.assign(descriptorBase, {
     /**
      * enumerable: true
      */
     get enumerable() {
-        return descriptor({ enumerable: true });
+        return descriptorBase({ enumerable: true });
     },
     /**
      * enumerable: false
      */
     get hidden() {
-        return descriptor({ enumerable: false });
+        return descriptorBase({ enumerable: false });
     },
     /**
      * configurable: true
      */
     get configurable() {
-        return descriptor({ configurable: true });
+        return descriptorBase({ configurable: true });
     },
     /**
      * configurable: false
      */
     get frozen() {
-        return descriptor({ configurable: false });
+        return descriptorBase({ configurable: false });
     },
     /**
      * writable: true
      */
     get writable() {
-        return descriptor({ writable: true });
+        return descriptorBase({ writable: true });
     },
     /**
      * writable: false
      */
     get readonly() {
-        return descriptor({ writable: false });
+        return descriptorBase({ writable: false });
     },
 });
 /**
@@ -2540,26 +2662,27 @@ function throttle(delay) {
     });
 }
 
-var version$1 = "1.0.12";
+var version$1 = "1.0.13";
 var pkg = {
 	version: version$1};
 
 const { version } = pkg;
 const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__';
+const runtimeGlobals = globalThis;
 const globalScope = (typeof globalThis !== 'undefined'
     ? globalThis
-    : typeof window !== 'undefined'
-        ? window
-        : typeof global !== 'undefined'
-            ? global
+    : runtimeGlobals.window
+        ? runtimeGlobals.window
+        : runtimeGlobals.global
+            ? runtimeGlobals.global
             : false);
 if (globalScope) {
     let source = 'mutts/index';
     try {
-        if (typeof __filename !== 'undefined')
-            source = __filename;
-        else if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-yK0HVxHv.cjs', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-yK0HVxHv.cjs', document.baseURI).href))) {
-            source = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-yK0HVxHv.cjs', document.baseURI).href));
+        if (runtimeGlobals.__filename)
+            source = runtimeGlobals.__filename;
+        else if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-CAdnMJev.cjs', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-CAdnMJev.cjs', document.baseURI).href))) {
+            source = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-CAdnMJev.cjs', document.baseURI).href));
         }
     }
     catch (_e) { }
@@ -2609,4 +2732,4 @@ exports.throttle = throttle;
 exports.unreactive = unreactive;
 exports.watch = watch;
 exports.when = when;
-//# sourceMappingURL=index-yK0HVxHv.cjs.map
+//# sourceMappingURL=index-CAdnMJev.cjs.map