@rstest/core 0.9.5 → 0.9.6

package/dist/browser-runtime/2~fake-timers.js

@@ -1,4 +1,4 @@
-import { __webpack_require__ } from "./rslib-runtime.js";
+import { __webpack_require__ } from "./723.js";
 import "./723.js";
 __webpack_require__.add({
     "../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/called-in-order.js" (module, __unused_rspack_exports, __webpack_require__) {
@@ -183,7 +183,7 @@ __webpack_require__.add({
         }
         module.exports = valueToString;
     },
-    "../../node_modules/.pnpm/@sinonjs+fake-timers@15.1.1/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js" (__unused_rspack_module, exports, __webpack_require__) {
+    "../../node_modules/.pnpm/@sinonjs+fake-timers@15.2.0/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js" (__unused_rspack_module, exports, __webpack_require__) {
         const globalObject = __webpack_require__("../../node_modules/.pnpm/@sinonjs+commons@3.0.1/node_modules/@sinonjs/commons/lib/index.js").global;
         let timersModule, timersPromisesModule;
         try {
@@ -220,11 +220,11 @@ __webpack_require__.add({
             isPresent.performance = _global.performance && "function" == typeof _global.performance.now;
             const hasPerformancePrototype = _global.Performance && (typeof _global.Performance).match(/^(function|object)$/);
             const hasPerformanceConstructorPrototype = _global.performance && _global.performance.constructor && _global.performance.constructor.prototype;
-            isPresent.queueMicrotask = _global.hasOwnProperty("queueMicrotask");
+            isPresent.queueMicrotask = Object.prototype.hasOwnProperty.call(_global, "queueMicrotask");
             isPresent.requestAnimationFrame = _global.requestAnimationFrame && "function" == typeof _global.requestAnimationFrame;
             isPresent.cancelAnimationFrame = _global.cancelAnimationFrame && "function" == typeof _global.cancelAnimationFrame;
             isPresent.requestIdleCallback = _global.requestIdleCallback && "function" == typeof _global.requestIdleCallback;
-            isPresent.cancelIdleCallbackPresent = _global.cancelIdleCallback && "function" == typeof _global.cancelIdleCallback;
+            isPresent.cancelIdleCallback = _global.cancelIdleCallback && "function" == typeof _global.cancelIdleCallback;
             isPresent.setImmediate = _global.setImmediate && "function" == typeof _global.setImmediate;
             isPresent.clearImmediate = _global.clearImmediate && "function" == typeof _global.clearImmediate;
             isPresent.Intl = _global.Intl && "object" == typeof _global.Intl;
@@ -232,6 +232,7 @@ __webpack_require__.add({
             const NativeDate = _global.Date;
             const NativeIntl = isPresent.Intl ? Object.defineProperties(Object.create(null), Object.getOwnPropertyDescriptors(_global.Intl)) : void 0;
             let uniqueTimerId = idCounterStart;
+            let uniqueTimerOrder = 0;
             if (void 0 === NativeDate) throw new Error("The global scope doesn't have a `Date` object (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)");
             isPresent.Date = true;
             class FakePerformanceEntry {
@@ -392,52 +393,63 @@ __webpack_require__.add({
             }
             function addTimer(clock, timer) {
                 if (void 0 === timer.func) throw new Error("Callback must be provided to timer calls");
-                if (addTimerReturnsObject) {
-                    if ("function" != typeof timer.func) throw new TypeError(`[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${timer.func} of type ${typeof timer.func}`);
-                }
+                if ("function" != typeof timer.func) throw new TypeError(`[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${timer.func} of type ${typeof timer.func}`);
                 if (isNearInfiniteLimit) timer.error = new Error();
                 timer.type = timer.immediate ? "Immediate" : "Timeout";
-                if (timer.hasOwnProperty("delay")) {
+                if (Object.prototype.hasOwnProperty.call(timer, "delay")) {
                     if ("number" != typeof timer.delay) timer.delay = parseInt(timer.delay, 10);
                     if (!isNumberFinite(timer.delay)) timer.delay = 0;
                     timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;
                     timer.delay = Math.max(0, timer.delay);
                 }
-                if (timer.hasOwnProperty("interval")) {
+                if (Object.prototype.hasOwnProperty.call(timer, "interval")) {
                     timer.type = "Interval";
                     timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;
                 }
-                if (timer.hasOwnProperty("animation")) {
+                if (Object.prototype.hasOwnProperty.call(timer, "animation")) {
                     timer.type = "AnimationFrame";
                     timer.animation = true;
                 }
-                if (timer.hasOwnProperty("idleCallback")) {
-                    timer.type = "IdleCallback";
-                    timer.idleCallback = true;
+                if (Object.prototype.hasOwnProperty.call(timer, "requestIdleCallback")) {
+                    if (!timer.delay) timer.type = "IdleCallback";
+                    timer.requestIdleCallback = true;
+                }
+                if (!clock.timers) {
+                    clock.timers = {};
+                    clock.timerHeap = new TimerHeap();
+                }
+                while(clock.timers && clock.timers[uniqueTimerId]){
+                    uniqueTimerId++;
+                    if (uniqueTimerId >= Number.MAX_SAFE_INTEGER) uniqueTimerId = idCounterStart;
                 }
-                if (!clock.timers) clock.timers = {};
                 timer.id = uniqueTimerId++;
+                if (uniqueTimerId >= Number.MAX_SAFE_INTEGER) uniqueTimerId = idCounterStart;
+                timer.order = uniqueTimerOrder++;
                 timer.createdAt = clock.now;
                 timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
                 clock.timers[timer.id] = timer;
+                clock.timerHeap.push(timer);
                 if (addTimerReturnsObject) {
                     const res = {
                         refed: true,
                         ref: function() {
                             this.refed = true;
-                            return res;
+                            return this;
                         },
                         unref: function() {
                             this.refed = false;
-                            return res;
+                            return this;
                         },
                         hasRef: function() {
                             return this.refed;
                         },
                         refresh: function() {
                             timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+                            clock.timerHeap.remove(timer);
+                            timer.order = uniqueTimerOrder++;
                             clock.timers[timer.id] = timer;
-                            return res;
+                            clock.timerHeap.push(timer);
+                            return this;
                         },
                         [Symbol.toPrimitive]: function() {
                             return timer.id;
@@ -448,53 +460,124 @@ __webpack_require__.add({
                 return timer.id;
             }
             function compareTimers(a, b) {
+                if ("IdleCallback" === a.type && "IdleCallback" !== b.type) return 1;
+                if ("IdleCallback" !== a.type && "IdleCallback" === b.type) return -1;
                 if (a.callAt < b.callAt) return -1;
                 if (a.callAt > b.callAt) return 1;
                 if (a.immediate && !b.immediate) return -1;
                 if (!a.immediate && b.immediate) return 1;
+                if (a.order < b.order) return -1;
+                if (a.order > b.order) return 1;
                 if (a.createdAt < b.createdAt) return -1;
                 if (a.createdAt > b.createdAt) return 1;
                 if (a.id < b.id) return -1;
                 if (a.id > b.id) return 1;
+                return 0;
+            }
+            function TimerHeap() {
+                this.timers = [];
             }
+            TimerHeap.prototype.peek = function() {
+                return this.timers[0];
+            };
+            TimerHeap.prototype.push = function(timer) {
+                this.timers.push(timer);
+                this.bubbleUp(this.timers.length - 1);
+            };
+            TimerHeap.prototype.pop = function() {
+                if (0 === this.timers.length) return;
+                const first = this.timers[0];
+                const last = this.timers.pop();
+                if (this.timers.length > 0) {
+                    this.timers[0] = last;
+                    last.heapIndex = 0;
+                    this.bubbleDown(0);
+                }
+                delete first.heapIndex;
+                return first;
+            };
+            TimerHeap.prototype.remove = function(timer) {
+                const index = timer.heapIndex;
+                if (void 0 === index || this.timers[index] !== timer) return false;
+                const last = this.timers.pop();
+                if (timer !== last) {
+                    this.timers[index] = last;
+                    last.heapIndex = index;
+                    if (compareTimers(last, timer) < 0) this.bubbleUp(index);
+                    else this.bubbleDown(index);
+                }
+                delete timer.heapIndex;
+                return true;
+            };
+            TimerHeap.prototype.bubbleUp = function(index) {
+                const timer = this.timers[index];
+                let currentIndex = index;
+                while(currentIndex > 0){
+                    const parentIndex = Math.floor((currentIndex - 1) / 2);
+                    const parent = this.timers[parentIndex];
+                    if (compareTimers(timer, parent) < 0) {
+                        this.timers[currentIndex] = parent;
+                        parent.heapIndex = currentIndex;
+                        currentIndex = parentIndex;
+                    } else break;
+                }
+                this.timers[currentIndex] = timer;
+                timer.heapIndex = currentIndex;
+            };
+            TimerHeap.prototype.bubbleDown = function(index) {
+                const timer = this.timers[index];
+                let currentIndex = index;
+                const halfLength = Math.floor(this.timers.length / 2);
+                while(currentIndex < halfLength){
+                    const leftIndex = 2 * currentIndex + 1;
+                    const rightIndex = leftIndex + 1;
+                    let bestChildIndex = leftIndex;
+                    let bestChild = this.timers[leftIndex];
+                    if (rightIndex < this.timers.length && compareTimers(this.timers[rightIndex], bestChild) < 0) {
+                        bestChildIndex = rightIndex;
+                        bestChild = this.timers[rightIndex];
+                    }
+                    if (compareTimers(bestChild, timer) < 0) {
+                        this.timers[currentIndex] = bestChild;
+                        bestChild.heapIndex = currentIndex;
+                        currentIndex = bestChildIndex;
+                    } else break;
+                }
+                this.timers[currentIndex] = timer;
+                timer.heapIndex = currentIndex;
+            };
             function firstTimerInRange(clock, from, to) {
-                const timers = clock.timers;
+                if (!clock.timerHeap) return null;
+                const timers = clock.timerHeap.timers;
+                if (1 === timers.length && timers[0].requestIdleCallback) return timers[0];
+                const first = clock.timerHeap.peek();
+                if (first && inRange(from, to, first)) return first;
                 let timer = null;
-                let id, isInRange;
-                for(id in timers)if (timers.hasOwnProperty(id)) {
-                    isInRange = inRange(from, to, timers[id]);
-                    if (isInRange && (!timer || 1 === compareTimers(timer, timers[id]))) timer = timers[id];
-                }
+                for(let i = 0; i < timers.length; i++)if (inRange(from, to, timers[i]) && (!timer || 1 === compareTimers(timer, timers[i]))) timer = timers[i];
                 return timer;
             }
             function firstTimer(clock) {
-                const timers = clock.timers;
-                let timer = null;
-                let id;
-                for(id in timers)if (timers.hasOwnProperty(id)) {
-                    if (!timer || 1 === compareTimers(timer, timers[id])) timer = timers[id];
-                }
-                return timer;
+                if (!clock.timerHeap) return null;
+                return clock.timerHeap.peek() || null;
             }
             function lastTimer(clock) {
-                const timers = clock.timers;
+                if (!clock.timerHeap) return null;
+                const timers = clock.timerHeap.timers;
                 let timer = null;
-                let id;
-                for(id in timers)if (timers.hasOwnProperty(id)) {
-                    if (!timer || -1 === compareTimers(timer, timers[id])) timer = timers[id];
-                }
+                for(let i = 0; i < timers.length; i++)if (!timer || -1 === compareTimers(timer, timers[i])) timer = timers[i];
                 return timer;
             }
             function callTimer(clock, timer) {
-                if ("number" == typeof timer.interval) clock.timers[timer.id].callAt += timer.interval;
-                else delete clock.timers[timer.id];
-                if ("function" == typeof timer.func) timer.func.apply(null, timer.args);
-                else {
-                    const eval2 = eval;
-                    (function() {
-                        eval2(timer.func);
-                    })();
+                if ("number" == typeof timer.interval) {
+                    clock.timerHeap.remove(timer);
+                    timer.callAt += timer.interval;
+                    timer.order = uniqueTimerOrder++;
+                    clock.timerHeap.push(timer);
+                } else {
+                    delete clock.timers[timer.id];
+                    clock.timerHeap.remove(timer);
                 }
+                if ("function" == typeof timer.func) timer.func.apply(null, timer.args);
             }
             function getClearHandler(ttype) {
                 if ("IdleCallback" === ttype || "AnimationFrame" === ttype) return `cancel${ttype}`;
@@ -524,10 +607,12 @@ __webpack_require__.add({
                     const stackTrace = new Error().stack.split("\n").slice(1).join("\n");
                     warnOnce(`FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.\nTo automatically clean-up native timers, use \`shouldClearNativeTimers\`.\n${stackTrace}`);
                 }
-                if (clock.timers.hasOwnProperty(id)) {
+                if (Object.prototype.hasOwnProperty.call(clock.timers, id)) {
                     const timer = clock.timers[id];
-                    if (timer.type === ttype || "Timeout" === timer.type && "Interval" === ttype || "Interval" === timer.type && "Timeout" === ttype) delete clock.timers[id];
-                    else {
+                    if (timer.type === ttype || "Timeout" === timer.type && "Interval" === ttype || "Interval" === timer.type && "Timeout" === ttype) {
+                        delete clock.timers[id];
+                        clock.timerHeap.remove(timer);
+                    } else {
                         const clear = getClearHandler(ttype);
                         const schedule = getScheduleHandler(timer.type);
                         throw new Error(`Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`);
@@ -546,7 +631,7 @@ __webpack_require__.add({
                         const originalPerfDescriptor = Object.getOwnPropertyDescriptor(clock, `_${method}`);
                         if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) Object.defineProperty(_global, method, originalPerfDescriptor);
                         else if (originalPerfDescriptor.configurable) _global[method] = clock[`_${method}`];
-                    } else if (_global[method] && _global[method].hadOwnProperty) _global[method] = clock[`_${method}`];
+                    } else if (clock[method] && clock[method].hasOwnProperty) _global[method] = clock[`_${method}`];
                     else try {
                         delete _global[method];
                     } catch (ignore) {}
@@ -565,13 +650,11 @@ __webpack_require__.add({
                     signal.removeEventListener("abort", listener);
                     clock.abortListenerMap.delete(listener);
                 }
-                if (!clock.timers) return [];
-                return Object.keys(clock.timers).map(function mapper(key) {
-                    return clock.timers[key];
-                });
+                if (!clock.timerHeap) return [];
+                return clock.timerHeap.timers.slice();
             }
             function hijackMethod(target, method, clock) {
-                clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(target, method);
+                clock[method].hasOwnProperty = Object.prototype.hasOwnProperty.call(target, method);
                 clock[`_${method}`] = target[method];
                 if ("Date" === method) target[method] = clock[method];
                 else if ("Intl" === method) target[method] = clock[method];
@@ -719,14 +802,23 @@ __webpack_require__.add({
                         });
                     });
                 }
-                clock.requestIdleCallback = function requestIdleCallback(func, timeout) {
+                function getTimeToNextIdlePeriod() {
                     let timeToNextIdlePeriod = 0;
                     if (clock.countTimers() > 0) timeToNextIdlePeriod = 50;
+                    return timeToNextIdlePeriod;
+                }
+                clock.requestIdleCallback = function requestIdleCallback(func, { timeout } = {}) {
+                    const idleDeadline = {
+                        didTimeout: true,
+                        timeRemaining: getTimeToNextIdlePeriod
+                    };
                     const result = addTimer(clock, {
                         func: func,
-                        args: Array.prototype.slice.call(arguments, 2),
-                        delay: void 0 === timeout ? timeToNextIdlePeriod : Math.min(timeout, timeToNextIdlePeriod),
-                        idleCallback: true
+                        args: [
+                            idleDeadline
+                        ],
+                        delay: timeout,
+                        requestIdleCallback: true
                     });
                     return Number(result);
                 };
@@ -800,7 +892,7 @@ __webpack_require__.add({
                     };
                 }
                 clock.countTimers = function countTimers() {
-                    return Object.keys(clock.timers || {}).length + (clock.jobs || []).length;
+                    return (clock.timerHeap ? clock.timerHeap.timers.length : 0) + (clock.jobs || []).length;
                 };
                 clock.requestAnimationFrame = function requestAnimationFrame(func) {
                     const result = addTimer(clock, {
@@ -965,7 +1057,7 @@ __webpack_require__.add({
                             resetIsNearInfiniteLimit();
                             return clock.now;
                         }
-                        numTimers = Object.keys(clock.timers).length;
+                        numTimers = clock.timerHeap.timers.length;
                         if (0 === numTimers) {
                             resetIsNearInfiniteLimit();
                             return clock.now;
@@ -988,12 +1080,12 @@ __webpack_require__.add({
                                     runJobs(clock);
                                     let numTimers;
                                     if (i < clock.loopLimit) {
-                                        if (!clock.timers) {
+                                        if (!clock.timerHeap) {
                                             resetIsNearInfiniteLimit();
                                             resolve(clock.now);
                                             return;
                                         }
-                                        numTimers = Object.keys(clock.timers).length;
+                                        numTimers = clock.timerHeap.timers.length;
                                         if (0 === numTimers) {
                                             resetIsNearInfiniteLimit();
                                             resolve(clock.now);
@@ -1042,6 +1134,7 @@ __webpack_require__.add({
                 clock.reset = function reset() {
                     nanos = 0;
                     clock.timers = {};
+                    clock.timerHeap = new TimerHeap();
                     clock.jobs = [];
                     clock.now = start;
                 };
@@ -1053,7 +1146,7 @@ __webpack_require__.add({
                     adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;
                     clock.now = newNow;
                     nanos = 0;
-                    for(id in clock.timers)if (clock.timers.hasOwnProperty(id)) {
+                    for(id in clock.timers)if (Object.prototype.hasOwnProperty.call(clock.timers, id)) {
                         timer = clock.timers[id];
                         timer.createdAt += difference;
                         timer.callAt += difference;
@@ -1062,8 +1155,13 @@ __webpack_require__.add({
                 clock.jump = function jump(tickValue) {
                     const msFloat = "number" == typeof tickValue ? tickValue : parseTime(tickValue);
                     const ms = Math.floor(msFloat);
-                    for (const timer of Object.values(clock.timers))if (clock.now + ms > timer.callAt) timer.callAt = clock.now + ms;
+                    if (clock.timers) {
+                        for (const timer of Object.values(clock.timers))if (clock.now + ms > timer.callAt) timer.callAt = clock.now + ms;
+                        clock.timerHeap = new TimerHeap();
+                        for (const timer of Object.values(clock.timers))clock.timerHeap.push(timer);
+                    }
                     clock.tick(ms);
+                    return clock.now;
                 };
                 if (isPresent.performance) {
                     clock.performance = Object.create(null);
@@ -1084,6 +1182,9 @@ __webpack_require__.add({
                 config.shouldAdvanceTime = config.shouldAdvanceTime || false;
                 config.advanceTimeDelta = config.advanceTimeDelta || 20;
                 config.shouldClearNativeTimers = config.shouldClearNativeTimers || false;
+                const hasToFake = Object.prototype.hasOwnProperty.call(config, "toFake");
+                const hasToNotFake = Object.prototype.hasOwnProperty.call(config, "toNotFake");
+                if (hasToFake && hasToNotFake) throw new TypeError("config.toFake and config.toNotFake cannot be used together");
                 if (config.target) throw new TypeError("config.target is no longer supported. Use `withGlobal(target)` instead.");
                 function handleMissingTimer(timer) {
                     if (config.ignoreMissingTimers) return;
@@ -1096,8 +1197,13 @@ __webpack_require__.add({
                     return uninstall(clock);
                 };
                 clock.abortListenerMap = new Map();
-                clock.methods = config.toFake || [];
-                if (0 === clock.methods.length) clock.methods = Object.keys(timers);
+                if (hasToFake) {
+                    clock.methods = config.toFake || [];
+                    if (0 === clock.methods.length) clock.methods = Object.keys(timers);
+                } else if (hasToNotFake) {
+                    const methodsToNotFake = config.toNotFake || [];
+                    clock.methods = Object.keys(timers).filter((method)=>!methodsToNotFake.includes(method));
+                } else clock.methods = Object.keys(timers);
                 if (true === config.shouldAdvanceTime) clock.setTickMode({
                     mode: "interval",
                     delta: config.advanceTimeDelta
@@ -1539,7 +1645,7 @@ __webpack_require__.add({
 var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
 const RealDate = Date;
 const loadFakeTimersModule = ()=>{
-    const loaded = __webpack_require__("../../node_modules/.pnpm/@sinonjs+fake-timers@15.1.1/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js");
+    const loaded = __webpack_require__("../../node_modules/.pnpm/@sinonjs+fake-timers@15.2.0/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js");
     return {
         withGlobal: loaded.withGlobal
     };
@@ -1619,6 +1725,7 @@ class FakeTimers {
             ignoreMissingTimers: true,
             ...fakeTimersConfig
         });
+        this._clock.reset();
         this._fakingTime = true;
     }
     reset() {

package/dist/browser-runtime/2~magic-string.es.js

@@ -1,12 +1,5 @@
-import { __webpack_require__ } from "./rslib-runtime.js";
+import { __webpack_require__ } from "./723.js";
 import "./723.js";
-var magic_string_es_namespaceObject = {};
-__webpack_require__.r(magic_string_es_namespaceObject);
-__webpack_require__.d(magic_string_es_namespaceObject, {
-    Bundle: ()=>Bundle,
-    SourceMap: ()=>SourceMap,
-    default: ()=>MagicString
-});
 var Buffer = __webpack_require__("../../node_modules/.pnpm/buffer@5.7.1/node_modules/buffer/index.js")["Buffer"];
 var comma = ",".charCodeAt(0);
 var semicolon = ";".charCodeAt(0);
@@ -1033,184 +1026,5 @@ class MagicString {
         return this._replaceRegexp(searchValue, replacement);
     }
 }
-const hasOwnProp = Object.prototype.hasOwnProperty;
-class Bundle {
-    constructor(options = {}){
-        this.intro = options.intro || '';
-        this.separator = void 0 !== options.separator ? options.separator : '\n';
-        this.sources = [];
-        this.uniqueSources = [];
-        this.uniqueSourceIndexByFilename = {};
-    }
-    addSource(source) {
-        if (source instanceof MagicString) return this.addSource({
-            content: source,
-            filename: source.filename,
-            separator: this.separator
-        });
-        if (!isObject(source) || !source.content) throw new Error('bundle.addSource() takes an object with a `content` property, which should be an instance of MagicString, and an optional `filename`');
-        [
-            'filename',
-            'ignoreList',
-            'indentExclusionRanges',
-            'separator'
-        ].forEach((option)=>{
-            if (!hasOwnProp.call(source, option)) source[option] = source.content[option];
-        });
-        if (void 0 === source.separator) source.separator = this.separator;
-        if (source.filename) if (hasOwnProp.call(this.uniqueSourceIndexByFilename, source.filename)) {
-            const uniqueSource = this.uniqueSources[this.uniqueSourceIndexByFilename[source.filename]];
-            if (source.content.original !== uniqueSource.content) throw new Error(`Illegal source: same filename (${source.filename}), different contents`);
-        } else {
-            this.uniqueSourceIndexByFilename[source.filename] = this.uniqueSources.length;
-            this.uniqueSources.push({
-                filename: source.filename,
-                content: source.content.original
-            });
-        }
-        this.sources.push(source);
-        return this;
-    }
-    append(str, options) {
-        this.addSource({
-            content: new MagicString(str),
-            separator: options && options.separator || ''
-        });
-        return this;
-    }
-    clone() {
-        const bundle = new Bundle({
-            intro: this.intro,
-            separator: this.separator
-        });
-        this.sources.forEach((source)=>{
-            bundle.addSource({
-                filename: source.filename,
-                content: source.content.clone(),
-                separator: source.separator
-            });
-        });
-        return bundle;
-    }
-    generateDecodedMap(options = {}) {
-        const names = [];
-        let x_google_ignoreList;
-        this.sources.forEach((source)=>{
-            Object.keys(source.content.storedNames).forEach((name)=>{
-                if (!~names.indexOf(name)) names.push(name);
-            });
-        });
-        const mappings = new Mappings(options.hires);
-        if (this.intro) mappings.advance(this.intro);
-        this.sources.forEach((source, i)=>{
-            if (i > 0) mappings.advance(this.separator);
-            const sourceIndex = source.filename ? this.uniqueSourceIndexByFilename[source.filename] : -1;
-            const magicString = source.content;
-            const locate = getLocator(magicString.original);
-            if (magicString.intro) mappings.advance(magicString.intro);
-            magicString.firstChunk.eachNext((chunk)=>{
-                const loc = locate(chunk.start);
-                if (chunk.intro.length) mappings.advance(chunk.intro);
-                if (source.filename) if (chunk.edited) mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
-                else mappings.addUneditedChunk(sourceIndex, chunk, magicString.original, loc, magicString.sourcemapLocations);
-                else mappings.advance(chunk.content);
-                if (chunk.outro.length) mappings.advance(chunk.outro);
-            });
-            if (magicString.outro) mappings.advance(magicString.outro);
-            if (source.ignoreList && -1 !== sourceIndex) {
-                if (void 0 === x_google_ignoreList) x_google_ignoreList = [];
-                x_google_ignoreList.push(sourceIndex);
-            }
-        });
-        return {
-            file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
-            sources: this.uniqueSources.map((source)=>options.file ? getRelativePath(options.file, source.filename) : source.filename),
-            sourcesContent: this.uniqueSources.map((source)=>options.includeContent ? source.content : null),
-            names,
-            mappings: mappings.raw,
-            x_google_ignoreList
-        };
-    }
-    generateMap(options) {
-        return new SourceMap(this.generateDecodedMap(options));
-    }
-    getIndentString() {
-        const indentStringCounts = {};
-        this.sources.forEach((source)=>{
-            const indentStr = source.content._getRawIndentString();
-            if (null === indentStr) return;
-            if (!indentStringCounts[indentStr]) indentStringCounts[indentStr] = 0;
-            indentStringCounts[indentStr] += 1;
-        });
-        return Object.keys(indentStringCounts).sort((a, b)=>indentStringCounts[a] - indentStringCounts[b])[0] || '\t';
-    }
-    indent(indentStr) {
-        if (!arguments.length) indentStr = this.getIndentString();
-        if ('' === indentStr) return this;
-        let trailingNewline = !this.intro || '\n' === this.intro.slice(-1);
-        this.sources.forEach((source, i)=>{
-            const separator = void 0 !== source.separator ? source.separator : this.separator;
-            const indentStart = trailingNewline || i > 0 && /\r?\n$/.test(separator);
-            source.content.indent(indentStr, {
-                exclude: source.indentExclusionRanges,
-                indentStart
-            });
-            trailingNewline = '\n' === source.content.lastChar();
-        });
-        if (this.intro) this.intro = indentStr + this.intro.replace(/^[^\n]/gm, (match, index)=>index > 0 ? indentStr + match : match);
-        return this;
-    }
-    prepend(str) {
-        this.intro = str + this.intro;
-        return this;
-    }
-    toString() {
-        const body = this.sources.map((source, i)=>{
-            const separator = void 0 !== source.separator ? source.separator : this.separator;
-            const str = (i > 0 ? separator : '') + source.content.toString();
-            return str;
-        }).join('');
-        return this.intro + body;
-    }
-    isEmpty() {
-        if (this.intro.length && this.intro.trim()) return false;
-        if (this.sources.some((source)=>!source.content.isEmpty())) return false;
-        return true;
-    }
-    length() {
-        return this.sources.reduce((length, source)=>length + source.content.length(), this.intro.length);
-    }
-    trimLines() {
-        return this.trim('[\\r\\n]');
-    }
-    trim(charType) {
-        return this.trimStart(charType).trimEnd(charType);
-    }
-    trimStart(charType) {
-        const rx = new RegExp('^' + (charType || '\\s') + '+');
-        this.intro = this.intro.replace(rx, '');
-        if (!this.intro) {
-            let source;
-            let i = 0;
-            do {
-                source = this.sources[i++];
-                if (!source) break;
-            }while (!source.content.trimStartAborted(charType))
-        }
-        return this;
-    }
-    trimEnd(charType) {
-        const rx = new RegExp((charType || '\\s') + '+$');
-        let source;
-        let i = this.sources.length - 1;
-        do {
-            source = this.sources[i--];
-            if (!source) {
-                this.intro = this.intro.replace(rx, '');
-                break;
-            }
-        }while (!source.content.trimEndAborted(charType))
-        return this;
-    }
-}
-export { magic_string_es_namespaceObject };
+Object.prototype.hasOwnProperty;
+export default MagicString;

package/dist/browser-runtime/2~snapshot.js

@@ -1,5 +1,5 @@
 /*! LICENSE: 2~snapshot.js.LICENSE.txt */
-import { __webpack_require__ } from "./rslib-runtime.js";
+import { __webpack_require__ } from "./723.js";
 import { dist_format, dist_plugins, getTaskNameWithPrefix, subsetEquality, pathe_M_eThtNZ_resolve, dist_equals, iterableEquality } from "./723.js";
 var snapshot_namespaceObject = {};
 __webpack_require__.r(snapshot_namespaceObject);
@@ -1260,7 +1260,7 @@ function offsetToLineNumber(source, offset) {
     return line + 1;
 }
 async function saveInlineSnapshots(environment, snapshots) {
-    const MagicString = (await import("./2~magic-string.es.js").then((m)=>m.magic_string_es_namespaceObject)).default;
+    const MagicString = (await import("./2~magic-string.es.js")).default;
     const files = new Set(snapshots.map((i)=>i.file));
     await Promise.all(Array.from(files).map(async (file)=>{
         const snaps = snapshots.filter((i)=>i.file === file);