@obsfx/trekker 0.1.7 → 0.1.8

package/webapp-dist/vendor/next/dist/build/webpack/plugins/wellknown-errors-plugin/getModuleTrace.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    formatModuleTrace: null,
+    getModuleTrace: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    formatModuleTrace: function() {
+        return formatModuleTrace;
+    },
+    getModuleTrace: function() {
+        return getModuleTrace;
+    }
+});
+const _loaderutils3 = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/loader-utils3"));
+const _path = require("path");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function formatModule(compiler, module1) {
+    const relativePath = (0, _path.relative)(compiler.context, module1.resource).replace(/\?.+$/, '');
+    return _loaderutils3.default.isUrlRequest(relativePath) ? _loaderutils3.default.urlToRequest(relativePath) : relativePath;
+}
+function formatModuleTrace(compiler, moduleTrace) {
+    let importTrace = [];
+    let firstExternalModule;
+    for(let i = moduleTrace.length - 1; i >= 0; i--){
+        const mod = moduleTrace[i];
+        if (!mod.resource) continue;
+        if (!mod.resource.includes('node_modules/')) {
+            importTrace.unshift(formatModule(compiler, mod));
+        } else {
+            firstExternalModule = mod;
+            break;
+        }
+    }
+    let invalidImportMessage = '';
+    if (firstExternalModule) {
+        var _firstExternalModule_resourceResolveData_descriptionFileData, _firstExternalModule_resourceResolveData;
+        const firstExternalPackageName = (_firstExternalModule_resourceResolveData = firstExternalModule.resourceResolveData) == null ? void 0 : (_firstExternalModule_resourceResolveData_descriptionFileData = _firstExternalModule_resourceResolveData.descriptionFileData) == null ? void 0 : _firstExternalModule_resourceResolveData_descriptionFileData.name;
+        if (firstExternalPackageName === 'styled-jsx') {
+            invalidImportMessage += `\n\nThe error was caused by using 'styled-jsx' in '${importTrace[0]}'. It only works in a Client Component but none of its parents are marked with "use client", so they're Server Components by default.`;
+        } else {
+            let formattedExternalFile = firstExternalModule.resource.split('node_modules');
+            formattedExternalFile = formattedExternalFile[formattedExternalFile.length - 1];
+            invalidImportMessage += `\n\nThe error was caused by importing '${formattedExternalFile.slice(1)}' in '${importTrace[0]}'.`;
+        }
+    }
+    return {
+        lastInternalFileName: importTrace[0],
+        invalidImportMessage,
+        formattedModuleTrace: importTrace.map((mod)=>'  ' + mod).join('\n')
+    };
+}
+function getModuleTrace(module1, compilation, compiler) {
+    // Get the module trace:
+    // https://cs.github.com/webpack/webpack/blob/9fcaa243573005d6fdece9a3f8d89a0e8b399613/lib/stats/DefaultStatsFactoryPlugin.js#L414
+    const visitedModules = new Set();
+    const moduleTrace = [];
+    let current = module1;
+    let isPagesDir = false;
+    while(current){
+        if (visitedModules.has(current)) break;
+        if (/[\\/]pages/.test(current.resource.replace(compiler.context, ''))) {
+            isPagesDir = true;
+        }
+        visitedModules.add(current);
+        moduleTrace.push(current);
+        const origin = compilation.moduleGraph.getIssuer(current);
+        if (!origin) break;
+        current = origin;
+    }
+    return {
+        moduleTrace,
+        isPagesDir
+    };
+}
+
+//# sourceMappingURL=getModuleTrace.js.map

