@rstest/core 0.0.3 → 0.0.5

package/LICENSE

@@ -139,9 +139,9 @@ Licensed under MIT license in the repository at https://github.com/jestjs/jest.g
 
 ### @jridgewell/trace-mapping
 
-Licensed under MIT license in the repository at git+https://github.com/jridgewell/trace-mapping.git.
+Licensed under MIT license in the repository at git+https://github.com/jridgewell/sourcemaps.git.
 
-> Copyright 2022 Justin Ridgewell <justin@ridgewell.name>
+> Copyright 2024 Justin Ridgewell <justin@ridgewell.name>
 > 
 > Permission is hereby granted, free of charge, to any person obtaining a copy
 > of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -6,6 +6,14 @@
 
 Rstest is a testing framework powered by Rspack.
 
-## 📖 License
+## Documentation
+
+See [Documentation](https://rstest.rs).
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/rstest/blob/main/CONTRIBUTING.md).
+
+## License
 
 Rstest is licensed under the [MIT License](https://github.com/web-infra-dev/rstest/blob/main/LICENSE).

package/dist/285.js

@@ -26,6 +26,7 @@ export const __webpack_modules__ = {
             const getRsbuildStats = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.r)({
                 name,
                 globTestSourceEntries,
+                normalizedConfig: context.normalizedConfig,
                 setupFiles,
                 rsbuildInstance,
                 rootPath
@@ -54,7 +55,7 @@ export const __webpack_modules__ = {
             const hasError = list.some((file)=>file.errors?.length);
             if (hasError) {
                 const { printError } = await Promise.all([
-                    __webpack_require__.e("973"),
+                    __webpack_require__.e("723"),
                     __webpack_require__.e("355")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./src/utils/error.ts"));
                 process.exitCode = 1;

package/dist/353.js

@@ -323,7 +323,7 @@ export const __webpack_modules__ = {
                 utils.kg.log(`${utils.$_.bgRed(' FAIL ')} ${(0, utils.aj)(relativePath)} ${nameStr.length ? `${utils.$_.dim(utils.Qd)} ${nameStr}` : ''}`);
                 if (test.errors) {
                     const { printError } = await Promise.all([
-                        __webpack_require__.e("973"),
+                        __webpack_require__.e("723"),
                         __webpack_require__.e("355")
                     ]).then(__webpack_require__.bind(__webpack_require__, "./src/utils/error.ts"));
                     for (const error of test.errors)await printError(error, getSourcemap, rootPath);
@@ -374,7 +374,8 @@ export const __webpack_modules__ = {
                     const icon = isSlowCase && 'pass' === result.status ? utils.$_.yellow(statusStr[result.status]) : statusColorfulStr[result.status];
                     const nameStr = (0, utils.Yz)(result);
                     const duration = void 0 !== result.duration ? ` (${(0, utils.AS)(result.duration, false)})` : '';
-                    console.log(`  ${icon} ${nameStr}${utils.$_.gray(duration)}`);
+                    const retry = result.retryCount ? utils.$_.yellow(` (retry x${result.retryCount})`) : '';
+                    console.log(`  ${icon} ${nameStr}${utils.$_.gray(duration)}${retry}`);
                     if (result.errors) for (const error of result.errors)console.error(utils.$_.red(`    ${error.message}`));
                 }
             }
@@ -451,7 +452,7 @@ export const __webpack_modules__ = {
             });
             return {
                 command,
-                version: "0.0.3",
+                version: "0.0.5",
                 rootPath,
                 reporters,
                 snapshotManager,
@@ -466,14 +467,14 @@ export const __webpack_modules__ = {
             }, config);
             const runTests = async ()=>{
                 const { runTests } = await Promise.all([
-                    __webpack_require__.e("992"),
+                    __webpack_require__.e("612"),
                     __webpack_require__.e("629")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/runTests.ts"));
                 await runTests(context, fileFilters);
             };
             const listTests = async (options)=>{
                 const { listTests } = await Promise.all([
-                    __webpack_require__.e("992"),
+                    __webpack_require__.e("612"),
                     __webpack_require__.e("285")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./src/core/listTests.ts"));
                 await listTests(context, fileFilters, options);

package/dist/355.js

@@ -7,7 +7,7 @@ export const __webpack_modules__ = {
             printError: ()=>printError
         });
         var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("node:fs");
-        var _jridgewell_trace_mapping__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs");
+        var _jridgewell_trace_mapping__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.29/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs");
         var stacktrace_parser__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../../node_modules/.pnpm/stacktrace-parser@0.1.11/node_modules/stacktrace-parser/dist/stack-trace-parser.esm.js");
         var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./src/utils/index.ts");
         async function printError(error, getSourcemap, rootPath) {

package/dist/{992.js → 612.js}

@@ -1,5 +1,5 @@
 export const __webpack_ids__ = [
-    "992"
+    "612"
 ];
 export const __webpack_modules__ = {
     "./src/core/rsbuild.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -11,6 +11,38 @@ export const __webpack_modules__ = {
         var core_ = __webpack_require__("@rsbuild/core");
         var external_pathe_ = __webpack_require__("pathe");
         var utils = __webpack_require__("./src/utils/index.ts");
+        var external_node_path_ = __webpack_require__("node:path");
+        var external_node_url_ = __webpack_require__("node:url");
+        const PLUGIN_CSS_FILTER = 'rstest:css-filter';
+        const css_filter_dirname = external_node_path_["default"].dirname((0, external_node_url_.fileURLToPath)(import.meta.url));
+        const pluginCSSFilter = ()=>({
+                name: PLUGIN_CSS_FILTER,
+                setup (api) {
+                    api.modifyBundlerChain({
+                        order: 'post',
+                        handler: async (chain, { target, CHAIN_ID, environment })=>{
+                            const emitCss = environment.config.output.emitCss ?? 'web' === target;
+                            if (!emitCss) {
+                                const ruleIds = [
+                                    CHAIN_ID.RULE.CSS,
+                                    CHAIN_ID.RULE.SASS,
+                                    CHAIN_ID.RULE.LESS,
+                                    CHAIN_ID.RULE.STYLUS
+                                ];
+                                for (const ruleId of ruleIds){
+                                    if (!chain.module.rules.has(ruleId)) continue;
+                                    const rule = chain.module.rule(ruleId);
+                                    if (!rule.uses.has(CHAIN_ID.USE.CSS)) continue;
+                                    const cssLoaderOptions = rule.use(CHAIN_ID.USE.CSS).get('options');
+                                    if (cssLoaderOptions.modules && ('object' != typeof cssLoaderOptions.modules || false !== cssLoaderOptions.modules.auto)) rule.use('rstest-css-pre-filter').loader(external_node_path_["default"].join(css_filter_dirname, 'cssFilterLoader.mjs')).options({
+                                        modules: cssLoaderOptions.modules
+                                    }).after(ruleId);
+                                }
+                            }
+                        }
+                    });
+                }
+            });
         class TestFileWatchPlugin {
             contextToWatch = null;
             constructor(contextToWatch){
@@ -47,8 +79,8 @@ export const __webpack_modules__ = {
                             config.watchOptions.ignored = '**/**';
                             const sourceEntries = await globTestSourceEntries();
                             config.entry = {
-                                ...sourceEntries,
-                                ...setupFiles
+                                ...setupFiles,
+                                ...sourceEntries
                             };
                         }
                     });
@@ -73,12 +105,155 @@ export const __webpack_modules__ = {
                 });
             }
         };
+        class MockRuntimeRspackPlugin {
+            apply(compiler) {
+                const { RuntimeModule } = compiler.webpack;
+                class RetestImportRuntimeModule extends RuntimeModule {
+                    constructor(){
+                        super('rstest runtime');
+                    }
+                    generate() {
+                        return `
+if (typeof __webpack_require__ === 'undefined') {
+  return;
+}
+
+const originalRequire = __webpack_require__;
+__webpack_require__ = function(...args) {
+  try {
+    return originalRequire(...args);
+  } catch (e) {
+    const errMsg = e.message ?? e.toString();
+    if (errMsg.includes('__webpack_modules__[moduleId] is not a function')) {
+      throw new Error(\`Cannot find module '\${args[0]}'\`)
+    }
+    throw e;
+  }
+};
+
+Object.keys(originalRequire).forEach(key => {
+  __webpack_require__[key] = originalRequire[key];
+});
+
+__webpack_require__.rstest_original_modules = {};
+
+// TODO: Remove "reset_modules" in next Rspack version.
+__webpack_require__.rstest_reset_modules = __webpack_require__.reset_modules = () => {
+  const mockedIds = Object.keys(__webpack_require__.rstest_original_modules)
+  Object.keys(__webpack_module_cache__).forEach(id => {
+    // Do not reset mocks registry.
+    if (!mockedIds.includes(id)) {
+      delete __webpack_module_cache__[id];
+    }
+  });
+}
+
+// TODO: Remove "unmock" in next Rspack version.
+__webpack_require__.rstest_unmock = __webpack_require__.unmock = (id) => {
+  delete __webpack_module_cache__[id]
+}
+
+// TODO: Remove "require_actual" and "import_actual" in next Rspack version.
+__webpack_require__.rstest_require_actual = __webpack_require__.rstest_import_actual = __webpack_require__.require_actual = __webpack_require__.import_actual = (id) => {
+  const originalModule = __webpack_require__.rstest_original_modules[id];
+  // Use fallback module if the module is not mocked.
+  const fallbackMod = __webpack_require__(id);
+  return originalModule ? originalModule : fallbackMod;
+}
+
+// TODO: Remove "set_mock" in next Rspack version.
+__webpack_require__.rstest_set_mock = __webpack_require__.set_mock = (id, modFactory) => {
+  let requiredModule = undefined
+  try {
+    requiredModule = __webpack_require__(id);
+  } catch {
+    // TODO: non-resolved module
+  } finally {
+    __webpack_require__.rstest_original_modules[id] = requiredModule;
+  }
+  if (typeof modFactory === 'string' || typeof modFactory === 'number') {
+    __webpack_module_cache__[id] = { exports: __webpack_require__(modFactory) };
+  } else if (typeof modFactory === 'function') {
+    let exports = modFactory();
+    __webpack_require__.r(exports);
+    __webpack_module_cache__[id] = { exports, id, loaded: true };
+  }
+};
+`;
+                    }
+                }
+                compiler.hooks.thisCompilation.tap('CustomPlugin', (compilation)=>{
+                    compilation.hooks.additionalTreeRuntimeRequirements.tap('CustomPlugin', (chunk)=>{
+                        compilation.addRuntimeModule(chunk, new RetestImportRuntimeModule());
+                    });
+                });
+            }
+        }
+        const pluginMockRuntime = {
+            name: 'rstest:mock-runtime',
+            setup: (api)=>{
+                api.modifyRspackConfig(async (config)=>{
+                    config.plugins.push(new MockRuntimeRspackPlugin());
+                });
+            }
+        };
+        class RstestCacheControlPlugin {
+            apply(compiler) {
+                const { RuntimeModule } = compiler.webpack;
+                class RetestCacheControlModule extends RuntimeModule {
+                    constructor(){
+                        super('rstest_cache_control');
+                    }
+                    generate() {
+                        return `
+global.setupIds = [];
+
+function __rstest_clean_core_cache__() {
+  if (typeof __webpack_require__ === 'undefined') {
+    return;
+  }
+  delete __webpack_module_cache__['@rstest/core'];
+
+  global.setupIds.forEach((id) => {
+    delete __webpack_module_cache__[id];
+  });
+}
+
+global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
+`;
+                    }
+                }
+                compiler.hooks.thisCompilation.tap('CustomPlugin', (compilation)=>{
+                    compilation.hooks.additionalTreeRuntimeRequirements.tap('CustomPlugin', (chunk)=>{
+                        compilation.addRuntimeModule(chunk, new RetestCacheControlModule());
+                    });
+                });
+            }
+        }
+        const pluginCacheControl = (setupFiles)=>({
+                name: 'rstest:cache-control',
+                setup: (api)=>{
+                    api.transform({
+                        test: setupFiles
+                    }, ({ code })=>({
+                            code: `
+          ${code}
+         if (global.setupIds && __webpack_module__.id) {
+  global.setupIds.push(__webpack_module__.id);
+}
+        `
+                        }));
+                    api.modifyRspackConfig(async (config)=>{
+                        config.plugins.push(new RstestCacheControlPlugin());
+                    });
+                }
+            });
         const isMultiCompiler = (compiler)=>'compilers' in compiler && Array.isArray(compiler.compilers);
         const autoExternalNodeModules = ({ context, request, dependencyType, getResolve }, callback)=>{
-            if (!request || request.startsWith('node:')) return callback();
+            if (!request) return callback();
             if (request.startsWith('@swc/helpers/')) return callback();
             const doExternal = (externalPath = request)=>{
-                callback(void 0, externalPath, 'commonjs' === dependencyType ? 'commonjs' : 'module-import');
+                callback(void 0, externalPath, 'commonjs' === dependencyType ? 'commonjs' : 'import');
             };
             const resolver = getResolve?.();
             if (!resolver) return callback();
@@ -88,11 +263,20 @@ export const __webpack_modules__ = {
                 return callback();
             });
         };
+        const autoExternalNodeBuiltin = ({ request, dependencyType }, callback)=>{
+            if (!request) return callback();
+            const isNodeBuiltin = utils.Tn.some((builtin)=>{
+                if ('string' == typeof builtin) return builtin === request;
+                return builtin.test(request);
+            });
+            if (isNodeBuiltin) callback(void 0, request, 'commonjs' === dependencyType ? 'commonjs' : 'module-import');
+            else callback();
+        };
         const prepareRsbuild = async (context, globTestSourceEntries, setupFiles)=>{
-            const { command, normalizedConfig: { name, plugins, resolve, source, output, tools, testEnvironment } } = context;
+            const { command, normalizedConfig: { isolate, name, plugins, resolve, source, output, tools, testEnvironment, performance, dev = {} } } = context;
             const debugMode = (0, utils.L1)();
             core_.logger.level = debugMode ? 'verbose' : 'error';
-            const writeToDisk = debugMode;
+            const writeToDisk = dev.writeToDisk || debugMode;
             const rsbuildInstance = await (0, core_.createRsbuild)({
                 rsbuildConfig: {
                     tools,
@@ -105,6 +289,7 @@ export const __webpack_modules__ = {
                         strictPort: false,
                         middlewareMode: true
                     },
+                    performance,
                     environments: {
                         [name]: {
                             dev: {
@@ -123,28 +308,28 @@ export const __webpack_modules__ = {
                                 distPath: {
                                     root: utils.Nk
                                 },
-                                externals: [
-                                    {
-                                        '@rstest/core': 'global @rstest/core'
-                                    },
-                                    'node' === testEnvironment ? autoExternalNodeModules : {}
-                                ],
                                 target: 'node'
                             },
                             tools: {
                                 rspack: (config)=>{
                                     config.output ??= {};
                                     config.output.iife = false;
-                                    config.externalsPresets = {
-                                        node: true
-                                    };
+                                    config.output.importFunctionName = '__rstest_dynamic_import__';
                                     config.output.devtoolModuleFilenameTemplate = '[absolute-resource-path]';
                                     config.plugins.push(new core_.rspack.experiments.RstestPlugin({
                                         injectModulePathName: true,
-                                        hoistMockModule: true,
                                         importMetaPathName: true,
-                                        manualMockRoot: context.rootPath
+                                        hoistMockModule: true,
+                                        manualMockRoot: external_pathe_["default"].resolve(context.rootPath, '__mocks__')
                                     }));
+                                    config.externals = (0, utils.XQ)(config.externals) || [];
+                                    config.externals.unshift({
+                                        '@rstest/core': 'global @rstest/core'
+                                    });
+                                    if ('node' === testEnvironment) config.externals.push(autoExternalNodeModules);
+                                    config.externalsPresets ??= {};
+                                    config.externalsPresets.node = false;
+                                    config.externals.push(autoExternalNodeBuiltin);
                                     config.module.parser ??= {};
                                     config.module.parser.javascript = {
                                         importDynamic: false,
@@ -152,29 +337,26 @@ export const __webpack_modules__ = {
                                         requireAsExpression: false,
                                         ...config.module.parser.javascript || {}
                                     };
-                                    if ('node' === testEnvironment && ((0, utils.mP)()[0] || 0) < 20) {
-                                        config.resolve ??= {};
-                                        config.resolve.mainFields = config.resolve.mainFields?.filter((filed)=>'module' !== filed) || [
-                                            'main'
-                                        ];
-                                    }
+                                    config.resolve ??= {};
+                                    config.resolve.extensions ??= [];
+                                    config.resolve.extensions.push('.cjs');
+                                    if ('node' === testEnvironment && (0, utils.mP)().major < 20) config.resolve.mainFields = config.resolve.mainFields?.filter((filed)=>'module' !== filed) || [
+                                        'main'
+                                    ];
                                     config.optimization = {
-                                        ...config.optimization || {},
                                         moduleIds: 'named',
                                         chunkIds: 'named',
+                                        ...config.optimization || {},
                                         runtimeChunk: {
                                             name: 'runtime'
-                                        },
-                                        splitChunks: {
-                                            chunks: 'all',
-                                            minSize: 0,
-                                            maxInitialRequests: Number.POSITIVE_INFINITY
                                         }
                                     };
                                 }
                             },
                             plugins: [
                                 pluginIgnoreResolveError,
+                                pluginMockRuntime,
+                                pluginCSSFilter(),
                                 pluginEntryWatch({
                                     globTestSourceEntries,
                                     setupFiles,
@@ -185,9 +367,12 @@ export const __webpack_modules__ = {
                     }
                 }
             });
+            if (!isolate) rsbuildInstance.addPlugins([
+                pluginCacheControl(Object.values(setupFiles))
+            ]);
             return rsbuildInstance;
         };
-        const createRsbuildServer = async ({ name, globTestSourceEntries, setupFiles, rsbuildInstance })=>{
+        const createRsbuildServer = async ({ name, globTestSourceEntries, setupFiles, rsbuildInstance, normalizedConfig })=>{
             let rspackCompiler;
             const rstestCompilerPlugin = {
                 name: 'rstest:compiler',
@@ -204,7 +389,10 @@ export const __webpack_modules__ = {
                 getPortSilently: true
             });
             if ((0, utils.L1)()) await rsbuildInstance.inspectConfig({
-                writeToDisk: true
+                writeToDisk: true,
+                extraConfigs: {
+                    retest: normalizedConfig
+                }
             });
             const outputFileSystem = (isMultiCompiler(rspackCompiler) ? rspackCompiler.compilers[0].outputFileSystem : rspackCompiler.outputFileSystem) || external_node_fs_["default"];
             const getRsbuildStats = async ()=>{
@@ -397,8 +585,9 @@ export const __webpack_modules__ = {
                     ...execArgv,
                     '--experimental-vm-modules',
                     '--experimental-import-meta-resolve',
-                    '--no-warnings'
-                ],
+                    '--no-warnings',
+                    (0, utils.PA)() ? '--experimental-detect-module' : void 0
+                ].filter(Boolean),
                 env: {
                     NODE_ENV: 'test',
                     FORCE_COLOR: '1',
@@ -421,7 +610,8 @@ export const __webpack_modules__ = {
                 maxConcurrency,
                 printConsoleTrace,
                 disableConsoleIntercept,
-                testEnvironment
+                testEnvironment,
+                isolate
             };
             const rpcMethods = {
                 onTestCaseResult: async (result)=>{

package/dist/629.js

@@ -33,6 +33,7 @@ export const __webpack_modules__ = {
             const rsbuildInstance = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_2__.z)(context, globTestSourceEntries, setupFiles);
             const getRsbuildStats = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_2__.r)({
                 name,
+                normalizedConfig: context.normalizedConfig,
                 globTestSourceEntries,
                 setupFiles,
                 rsbuildInstance,

package/dist/{973.js → 723.js}

@@ -1,8 +1,8 @@
 export const __webpack_ids__ = [
-    "973"
+    "723"
 ];
 export const __webpack_modules__ = {
-    "../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.25/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+    "../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.29/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
             s7: ()=>TraceMap,
             Sk: ()=>originalPositionFor
@@ -212,7 +212,7 @@ export const __webpack_modules__ = {
             if (!path || addTrailingSlash && !path.endsWith('/..')) path += '/';
             url.path = path;
         }
-        function resolve(input, base) {
+        function resolve_uri_resolve(input, base) {
             if (!input && !base) return '';
             const url = parseUrl(input);
             let inputType = url.type;
@@ -255,20 +255,21 @@ export const __webpack_modules__ = {
                     return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
             }
         }
-        function trace_mapping_resolve(input, base) {
-            if (base && !base.endsWith('/')) base += '/';
-            return resolve(input, base);
-        }
         function stripFilename(path) {
-            if (!path) return '';
-            const index = path.lastIndexOf('/');
+            if (!path) return "";
+            const index = path.lastIndexOf("/");
             return path.slice(0, index + 1);
         }
-        const COLUMN = 0;
-        const SOURCES_INDEX = 1;
-        const SOURCE_LINE = 2;
-        const SOURCE_COLUMN = 3;
-        const NAMES_INDEX = 4;
+        function resolver(mapUrl, sourceRoot) {
+            const from = stripFilename(mapUrl);
+            const prefix = sourceRoot ? sourceRoot + "/" : "";
+            return (source)=>resolve_uri_resolve(prefix + (source || ""), from);
+        }
+        var COLUMN = 0;
+        var SOURCES_INDEX = 1;
+        var SOURCE_LINE = 2;
+        var SOURCE_COLUMN = 3;
+        var NAMES_INDEX = 4;
         function maybeSort(mappings, owned) {
             const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
             if (unsortedIndex === mappings.length) return mappings;
@@ -291,7 +292,7 @@ export const __webpack_modules__ = {
         function trace_mapping_sortComparator(a, b) {
             return a[COLUMN] - b[COLUMN];
         }
-        let found = false;
+        var found = false;
         function binarySearch(haystack, needle, low, high) {
             while(low <= high){
                 const mid = low + (high - low >> 1);
@@ -337,15 +338,18 @@ export const __webpack_modules__ = {
             state.lastNeedle = needle;
             return state.lastIndex = binarySearch(haystack, needle, low, high);
         }
-        const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
-        const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
-        const LEAST_UPPER_BOUND = -1;
-        const GREATEST_LOWER_BOUND = 1;
-        class TraceMap {
+        function parse(map) {
+            return "string" == typeof map ? JSON.parse(map) : map;
+        }
+        var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+        var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+        var LEAST_UPPER_BOUND = -1;
+        var GREATEST_LOWER_BOUND = 1;
+        var TraceMap = class {
             constructor(map, mapUrl){
-                const isString = 'string' == typeof map;
+                const isString = "string" == typeof map;
                 if (!isString && map._decodedMemo) return map;
-                const parsed = isString ? JSON.parse(map) : map;
+                const parsed = parse(map);
                 const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
                 this.version = version;
                 this.file = file;
@@ -354,21 +358,22 @@ export const __webpack_modules__ = {
                 this.sources = sources;
                 this.sourcesContent = sourcesContent;
                 this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
-                const from = trace_mapping_resolve(sourceRoot || '', stripFilename(mapUrl));
-                this.resolvedSources = sources.map((s)=>trace_mapping_resolve(s || '', from));
+                const resolve = resolver(mapUrl, sourceRoot);
+                this.resolvedSources = sources.map(resolve);
                 const { mappings } = parsed;
-                if ('string' == typeof mappings) {
+                if ("string" == typeof mappings) {
                     this._encoded = mappings;
                     this._decoded = void 0;
-                } else {
+                } else if (Array.isArray(mappings)) {
                     this._encoded = void 0;
                     this._decoded = maybeSort(mappings, isString);
-                }
+                } else if (parsed.sections) throw new Error("TraceMap passed sectioned source map, please use FlattenMap export instead");
+                else throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
                 this._decodedMemo = memoizedState();
                 this._bySources = void 0;
                 this._bySourceMemos = void 0;
             }
-        }
+        };
         function cast(map) {
             return map;
         }

package/dist/813.js

@@ -129,11 +129,11 @@ export const __webpack_modules__ = {
             $_: ()=>helper.$_,
             Yz: ()=>helper.Yz
         });
+        var constants = __webpack_require__("./src/utils/constants.ts");
         var helper = __webpack_require__("./src/utils/helper.ts");
         __webpack_require__("./src/utils/logger.ts");
         __webpack_require__("node:fs");
         __webpack_require__("node:fs/promises");
         __webpack_require__("pathe");
-        var constants = __webpack_require__("./src/utils/constants.ts");
     }
 };