@obsfx/trekker 0.1.7 → 0.1.8

package/webapp-dist/vendor/next/dist/build/webpack/loaders/next-swc-loader.js

@@ -0,0 +1,241 @@
+/*
+Copyright (c) 2017 The swc Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    pitch: null,
+    raw: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return swcLoader;
+    },
+    pitch: function() {
+        return pitch;
+    },
+    raw: function() {
+        return raw;
+    }
+});
+const _constants = require("../../../lib/constants");
+const _swc = require("../../swc");
+const _installbindings = require("../../swc/install-bindings");
+const _options = require("../../swc/options");
+const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+const _webpackconfig = require("../../webpack-config");
+const _handleexternals = require("../../handle-externals");
+const _updatetelemetryloadercontextfromswc = require("../plugins/telemetry-plugin/update-telemetry-loader-context-from-swc");
+const _constants1 = require("../../../shared/lib/constants");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const maybeExclude = (excludePath, transpilePackages)=>{
+    if (_webpackconfig.babelIncludeRegexes.some((r)=>r.test(excludePath))) {
+        return false;
+    }
+    const shouldBeBundled = (0, _handleexternals.isResourceInPackages)(excludePath, transpilePackages);
+    if (shouldBeBundled) return false;
+    return excludePath.includes('node_modules');
+};
+// these are exact code conditions checked
+// for to force transpiling a `node_module`
+const FORCE_TRANSPILE_CONDITIONS = /next\/font|next\/dynamic|use server|use client|use cache/;
+// same as above, but including `import(...)`.
+// (note the optional whitespace: `import  (...)` is also syntactically valid)
+const FORCE_TRANSPILE_CONDITIONS_WITH_IMPORT = new RegExp(String.raw`(?:${FORCE_TRANSPILE_CONDITIONS.source})|import\s*\(`);
+async function loaderTransform(source, inputSourceMap) {
+    var _nextConfig_experimental, _nextConfig_experimental1, _nextConfig_experimental2, _nextConfig_experimental3, _nextConfig_experimental4;
+    // Make the loader async
+    const filename = this.resourcePath;
+    // Ensure `.d.ts` are not processed.
+    if (filename.endsWith('.d.ts')) {
+        return [
+            source,
+            inputSourceMap
+        ];
+    }
+    let loaderOptions = this.getOptions() || {};
+    const shouldMaybeExclude = maybeExclude(filename, loaderOptions.transpilePackages || []);
+    const trackDynamicImports = shouldTrackDynamicImports(loaderOptions);
+    if (shouldMaybeExclude) {
+        if (!source) {
+            throw Object.defineProperty(new Error(`Invariant might be excluded but missing source`), "__NEXT_ERROR_CODE", {
+                value: "E368",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const forceTranspileConditions = trackDynamicImports ? FORCE_TRANSPILE_CONDITIONS_WITH_IMPORT : FORCE_TRANSPILE_CONDITIONS;
+        if (!forceTranspileConditions.test(source)) {
+            return [
+                source,
+                inputSourceMap
+            ];
+        }
+    }
+    const { isServer, rootDir, pagesDir, appDir, hasReactRefresh, nextConfig, jsConfig, supportedBrowsers, swcCacheDir, serverComponents, serverReferenceHashSalt, bundleLayer, esm } = loaderOptions;
+    const isPageFile = pagesDir ? filename.startsWith(pagesDir) : false;
+    const relativeFilePathFromRoot = _path.default.relative(rootDir, filename);
+    const swcOptions = (0, _options.getLoaderSWCOptions)({
+        pagesDir,
+        appDir,
+        filename,
+        isServer,
+        isPageFile,
+        development: this.mode === 'development' || !!((_nextConfig_experimental = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental.allowDevelopmentBuild),
+        isCacheComponents: nextConfig.cacheComponents,
+        hasReactRefresh,
+        modularizeImports: nextConfig == null ? void 0 : nextConfig.modularizeImports,
+        optimizePackageImports: nextConfig == null ? void 0 : (_nextConfig_experimental1 = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental1.optimizePackageImports,
+        swcPlugins: nextConfig == null ? void 0 : (_nextConfig_experimental2 = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental2.swcPlugins,
+        compilerOptions: nextConfig == null ? void 0 : nextConfig.compiler,
+        optimizeServerReact: nextConfig == null ? void 0 : (_nextConfig_experimental3 = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental3.optimizeServerReact,
+        jsConfig,
+        supportedBrowsers,
+        swcCacheDir,
+        relativeFilePathFromRoot,
+        serverComponents,
+        serverReferenceHashSalt,
+        bundleLayer,
+        esm,
+        cacheHandlers: nextConfig.cacheHandlers,
+        useCacheEnabled: (_nextConfig_experimental4 = nextConfig.experimental) == null ? void 0 : _nextConfig_experimental4.useCache,
+        trackDynamicImports
+    });
+    const programmaticOptions = {
+        ...swcOptions,
+        filename,
+        inputSourceMap: inputSourceMap ? JSON.stringify(inputSourceMap) : undefined,
+        // Set the default sourcemap behavior based on Webpack's mapping flag,
+        sourceMaps: this.sourceMap,
+        inlineSourcesContent: this.sourceMap,
+        // Ensure that Webpack will get a full absolute path in the sourcemap
+        // so that it can properly map the module back to its internal cached
+        // modules.
+        sourceFileName: filename
+    };
+    if (!programmaticOptions.inputSourceMap) {
+        delete programmaticOptions.inputSourceMap;
+    }
+    // auto detect development mode
+    if (this.mode && programmaticOptions.jsc && programmaticOptions.jsc.transform && programmaticOptions.jsc.transform.react && !Object.prototype.hasOwnProperty.call(programmaticOptions.jsc.transform.react, 'development')) {
+        programmaticOptions.jsc.transform.react.development = this.mode === 'development';
+    }
+    return (0, _swc.transform)(source, programmaticOptions).then((output)=>{
+        (0, _updatetelemetryloadercontextfromswc.updateTelemetryLoaderCtxFromTransformOutput)(this, output);
+        return [
+            output.code,
+            output.map ? JSON.parse(output.map) : undefined
+        ];
+    });
+}
+function shouldTrackDynamicImports(loaderOptions) {
+    // we only need to track `import()` 1. in cacheComponents, 2. on the server (RSC and SSR)
+    // (Note: logic duplicated in crates/next-core/src/next_server/transforms.rs)
+    const { nextConfig, bundleLayer, compilerType } = loaderOptions;
+    return !!nextConfig.cacheComponents && // NOTE: `server` means nodejs. `cacheComponents` is not supported in the edge runtime, so we want to exclude it.
+    // (also, the code generated by the dynamic imports transform relies on `CacheSignal`, which uses nodejs-specific APIs)
+    compilerType === _constants1.COMPILER_NAMES.server && (bundleLayer === _constants.WEBPACK_LAYERS.reactServerComponents || bundleLayer === _constants.WEBPACK_LAYERS.serverSideRendering);
+}
+const EXCLUDED_PATHS = /[\\/](cache[\\/][^\\/]+\.zip[\\/]node_modules|__virtual__)[\\/]/g;
+function pitch() {
+    const callback = this.async();
+    let loaderOptions = this.getOptions() || {};
+    const shouldMaybeExclude = maybeExclude(this.resourcePath, loaderOptions.transpilePackages || []);
+    (async ()=>{
+        if (// if it might be excluded/no-op we can't use pitch loader
+        !shouldMaybeExclude && // TODO: investigate swc file reading in PnP mode?
+        !process.versions.pnp && !EXCLUDED_PATHS.test(this.resourcePath) && this.loaders.length - 1 === this.loaderIndex && (0, _path.isAbsolute)(this.resourcePath) && !(0, _swc.getBindingsSync)().isWasm) {
+            this.addDependency(this.resourcePath);
+            return loaderTransform.call(this);
+        }
+    })().then((r)=>{
+        if (r) return callback(null, ...r);
+        callback();
+    }, callback);
+}
+function swcLoader(inputSource, inputSourceMap) {
+    const callback = this.async();
+    // Install bindings early so they are definitely available to the loader.
+    // When run by webpack in next this is already done with correct configuration so this is a no-op.
+    // In turbopack loaders are run in a subprocess so it may or may not be done.
+    (0, _installbindings.installBindings)().then(()=>loaderTransform.call(this, inputSource, inputSourceMap).then(([transformedSource, outputSourceMap])=>{
+            callback(null, transformedSource, outputSourceMap || inputSourceMap);
+        }, (err)=>{
+            callback(err);
+        }));
+}
+const raw = true;
+
+//# sourceMappingURL=next-swc-loader.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/postcss-loader/src/Error.js

@@ -0,0 +1,40 @@
+/**
+ * **PostCSS Syntax Error**
+ *
+ * Loader wrapper for postcss syntax errors
+ *
+ * @class SyntaxError
+ * @extends Error
+ *
+ * @param {Object} err CssSyntaxError
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return PostCSSSyntaxError;
+    }
+});
+class PostCSSSyntaxError extends Error {
+    constructor(error){
+        super(error);
+        const { line, column, reason, plugin, file } = error;
+        this.name = 'SyntaxError';
+        this.message = `${this.name}\n\n`;
+        if (typeof line !== 'undefined') {
+            this.message += `(${line}:${column}) `;
+        }
+        this.message += plugin ? `${plugin}: ` : '';
+        this.message += file ? `${file} ` : '<css input> ';
+        this.message += reason;
+        const code = error.showSourceCode();
+        if (code) {
+            this.message += `\n\n${code}\n`;
+        }
+        this.stack = false;
+    }
+}
+
+//# sourceMappingURL=Error.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/postcss-loader/src/Warning.js

@@ -0,0 +1,35 @@
+/**
+ * **PostCSS Plugin Warning**
+ *
+ * Loader wrapper for postcss plugin warnings (`root.messages`)
+ *
+ * @class Warning
+ * @extends Error
+ *
+ * @param {Object} warning PostCSS Warning
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Warning;
+    }
+});
+class Warning extends Error {
+    constructor(warning){
+        super(warning);
+        const { text, line, column, plugin } = warning;
+        this.name = 'Warning';
+        this.message = `${this.name}\n\n`;
+        if (typeof line !== 'undefined') {
+            this.message += `(${line}:${column}) `;
+        }
+        this.message += plugin ? `${plugin}: ` : '';
+        this.message += text;
+        this.stack = false;
+    }
+}
+
+//# sourceMappingURL=Warning.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/postcss-loader/src/index.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * **PostCSS Loader**
+ *
+ * Loads && processes CSS with [PostCSS](https://github.com/postcss/postcss)
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return loader;
+    }
+});
+const _Warning = /*#__PURE__*/ _interop_require_default(require("./Warning"));
+const _Error = /*#__PURE__*/ _interop_require_default(require("./Error"));
+const _utils = require("./utils");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function loader(/** Source */ content, /** Source Map */ sourceMap, meta) {
+    const loaderSpan = this.currentTraceSpan.traceChild('postcss-loader');
+    const callback = this.async();
+    loaderSpan.traceAsyncFn(async ()=>{
+        const options = this.getOptions();
+        const file = this.resourcePath;
+        const useSourceMap = typeof options.sourceMap !== 'undefined' ? options.sourceMap : this.sourceMap;
+        const processOptions = {
+            from: file,
+            to: file
+        };
+        if (useSourceMap) {
+            processOptions.map = {
+                inline: false,
+                annotation: false,
+                ...processOptions.map
+            };
+        }
+        if (sourceMap && processOptions.map) {
+            processOptions.map.prev = loaderSpan.traceChild('normalize-source-map').traceFn(()=>(0, _utils.normalizeSourceMap)(sourceMap, this.context));
+        }
+        let root;
+        // Reuse PostCSS AST from other loaders
+        if (meta && meta.ast && meta.ast.type === 'postcss') {
+            ;
+            ({ root } = meta.ast);
+            loaderSpan.setAttribute('astUsed', 'true');
+        }
+        // Initializes postcss with plugins
+        const { postcssWithPlugins } = await options.postcss();
+        let result;
+        try {
+            result = await loaderSpan.traceChild('postcss-process').traceAsyncFn(()=>postcssWithPlugins.process(root || content, processOptions));
+        } catch (error) {
+            if (error.file) {
+                this.addDependency(error.file);
+            }
+            if (error.name === 'CssSyntaxError') {
+                throw Object.defineProperty(new _Error.default(error), "__NEXT_ERROR_CODE", {
+                    value: "E394",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            throw error;
+        }
+        for (const warning of result.warnings()){
+            this.emitWarning(Object.defineProperty(new _Warning.default(warning), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            }));
+        }
+        for (const message of result.messages){
+            // eslint-disable-next-line default-case
+            switch(message.type){
+                case 'dependency':
+                    this.addDependency(message.file);
+                    break;
+                case 'build-dependency':
+                    this.addBuildDependency(message.file);
+                    break;
+                case 'missing-dependency':
+                    this.addMissingDependency(message.file);
+                    break;
+                case 'context-dependency':
+                    this.addContextDependency(message.file);
+                    break;
+                case 'dir-dependency':
+                    this.addContextDependency(message.dir);
+                    break;
+                case 'asset':
+                    if (message.content && message.file) {
+                        this.emitFile(message.file, message.content, message.sourceMap, message.info);
+                    }
+            }
+        }
+        let map = result.map ? result.map.toJSON() : undefined;
+        if (map && useSourceMap) {
+            map = (0, _utils.normalizeSourceMapAfterPostcss)(map, this.context);
+        }
+        const ast = {
+            type: 'postcss',
+            version: result.processor.version,
+            root: result.root
+        };
+        return [
+            result.css,
+            map,
+            {
+                ast
+            }
+        ];
+    }).then(([css, map, { ast }])=>{
+        callback == null ? void 0 : callback(null, css, map, {
+            ast
+        });
+    }, (err)=>{
+        callback == null ? void 0 : callback(err);
+    });
+}
+
+//# sourceMappingURL=index.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/postcss-loader/src/utils.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    normalizeSourceMap: null,
+    normalizeSourceMapAfterPostcss: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    normalizeSourceMap: function() {
+        return normalizeSourceMap;
+    },
+    normalizeSourceMapAfterPostcss: function() {
+        return normalizeSourceMapAfterPostcss;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const IS_NATIVE_WIN32_PATH = /^[a-z]:[/\\]|^\\\\/i;
+const ABSOLUTE_SCHEME = /^[a-z0-9+\-.]+:/i;
+function getURLType(source) {
+    if (source[0] === '/') {
+        if (source[1] === '/') {
+            return 'scheme-relative';
+        }
+        return 'path-absolute';
+    }
+    if (IS_NATIVE_WIN32_PATH.test(source)) {
+        return 'path-absolute';
+    }
+    return ABSOLUTE_SCHEME.test(source) ? 'absolute' : 'path-relative';
+}
+function normalizeSourceMap(map, resourceContext) {
+    let newMap = map;
+    // Some loader emit source map as string
+    // Strip any JSON XSSI avoidance prefix from the string (as documented in the source maps specification), and then parse the string as JSON.
+    if (typeof newMap === 'string') {
+        newMap = JSON.parse(newMap);
+    }
+    delete newMap.file;
+    const { sourceRoot } = newMap;
+    delete newMap.sourceRoot;
+    if (newMap.sources) {
+        newMap.sources = newMap.sources.map((source)=>{
+            const sourceType = getURLType(source);
+            // Do no touch `scheme-relative` and `absolute` URLs
+            if (sourceType === 'path-relative' || sourceType === 'path-absolute') {
+                const absoluteSource = sourceType === 'path-relative' && sourceRoot ? _path.default.resolve(sourceRoot, _path.default.normalize(source)) : _path.default.normalize(source);
+                return _path.default.relative(resourceContext, absoluteSource);
+            }
+            return source;
+        });
+    }
+    return newMap;
+}
+function normalizeSourceMapAfterPostcss(map, resourceContext) {
+    const newMap = map;
+    // result.map.file is an optional property that provides the output filename.
+    // Since we don't know the final filename in the webpack build chain yet, it makes no sense to have it.
+    delete newMap.file;
+    newMap.sourceRoot = '';
+    newMap.sources = newMap.sources.map((source)=>{
+        if (source.startsWith('<')) {
+            return source;
+        }
+        const sourceType = getURLType(source);
+        // Do no touch `scheme-relative`, `path-absolute` and `absolute` types
+        if (sourceType === 'path-relative') {
+            return _path.default.resolve(resourceContext, source);
+        }
+        return source;
+    });
+    return newMap;
+}
+
+//# sourceMappingURL=utils.js.map

package/webapp-dist/vendor/next/dist/build/webpack/loaders/resolve-url-loader/index.js

@@ -0,0 +1,101 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) 2016 Ben Holloway
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * A webpack loader that resolves absolute url() paths relative to their original source file.
+ * Requires source-maps to do any meaningful work.
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return resolveUrlLoader;
+    }
+});
+const _sourcemap = require("next/dist/compiled/source-map");
+const _valueprocessor = /*#__PURE__*/ _interop_require_default(require("./lib/value-processor"));
+const _joinfunction = require("./lib/join-function");
+const _postcss = /*#__PURE__*/ _interop_require_default(require("./lib/postcss"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function resolveUrlLoader(/** Css content */ content, /** The source-map */ sourceMap) {
+    const options = Object.assign({
+        sourceMap: this.sourceMap,
+        silent: false,
+        absolute: false,
+        keepQuery: false,
+        root: false,
+        debug: false,
+        join: _joinfunction.defaultJoin
+    }, this.getOptions());
+    let sourceMapConsumer;
+    if (sourceMap) {
+        sourceMapConsumer = new _sourcemap.SourceMapConsumer(sourceMap);
+    }
+    const callback = this.async();
+    const { postcss } = options.postcss ? await options.postcss() : {
+        postcss: require('postcss')
+    };
+    (0, _postcss.default)(postcss, this.resourcePath, content, {
+        outputSourceMap: Boolean(options.sourceMap),
+        transformDeclaration: (0, _valueprocessor.default)(this.resourcePath, options),
+        inputSourceMap: sourceMap,
+        sourceMapConsumer: sourceMapConsumer
+    }).catch(onFailure).then(onSuccess);
+    function onFailure(error) {
+        callback(encodeError('CSS error', error));
+    }
+    function onSuccess(reworked) {
+        if (reworked) {
+            // complete with source-map
+            //  source-map sources are relative to the file being processed
+            if (options.sourceMap) {
+                callback(null, reworked.content, reworked.map);
+            } else {
+                callback(null, reworked.content);
+            }
+        }
+    }
+    function encodeError(label, exception) {
+        return Object.defineProperty(new Error([
+            'resolve-url-loader',
+            ': ',
+            [
+                label
+            ].concat(typeof exception === 'string' && exception || exception instanceof Error && [
+                exception.message,
+                exception.stack.split('\n', 2)[1].trim()
+            ] || []).filter(Boolean).join('\n  ')
+        ].join('')), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+
+//# sourceMappingURL=index.js.map