package/webapp-dist/vendor/next/dist/build/webpack/plugins/wellknown-errors-plugin/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WellKnownErrorsPlugin", {
+    enumerable: true,
+    get: function() {
+        return WellKnownErrorsPlugin;
+    }
+});
+const _webpackModuleError = require("./webpackModuleError");
+const NAME = 'WellKnownErrorsPlugin';
+class WellKnownErrorsPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(NAME, (compilation)=>{
+            compilation.hooks.afterSeal.tapPromise(NAME, async ()=>{
+                var _compilation_warnings, _compilation_errors;
+                if ((_compilation_warnings = compilation.warnings) == null ? void 0 : _compilation_warnings.length) {
+                    await Promise.all(compilation.warnings.map(async (warn, i)=>{
+                        var _warn_module_context, _warn_module;
+                        if (warn.name === 'ModuleDependencyWarning' && ((_warn_module = warn.module) == null ? void 0 : (_warn_module_context = _warn_module.context) == null ? void 0 : _warn_module_context.includes('node_modules'))) {
+                            compilation.warnings.splice(i, 1);
+                        }
+                    }));
+                }
+                if ((_compilation_errors = compilation.errors) == null ? void 0 : _compilation_errors.length) {
+                    await Promise.all(compilation.errors.map(async (err, i)=>{
+                        try {
+                            const moduleError = await (0, _webpackModuleError.getModuleBuildError)(compiler, compilation, err);
+                            if (moduleError !== false) {
+                                compilation.errors[i] = moduleError;
+                            }
+                        } catch (e) {
+                            console.log(e);
+                        }
+                    }));
+                }
+            });
+        });
+    }
+}
+
+//# sourceMappingURL=index.js.map

package/webapp-dist/vendor/next/dist/build/webpack/plugins/wellknown-errors-plugin/parse-dynamic-code-evaluation-error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getDynamicCodeEvaluationError", {
+    enumerable: true,
+    get: function() {
+        return getDynamicCodeEvaluationError;
+    }
+});
+const _getModuleTrace = require("./getModuleTrace");
+const _simpleWebpackError = require("./simpleWebpackError");
+function getDynamicCodeEvaluationError(message, module, compilation, compiler) {
+    const { moduleTrace } = (0, _getModuleTrace.getModuleTrace)(module, compilation, compiler);
+    const { formattedModuleTrace, lastInternalFileName, invalidImportMessage } = (0, _getModuleTrace.formatModuleTrace)(compiler, moduleTrace);
+    return new _simpleWebpackError.SimpleWebpackError(lastInternalFileName, message + invalidImportMessage + '\n\nImport trace for requested module:\n' + formattedModuleTrace);
+}
+
+//# sourceMappingURL=parse-dynamic-code-evaluation-error.js.map

package/webapp-dist/vendor/next/dist/build/webpack/plugins/wellknown-errors-plugin/parseBabel.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getBabelError", {
+    enumerable: true,
+    get: function() {
+        return getBabelError;
+    }
+});
+const _picocolors = require("../../../../lib/picocolors");
+const _simpleWebpackError = require("./simpleWebpackError");
+function getBabelError(fileName, err) {
+    if (err.code !== 'BABEL_PARSE_ERROR') {
+        return false;
+    }
+    // https://github.com/babel/babel/blob/34693d6024da3f026534dd8d569f97ac0109602e/packages/babel-core/src/parser/index.js
+    if (err.loc) {
+        const lineNumber = Math.max(1, err.loc.line);
+        const column = Math.max(1, err.loc.column);
+        let message = err.message// Remove file information, which instead is provided by webpack.
+        .replace(/^.+?: /, '')// Remove column information from message
+        .replace(new RegExp(`[^\\S\\r\\n]*\\(${lineNumber}:${column}\\)[^\\S\\r\\n]*`), '');
+        return new _simpleWebpackError.SimpleWebpackError(`${(0, _picocolors.cyan)(fileName)}:${(0, _picocolors.yellow)(lineNumber.toString())}:${(0, _picocolors.yellow)(column.toString())}`, (0, _picocolors.red)((0, _picocolors.bold)('Syntax error')).concat(`: ${message}`));
+    }
+    return false;
+}
+
+//# sourceMappingURL=parseBabel.js.map

package/webapp-dist/vendor/next/dist/build/webpack/plugins/wellknown-errors-plugin/parseCss.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getCssError", {
+    enumerable: true,
+    get: function() {
+        return getCssError;
+    }
+});
+const _picocolors = require("../../../../lib/picocolors");
+const _simpleWebpackError = require("./simpleWebpackError");
+const regexCssError = /^(?:CssSyntaxError|SyntaxError)\n\n\((\d+):(\d*)\) (.*)$/s;
+function getCssError(fileName, err) {
+    if (!((err.name === 'CssSyntaxError' || err.name === 'SyntaxError') && err.stack === false && !(err instanceof SyntaxError))) {
+        return false;
+    }
+    // https://github.com/postcss/postcss-loader/blob/d6931da177ac79707bd758436e476036a55e4f59/src/Error.js
+    const res = regexCssError.exec(err.message);
+    if (res) {
+        const [, _lineNumber, _column, reason] = res;
+        const lineNumber = Math.max(1, parseInt(_lineNumber, 10));
+        const column = Math.max(1, parseInt(_column, 10));
+        return new _simpleWebpackError.SimpleWebpackError(`${(0, _picocolors.cyan)(fileName)}:${(0, _picocolors.yellow)(lineNumber.toString())}:${(0, _picocolors.yellow)(column.toString())}`, (0, _picocolors.red)((0, _picocolors.bold)('Syntax error')).concat(`: ${reason}`));
+    }
+    return false;
+}
+
+//# sourceMappingURL=parseCss.js.map

package/webapp-dist/vendor/next/dist/build/webpack/plugins/wellknown-errors-plugin/parseNextAppLoaderError.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getNextAppLoaderError", {
+    enumerable: true,
+    get: function() {
+        return getNextAppLoaderError;
+    }
+});
+const _path = require("path");
+const _simpleWebpackError = require("./simpleWebpackError");
+const _entries = require("../../../entries");
+function getNextAppLoaderError(err, module, compiler) {
+    try {
+        if (!module.loaders[0].loader.includes((0, _entries.getAppLoader)())) {
+            return false;
+        }
+        const file = (0, _path.relative)(compiler.context, module.buildInfo.route.absolutePagePath);
+        return new _simpleWebpackError.SimpleWebpackError(file, err.message);
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=parseNextAppLoaderError.js.map

package/webapp-dist/vendor/next/dist/build/webpack/plugins/wellknown-errors-plugin/parseNextFontError.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getNextFontError", {
+    enumerable: true,
+    get: function() {
+        return getNextFontError;
+    }
+});
+const _simpleWebpackError = require("./simpleWebpackError");
+function getNextFontError(err, module) {
+    try {
+        const resourceResolveData = module.resourceResolveData;
+        if (!module.loaders.find((loader)=>/next-font-loader[/\\]index.js/.test(loader.loader))) {
+            return false;
+        }
+        // Parse the query and get the path of the file where the font function was called.
+        // provided by next-swc next-transform-font
+        const file = JSON.parse(resourceResolveData.query.slice(1)).path;
+        if (err.name === 'NextFontError') {
+            // Known error thrown by @next/font, display the error message
+            return new _simpleWebpackError.SimpleWebpackError(file, `\`next/font\` error:\n${err.message}`);
+        } else {
+            // Unknown error thrown by @next/font
+            return new _simpleWebpackError.SimpleWebpackError(file, `An error occurred in \`next/font\`.\n\n${err.stack}`);
+        }
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=parseNextFontError.js.map

package/webapp-dist/vendor/next/dist/build/webpack/plugins/wellknown-errors-plugin/parseNextInvalidImportError.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getNextInvalidImportError", {
+    enumerable: true,
+    get: function() {
+        return getNextInvalidImportError;
+    }
+});
+const _getModuleTrace = require("./getModuleTrace");
+const _simpleWebpackError = require("./simpleWebpackError");
+function getNextInvalidImportError(err, module, compilation, compiler) {
+    try {
+        if (!module.loaders.find((loader)=>loader.loader.includes('next-invalid-import-error-loader.js'))) {
+            return false;
+        }
+        const { moduleTrace } = (0, _getModuleTrace.getModuleTrace)(module, compilation, compiler);
+        const { formattedModuleTrace, lastInternalFileName, invalidImportMessage } = (0, _getModuleTrace.formatModuleTrace)(compiler, moduleTrace);
+        return new _simpleWebpackError.SimpleWebpackError(lastInternalFileName, err.message + invalidImportMessage + '\n\nImport trace for requested module:\n' + formattedModuleTrace);
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=parseNextInvalidImportError.js.map

package/webapp-dist/vendor/next/dist/build/webpack/plugins/wellknown-errors-plugin/parseNotFoundError.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getImageError: null,
+    getNotFoundError: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getImageError: function() {
+        return getImageError;
+    },
+    getNotFoundError: function() {
+        return getNotFoundError;
+    }
+});
+const _picocolors = require("../../../../lib/picocolors");
+const _simpleWebpackError = require("./simpleWebpackError");
+const _middlewarewebpack = require("../../../../server/dev/middleware-webpack");
+// Based on https://github.com/webpack/webpack/blob/fcdd04a833943394bbb0a9eeb54a962a24cc7e41/lib/stats/DefaultStatsFactoryPlugin.js#L422-L431
+/*
+Copyright JS Foundation and other contributors
+
+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.
+
+*/ function getModuleTrace(input, compilation) {
+    const visitedModules = new Set();
+    const moduleTrace = [];
+    let current = input.module;
+    while(current){
+        if (visitedModules.has(current)) break; // circular (technically impossible, but who knows)
+        visitedModules.add(current);
+        const origin = compilation.moduleGraph.getIssuer(current);
+        if (!origin) break;
+        moduleTrace.push({
+            origin,
+            module: current
+        });
+        current = origin;
+    }
+    return moduleTrace;
+}
+function sourceMapIgnoreListsEverything(sourceMap) {
+    var _sourceMap_ignoreList;
+    return sourceMap.sources.length === ((_sourceMap_ignoreList = sourceMap.ignoreList) == null ? void 0 : _sourceMap_ignoreList.length);
+}
+async function getSourceFrame(input, fileName, compilation) {
+    try {
+        const loc = input.loc || input.dependencies.map((d)=>d.loc).filter(Boolean)[0];
+        const module1 = input.module;
+        const originalSource = module1.originalSource();
+        const sourceMap = (originalSource == null ? void 0 : originalSource.map()) ?? undefined;
+        if (sourceMap) {
+            var _result_originalStackFrame_line1, _result_originalStackFrame, _result_originalStackFrame_column1, _result_originalStackFrame1;
+            const moduleId = compilation.chunkGraph.getModuleId(module1);
+            const result = await (0, _middlewarewebpack.createOriginalStackFrame)({
+                ignoredByDefault: sourceMapIgnoreListsEverything(sourceMap),
+                source: {
+                    type: 'bundle',
+                    sourceMap,
+                    ignoredSources: (0, _middlewarewebpack.getIgnoredSources)(sourceMap),
+                    compilation,
+                    moduleId,
+                    moduleURL: fileName
+                },
+                rootDirectory: compilation.options.context,
+                frame: {
+                    arguments: [],
+                    file: fileName,
+                    methodName: '',
+                    line1: loc.start.line,
+                    // loc is 0-based but columns in stack frames are 1-based.
+                    column1: (loc.start.column ?? 0) + 1
+                }
+            });
+            return {
+                frame: (result == null ? void 0 : result.originalCodeFrame) ?? '',
+                line1: (result == null ? void 0 : (_result_originalStackFrame = result.originalStackFrame) == null ? void 0 : (_result_originalStackFrame_line1 = _result_originalStackFrame.line1) == null ? void 0 : _result_originalStackFrame_line1.toString()) ?? '',
+                column1: (result == null ? void 0 : (_result_originalStackFrame1 = result.originalStackFrame) == null ? void 0 : (_result_originalStackFrame_column1 = _result_originalStackFrame1.column1) == null ? void 0 : _result_originalStackFrame_column1.toString()) ?? ''
+            };
+        }
+    } catch  {}
+    return {
+        frame: '',
+        line1: '',
+        column1: ''
+    };
+}
+function getFormattedFileName(fileName, module1, lineNumber, column) {
+    var _module_loaders;
+    if ((_module_loaders = module1.loaders) == null ? void 0 : _module_loaders.find((loader)=>/next-font-loader[/\\]index.js/.test(loader.loader))) {
+        // Parse the query and get the path of the file where the font function was called.
+        // provided by next-swc next-transform-font
+        return JSON.parse(module1.resourceResolveData.query.slice(1)).path;
+    } else {
+        let formattedFileName = (0, _picocolors.cyan)(fileName);
+        if (lineNumber && column) {
+            formattedFileName += `:${(0, _picocolors.yellow)(lineNumber)}:${(0, _picocolors.yellow)(column)}`;
+        }
+        return formattedFileName;
+    }
+}
+async function getNotFoundError(compilation, input, fileName, module1) {
+    if (input.name !== 'ModuleNotFoundError' && !(input.name === 'ModuleBuildError' && /Error: Can't resolve '.+' in /.test(input.message))) {
+        return false;
+    }
+    try {
+        const { frame, line1, column1 } = await getSourceFrame(input, fileName, compilation);
+        const errorMessage = input.error.message.replace(/ in '.*?'/, '').replace(/Can't resolve '(.*)'/, `Can't resolve '${(0, _picocolors.green)('$1')}'`);
+        const importTrace = ()=>{
+            const moduleTrace = getModuleTrace(input, compilation).map(({ origin })=>origin.readableIdentifier(compilation.requestShortener)).filter((name)=>name && !/next-(app|middleware|client-pages|route|flight-(client|server|client-entry))-loader/.test(name) && !/css-loader.+\.js/.test(name));
+            if (moduleTrace.length === 0) return '';
+            return `\nImport trace for requested module:\n${moduleTrace.join('\n')}`;
+        };
+        let message = (0, _picocolors.red)((0, _picocolors.bold)('Module not found')) + `: ${errorMessage}` + '\n' + frame + (frame !== '' ? '\n' : '') + '\nhttps://nextjs.org/docs/messages/module-not-found\n' + importTrace();
+        const formattedFileName = getFormattedFileName(fileName, module1, line1, column1);
+        return new _simpleWebpackError.SimpleWebpackError(formattedFileName, message);
+    } catch (err) {
+        // Don't fail on failure to resolve sourcemaps
+        return input;
+    }
+}
+async function getImageError(compilation, input, err) {
+    if (err.name !== 'InvalidImageFormatError') {
+        return false;
+    }
+    const moduleTrace = getModuleTrace(input, compilation);
+    const { origin, module: module1 } = moduleTrace[0] || {};
+    if (!origin || !module1) {
+        return false;
+    }
+    const page = origin.rawRequest.replace(/^private-next-pages/, './pages');
+    const importedFile = module1.rawRequest;
+    const source = origin.originalSource().buffer().toString('utf8');
+    let lineNumber = -1;
+    source.split('\n').some((line)=>{
+        lineNumber++;
+        return line.includes(importedFile);
+    });
+    return new _simpleWebpackError.SimpleWebpackError(`${(0, _picocolors.cyan)(page)}:${(0, _picocolors.yellow)(lineNumber.toString())}`, (0, _picocolors.red)((0, _picocolors.bold)('Error')).concat(`: Image import "${importedFile}" is not a valid image file. The image may be corrupted or an unsupported format.`));
+}
+
+//# sourceMappingURL=parseNotFoundError.js.map

package/webapp-dist/vendor/next/dist/build/webpack/plugins/wellknown-errors-plugin/parseScss.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getScssError", {
+    enumerable: true,
+    get: function() {
+        return getScssError;
+    }
+});
+const _picocolors = require("../../../../lib/picocolors");
+const _simpleWebpackError = require("./simpleWebpackError");
+const regexScssError = /SassError: (.+)\n\s+on line (\d+) [\s\S]*?>> (.+)\n\s*(-+)\^$/m;
+function getScssError(fileName, fileContent, err) {
+    if (err.name !== 'SassError') {
+        return false;
+    }
+    const res = regexScssError.exec(err.message);
+    if (res) {
+        const [, reason, _lineNumer, backupFrame, columnString] = res;
+        const lineNumber = Math.max(1, parseInt(_lineNumer, 10));
+        const column = (columnString == null ? void 0 : columnString.length) ?? 1;
+        let frame;
+        if (fileContent) {
+            try {
+                const { codeFrameColumns } = require('next/dist/compiled/babel/code-frame');
+                frame = codeFrameColumns(fileContent, {
+                    start: {
+                        line: lineNumber,
+                        column
+                    }
+                }, {
+                    forceColor: true
+                });
+            } catch  {}
+        }
+        return new _simpleWebpackError.SimpleWebpackError(`${(0, _picocolors.cyan)(fileName)}:${(0, _picocolors.yellow)(lineNumber.toString())}:${(0, _picocolors.yellow)(column.toString())}`, (0, _picocolors.red)((0, _picocolors.bold)('Syntax error')).concat(`: ${reason}\n\n${frame ?? backupFrame}`));
+    }
+    return false;
+}
+
+//# sourceMappingURL=parseScss.js.map

package/webapp-dist/vendor/next/dist/build/webpack/plugins/wellknown-errors-plugin/simpleWebpackError.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SimpleWebpackError", {
+    enumerable: true,
+    get: function() {
+        return SimpleWebpackError;
+    }
+});
+class SimpleWebpackError extends Error {
+    constructor(file, message){
+        super(message);
+        this.file = file;
+    }
+}
+
+//# sourceMappingURL=simpleWebpackError.js.map

package/webapp-dist/vendor/next/dist/build/webpack/plugins/wellknown-errors-plugin/webpackModuleError.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getModuleBuildError", {
+    enumerable: true,
+    get: function() {
+        return getModuleBuildError;
+    }
+});
+const _fs = require("fs");
+const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+const _parseBabel = require("./parseBabel");
+const _parseCss = require("./parseCss");
+const _parseScss = require("./parseScss");
+const _parseNotFoundError = require("./parseNotFoundError");
+const _iserror = /*#__PURE__*/ _interop_require_default(require("../../../../lib/is-error"));
+const _parseNextFontError = require("./parseNextFontError");
+const _parseNextAppLoaderError = require("./parseNextAppLoaderError");
+const _parseNextInvalidImportError = require("./parseNextInvalidImportError");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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;
+}
+function getFileData(compilation, m) {
+    var _compilation_compiler;
+    let resolved;
+    let ctx = ((_compilation_compiler = compilation.compiler) == null ? void 0 : _compilation_compiler.context) ?? null;
+    if (ctx !== null && typeof m.resource === 'string') {
+        const res = _path.relative(ctx, m.resource).replace(/\\/g, _path.posix.sep);
+        resolved = res.startsWith('.') ? res : `.${_path.posix.sep}${res}`;
+    } else {
+        const requestShortener = compilation.requestShortener;
+        if (typeof (m == null ? void 0 : m.readableIdentifier) === 'function') {
+            resolved = m.readableIdentifier(requestShortener);
+        } else {
+            resolved = m.request ?? m.userRequest;
+        }
+    }
+    if (resolved) {
+        let content = null;
+        try {
+            content = (0, _fs.readFileSync)(ctx ? _path.resolve(ctx, resolved) : resolved, 'utf8');
+        } catch  {}
+        return [
+            resolved,
+            content
+        ];
+    }
+    return [
+        '<unknown>',
+        null
+    ];
+}
+async function getModuleBuildError(compiler, compilation, input) {
+    if (!(typeof input === 'object' && ((input == null ? void 0 : input.name) === 'ModuleBuildError' || (input == null ? void 0 : input.name) === 'ModuleNotFoundError') && Boolean(input.module) && (0, _iserror.default)(input.error))) {
+        return false;
+    }
+    const err = input.error;
+    const [sourceFilename, sourceContent] = getFileData(compilation, input.module);
+    const notFoundError = await (0, _parseNotFoundError.getNotFoundError)(compilation, input, sourceFilename, input.module);
+    if (notFoundError !== false) {
+        return notFoundError;
+    }
+    const imageError = await (0, _parseNotFoundError.getImageError)(compilation, input, err);
+    if (imageError !== false) {
+        return imageError;
+    }
+    const babel = (0, _parseBabel.getBabelError)(sourceFilename, err);
+    if (babel !== false) {
+        return babel;
+    }
+    const css = (0, _parseCss.getCssError)(sourceFilename, err);
+    if (css !== false) {
+        return css;
+    }
+    const scss = (0, _parseScss.getScssError)(sourceFilename, sourceContent, err);
+    if (scss !== false) {
+        return scss;
+    }
+    const nextFont = (0, _parseNextFontError.getNextFontError)(err, input.module);
+    if (nextFont !== false) {
+        return nextFont;
+    }
+    const nextAppLoader = (0, _parseNextAppLoaderError.getNextAppLoaderError)(err, input.module, compiler);
+    if (nextAppLoader !== false) {
+        return nextAppLoader;
+    }
+    const invalidImportError = (0, _parseNextInvalidImportError.getNextInvalidImportError)(err, input.module, compilation, compiler);
+    if (invalidImportError !== false) {
+        return invalidImportError;
+    }
+    return false;
+}
+
+//# sourceMappingURL=webpackModuleError.js.map