@obsfx/trekker 0.1.7 → 0.1.8

package/webapp-dist/vendor/next/dist/lib/turbopack-warning.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "validateTurboNextConfig", {
+    enumerable: true,
+    get: function() {
+        return validateTurboNextConfig;
+    }
+});
+const _config = /*#__PURE__*/ _interop_require_default(require("../server/config"));
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
+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;
+}
+const unsupportedTurbopackNextConfigOptions = [
+    // Left to be implemented (priority)
+    // 'experimental.clientRouterFilter',
+    // 'experimental.optimizePackageImports',
+    // 'compiler.emotion',
+    // 'compiler.reactRemoveProperties',
+    // 'compiler.relay',
+    // 'compiler.removeConsole',
+    // 'compiler.styledComponents',
+    'experimental.fetchCacheKeyPrefix',
+    // Left to be implemented
+    // 'excludeDefaultMomentLocales',
+    // 'experimental.optimizeServerReact',
+    'experimental.clientRouterFilterAllowedRate',
+    // 'experimental.serverMinification',
+    // 'experimental.serverSourceMaps',
+    'experimental.allowedRevalidateHeaderKeys',
+    'experimental.extensionAlias',
+    'experimental.fallbackNodePolyfills',
+    'experimental.sri.algorithm',
+    'experimental.swcTraceProfiling',
+    // Left to be implemented (Might not be needed for Turbopack)
+    'experimental.craCompat',
+    'experimental.disablePostcssPresetEnv',
+    'experimental.esmExternals',
+    // This is used to force swc-loader to run regardless of finding Babel.
+    'experimental.forceSwcTransforms',
+    'experimental.fullySpecified',
+    'experimental.urlImports',
+    'experimental.slowModuleDetection'
+];
+async function validateTurboNextConfig({ dir, configPhase }) {
+    const { defaultConfig } = require('../server/config-shared');
+    const { cyan, red, underline } = require('../lib/picocolors');
+    const { interopDefault } = require('../lib/interop-default');
+    let unsupportedParts = '';
+    let hasWebpackConfig = false;
+    let hasTurboConfig = false;
+    const unsupportedConfig = [];
+    let rawNextConfig = {};
+    try {
+        rawNextConfig = interopDefault(await (0, _config.default)(configPhase, dir, {
+            rawConfig: true
+        }));
+        if (typeof rawNextConfig === 'function') {
+            rawNextConfig = rawNextConfig(configPhase, {
+                defaultConfig
+            });
+        }
+        hasWebpackConfig = Boolean(rawNextConfig.webpack);
+        hasTurboConfig = Boolean(rawNextConfig.turbopack);
+        const flattenKeys = (obj, prefix = '')=>{
+            let keys = [];
+            for(const key in obj){
+                const value = obj == null ? void 0 : obj[key];
+                if (typeof value === 'undefined') {
+                    continue;
+                }
+                const pre = prefix.length ? `${prefix}.` : '';
+                if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
+                    keys = keys.concat(flattenKeys(value, pre + key));
+                } else {
+                    keys.push(pre + key);
+                }
+            }
+            return keys;
+        };
+        const getDeepValue = (obj, keys)=>{
+            if (typeof keys === 'string') {
+                keys = keys.split('.');
+            }
+            if (keys.length === 1) {
+                return obj == null ? void 0 : obj[keys == null ? void 0 : keys[0]];
+            }
+            return getDeepValue(obj == null ? void 0 : obj[keys == null ? void 0 : keys[0]], keys.slice(1));
+        };
+        const customKeys = flattenKeys(rawNextConfig);
+        for (const key of customKeys){
+            if (key.startsWith('experimental.turbo')) {
+                hasTurboConfig = true;
+            }
+            const isUnsupported = unsupportedTurbopackNextConfigOptions.some((unsupportedKey)=>// Either the key matches (or is a more specific subkey) of
+                // unsupportedKey, or the key is the path to a specific subkey.
+                // | key     | unsupportedKey |
+                // |---------|----------------|
+                // | foo     | foo            |
+                // | foo.bar | foo            |
+                // | foo     | foo.bar        |
+                key.startsWith(unsupportedKey) || unsupportedKey.startsWith(`${key}.`)) && getDeepValue(rawNextConfig, key) !== getDeepValue(defaultConfig, key);
+            if (isUnsupported) {
+                unsupportedConfig.push(key);
+            }
+        }
+    } catch (e) {
+        _log.error('Unexpected error occurred while checking config', e);
+    }
+    // If the build was defaulted to Turbopack, we want to warn about possibly ignored webpack
+    // configuration. Otherwise the user explicitly picked turbopack and thus we expect that
+    // they have configured it correctly.
+    if (process.env.TURBOPACK === 'auto' && hasWebpackConfig && !hasTurboConfig) {
+        const configFile = rawNextConfig.configFileName ?? 'your Next config file';
+        _log.error(`ERROR: This build is using Turbopack, with a \`webpack\` config and no \`turbopack\` config.
+   This may be a mistake.
+
+   As of Next.js 16 Turbopack is enabled by default and
+   custom webpack configurations may need to be migrated to Turbopack.
+
+   NOTE: your \`webpack\` config may have been added by a configuration plugin.
+
+   To configure Turbopack, see https://nextjs.org/docs/app/api-reference/next-config-js/turbopack
+
+   TIP: Many applications work fine under Turbopack with no configuration,
+   if that is the case for you, you can silence this error by passing the
+   \`--turbopack\` or \`--webpack\` flag explicitly or simply setting an 
+   empty turbopack config in ${configFile} (e.g. \`turbopack: {}\`).`);
+        process.exit(1);
+    }
+    if (unsupportedConfig.length) {
+        unsupportedParts += `\n\n- Unsupported Next.js configuration option(s) (${cyan('next.config.js')})\n  Turbopack will ignore the following configuration options:\n${unsupportedConfig.map((name)=>`    - ${red(name)}\n`).join('')}`;
+    }
+    if (unsupportedParts) {
+        _log.error(`You are using configuration and/or tools that are not yet\nsupported by Next.js with Turbopack:\n${unsupportedParts}\n`);
+        _log.warn('Learn more about how to configure Turbopack with Next.js:\n' + underline('https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack'));
+    }
+    return rawNextConfig;
+}
+
+//# sourceMappingURL=turbopack-warning.js.map

package/webapp-dist/vendor/next/dist/lib/typescript/diagnosticFormatter.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getFormattedDiagnostic", {
+    enumerable: true,
+    get: function() {
+        return getFormattedDiagnostic;
+    }
+});
+const _picocolors = require("../picocolors");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getFormattedLinkDiagnosticMessageText(diagnostic) {
+    const message = diagnostic.messageText;
+    if (typeof message === 'string' && diagnostic.code === 2322) {
+        const match = message.match(/Type '"(.+)"' is not assignable to type 'RouteImpl<.+> \| UrlObject'\./) || message.match(/Type '"(.+)"' is not assignable to type 'UrlObject \| RouteImpl<.+>'\./);
+        if (match) {
+            const [, href] = match;
+            return `"${(0, _picocolors.bold)(href)}" is not an existing route. If it is intentional, please type it explicitly with \`as Route\`.`;
+        } else if (message === "Type 'string' is not assignable to type 'UrlObject'.") {
+            var _diagnostic_relatedInformation_, _diagnostic_relatedInformation;
+            const relatedMessage = (_diagnostic_relatedInformation = diagnostic.relatedInformation) == null ? void 0 : (_diagnostic_relatedInformation_ = _diagnostic_relatedInformation[0]) == null ? void 0 : _diagnostic_relatedInformation_.messageText;
+            if (typeof relatedMessage === 'string' && relatedMessage.match(/The expected type comes from property 'href' which is declared here on type 'IntrinsicAttributes & /)) {
+                return `Invalid \`href\` property of \`Link\`: the route does not exist. If it is intentional, please type it explicitly with \`as Route\`.`;
+            }
+        }
+    } else if (typeof message === 'string' && diagnostic.code === 2820) {
+        const match = message.match(/Type '"(.+)"' is not assignable to type 'RouteImpl<.+> \| UrlObject'\. Did you mean '"(.+)"'?/) || message.match(/Type '"(.+)"' is not assignable to type 'UrlObject \| RouteImpl<.+>'\. Did you mean '"(.+)"'?/);
+        if (match) {
+            const [, href, suggestion] = match;
+            return `"${(0, _picocolors.bold)(href)}" is not an existing route. Did you mean "${(0, _picocolors.bold)(suggestion)}" instead? If it is intentional, please type it explicitly with \`as Route\`.`;
+        }
+    }
+}
+function getFormattedLayoutAndPageDiagnosticMessageText(relativeSourceFilepath, diagnostic) {
+    const message = typeof diagnostic.messageText === 'string' ? diagnostic : diagnostic.messageText;
+    const messageText = message.messageText;
+    if (typeof messageText === 'string') {
+        const type = /page\.[^.]+$/.test(relativeSourceFilepath) ? 'Page' : /route\.[^.]+$/.test(relativeSourceFilepath) ? 'Route' : 'Layout';
+        // Reference of error codes:
+        // https://github.com/Microsoft/TypeScript/blob/main/src/compiler/diagnosticMessages.json
+        switch(message.code){
+            case 2344:
+                const filepathAndType = messageText.match(/typeof import\("(.+)"\)/);
+                if (filepathAndType) {
+                    let main = `${type} "${(0, _picocolors.bold)(relativeSourceFilepath)}" does not match the required types of a Next.js ${type}.`;
+                    function processNext(indent, next) {
+                        if (!next) return;
+                        for (const item of next){
+                            switch(item.code){
+                                case 2200:
+                                    const mismatchedField = item.messageText.match(/The types of '(.+)'/);
+                                    if (mismatchedField) {
+                                        main += '\n' + ' '.repeat(indent * 2);
+                                        main += `"${(0, _picocolors.bold)(mismatchedField[1])}" has the wrong type:`;
+                                    }
+                                    break;
+                                case 2322:
+                                    const types = item.messageText.match(/Type '(.+)' is not assignable to type '(.+)'./);
+                                    if (types) {
+                                        main += '\n' + ' '.repeat(indent * 2);
+                                        if (types[2] === 'PageComponent' || types[2] === 'LayoutComponent') {
+                                            main += `The exported ${type} component isn't correctly typed.`;
+                                        } else {
+                                            main += `Expected "${(0, _picocolors.bold)(types[2].replace('"__invalid_negative_number__"', 'number (>= 0)'))}", got "${(0, _picocolors.bold)(types[1])}".`;
+                                        }
+                                    }
+                                    break;
+                                case 2326:
+                                    const invalidConfig = item.messageText.match(/Types of property '(.+)' are incompatible\./);
+                                    main += '\n' + ' '.repeat(indent * 2);
+                                    main += `Invalid configuration${invalidConfig ? ` "${(0, _picocolors.bold)(invalidConfig[1])}"` : ''}:`;
+                                    break;
+                                case 2530:
+                                    const invalidField = item.messageText.match(/Property '(.+)' is incompatible with index signature/);
+                                    if (invalidField) {
+                                        main += '\n' + ' '.repeat(indent * 2);
+                                        main += `"${(0, _picocolors.bold)(invalidField[1])}" is not a valid ${type} export field.`;
+                                    }
+                                    return;
+                                case 2739:
+                                    const invalidProp = item.messageText.match(/Type '(.+)' is missing the following properties from type '(.+)'/);
+                                    if (invalidProp) {
+                                        if (invalidProp[1] === 'LayoutProps' || invalidProp[1] === 'PageProps') {
+                                            main += '\n' + ' '.repeat(indent * 2);
+                                            main += `Prop "${invalidProp[2]}" is incompatible with the ${type}.`;
+                                        }
+                                    }
+                                    break;
+                                case 2559:
+                                    const invalid = item.messageText.match(/Type '(.+)' has/);
+                                    if (invalid) {
+                                        main += '\n' + ' '.repeat(indent * 2);
+                                        main += `Type "${(0, _picocolors.bold)(invalid[1])}" isn't allowed.`;
+                                    }
+                                    break;
+                                case 2741:
+                                    const incompatPageProp = item.messageText.match(/Property '(.+)' is missing in type 'PageProps'/);
+                                    if (incompatPageProp) {
+                                        main += '\n' + ' '.repeat(indent * 2);
+                                        main += `Prop "${(0, _picocolors.bold)(incompatPageProp[1])}" will never be passed. Remove it from the component's props.`;
+                                    } else {
+                                        const extraLayoutProp = item.messageText.match(/Property '(.+)' is missing in type 'LayoutProps' but required in type '(.+)'/);
+                                        if (extraLayoutProp) {
+                                            main += '\n' + ' '.repeat(indent * 2);
+                                            main += `Prop "${(0, _picocolors.bold)(extraLayoutProp[1])}" is not valid for this Layout, remove it to fix.`;
+                                        }
+                                    }
+                                    break;
+                                default:
+                            }
+                            processNext(indent + 1, item.next);
+                        }
+                    }
+                    if ('next' in message) processNext(1, message.next);
+                    return main;
+                }
+                const invalidExportFnArg = messageText.match(/Type 'OmitWithTag<(.+), .+, "(.+)">' does not satisfy the constraint/);
+                if (invalidExportFnArg) {
+                    const main = `${type} "${(0, _picocolors.bold)(relativeSourceFilepath)}" has an invalid "${(0, _picocolors.bold)(invalidExportFnArg[2])}" export:\n  Type "${(0, _picocolors.bold)(invalidExportFnArg[1])}" is not valid.`;
+                    return main;
+                }
+                function processNextItems(indent, next) {
+                    if (!next) return '';
+                    let result = '';
+                    for (const item of next){
+                        switch(item.code){
+                            case 2322:
+                                const types = item.messageText.match(/Type '(.+)' is not assignable to type '(.+)'./);
+                                if (types) {
+                                    result += '\n' + ' '.repeat(indent * 2);
+                                    result += `Expected "${(0, _picocolors.bold)(types[2])}", got "${(0, _picocolors.bold)(types[1])}".`;
+                                }
+                                break;
+                            default:
+                        }
+                        result += processNextItems(indent + 1, item.next);
+                    }
+                    return result;
+                }
+                const invalidParamFn = messageText.match(/Type '{ __tag__: (.+); __param_position__: "(.*)"; __param_type__: (.+); }' does not satisfy/);
+                if (invalidParamFn) {
+                    let main = `${type} "${(0, _picocolors.bold)(relativeSourceFilepath)}" has an invalid ${invalidParamFn[1]} export:\n  Type "${(0, _picocolors.bold)(invalidParamFn[3])}" is not a valid type for the function's ${invalidParamFn[2]} argument.`;
+                    if ('next' in message) main += processNextItems(1, message.next);
+                    return main;
+                }
+                const invalidExportFnReturn = messageText.match(/Type '{ __tag__: "(.+)"; __return_type__: (.+); }' does not satisfy/);
+                if (invalidExportFnReturn) {
+                    let main = `${type} "${(0, _picocolors.bold)(relativeSourceFilepath)}" has an invalid export:\n  "${(0, _picocolors.bold)(invalidExportFnReturn[2])}" is not a valid ${invalidExportFnReturn[1]} return type:`;
+                    if ('next' in message) main += processNextItems(1, message.next);
+                    return main;
+                }
+                break;
+            case 2345:
+                const filepathAndInvalidExport = messageText.match(/'typeof import\("(.+)"\)'.+Impossible<"(.+)">/);
+                if (filepathAndInvalidExport) {
+                    const main = `${type} "${(0, _picocolors.bold)(relativeSourceFilepath)}" exports an invalid "${(0, _picocolors.bold)(filepathAndInvalidExport[2])}" field. ${type} should only export a default React component and configuration options. Learn more: https://nextjs.org/docs/messages/invalid-segment-export`;
+                    return main;
+                }
+                break;
+            case 2559:
+                const invalid = messageText.match(/Type '(.+)' has no properties in common with type '(.+)'/);
+                if (invalid) {
+                    const main = `${type} "${(0, _picocolors.bold)(relativeSourceFilepath)}" contains an invalid type "${(0, _picocolors.bold)(invalid[1])}" as ${invalid[2]}.`;
+                    return main;
+                }
+                break;
+            default:
+        }
+    }
+}
+function getAppEntrySourceFilePath(baseDir, diagnostic) {
+    var _diagnostic_file_text_trim_match, _diagnostic_file;
+    const sourceFilepath = ((_diagnostic_file = diagnostic.file) == null ? void 0 : (_diagnostic_file_text_trim_match = _diagnostic_file.text.trim().match(/^\/\/ File: (.+)\n/)) == null ? void 0 : _diagnostic_file_text_trim_match[1]) || '';
+    return _path.default.relative(baseDir, sourceFilepath);
+}
+function getFormattedDiagnostic(ts, baseDir, distDir, diagnostic, isAppDirEnabled) {
+    var _diagnostic_file;
+    // If the error comes from .next/types/, we handle it specially.
+    const isLayoutOrPageError = isAppDirEnabled && ((_diagnostic_file = diagnostic.file) == null ? void 0 : _diagnostic_file.fileName.startsWith(_path.default.join(baseDir, distDir, 'types')));
+    let message = '';
+    const appPath = isLayoutOrPageError ? getAppEntrySourceFilePath(baseDir, diagnostic) : null;
+    const linkReason = getFormattedLinkDiagnosticMessageText(diagnostic);
+    const appReason = !linkReason && isLayoutOrPageError && appPath ? getFormattedLayoutAndPageDiagnosticMessageText(appPath, diagnostic) : null;
+    const reason = linkReason || appReason || ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+    const category = diagnostic.category;
+    switch(category){
+        // Warning
+        case ts.DiagnosticCategory.Warning:
+            {
+                message += (0, _picocolors.yellow)((0, _picocolors.bold)('Type warning')) + ': ';
+                break;
+            }
+        // Error
+        case ts.DiagnosticCategory.Error:
+            {
+                message += (0, _picocolors.red)((0, _picocolors.bold)('Type error')) + ': ';
+                break;
+            }
+        // 2 = Suggestion, 3 = Message
+        case ts.DiagnosticCategory.Suggestion:
+        case ts.DiagnosticCategory.Message:
+            message += (0, _picocolors.cyan)((0, _picocolors.bold)(category === 2 ? 'Suggestion' : 'Info')) + ': ';
+            break;
+        default:
+            {
+                category;
+            }
+    }
+    message += reason + '\n';
+    if (!isLayoutOrPageError && diagnostic.file) {
+        const { codeFrameColumns } = require('next/dist/compiled/babel/code-frame');
+        const pos = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+        const line = pos.line + 1;
+        const character = pos.character + 1;
+        let fileName = _path.default.posix.normalize(_path.default.relative(baseDir, diagnostic.file.fileName).replace(/\\/g, '/'));
+        if (!fileName.startsWith('.')) {
+            fileName = './' + fileName;
+        }
+        message = (0, _picocolors.cyan)(fileName) + ':' + (0, _picocolors.yellow)(line.toString()) + ':' + (0, _picocolors.yellow)(character.toString()) + '\n' + message;
+        message += '\n' + codeFrameColumns(diagnostic.file.getFullText(diagnostic.file.getSourceFile()), {
+            start: {
+                line: line,
+                column: character
+            }
+        }, {
+            forceColor: true
+        });
+    } else if (isLayoutOrPageError && appPath) {
+        message = (0, _picocolors.cyan)(appPath) + '\n' + message;
+    }
+    return message;
+}
+
+//# sourceMappingURL=diagnosticFormatter.js.map

package/webapp-dist/vendor/next/dist/lib/typescript/getTypeScriptConfiguration.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getTypeScriptConfiguration", {
+    enumerable: true,
+    get: function() {
+        return getTypeScriptConfiguration;
+    }
+});
+const _picocolors = require("../picocolors");
+const _os = /*#__PURE__*/ _interop_require_default(require("os"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fatalerror = require("../fatal-error");
+const _iserror = /*#__PURE__*/ _interop_require_default(require("../is-error"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function getTypeScriptConfiguration(typescript, tsConfigPath, metaOnly) {
+    try {
+        var _result_errors;
+        const formatDiagnosticsHost = {
+            getCanonicalFileName: (fileName)=>fileName,
+            getCurrentDirectory: typescript.sys.getCurrentDirectory,
+            getNewLine: ()=>_os.default.EOL
+        };
+        const { config, error } = typescript.readConfigFile(tsConfigPath, typescript.sys.readFile);
+        if (error) {
+            throw Object.defineProperty(new _fatalerror.FatalError(typescript.formatDiagnostic(error, formatDiagnosticsHost)), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        let configToParse = config;
+        const result = typescript.parseJsonConfigFileContent(configToParse, // When only interested in meta info,
+        // avoid enumerating all files (for performance reasons)
+        metaOnly ? {
+            ...typescript.sys,
+            readDirectory (_path, extensions, _excludes, _includes, _depth) {
+                return [
+                    extensions ? `file${extensions[0]}` : `file.ts`
+                ];
+            }
+        } : typescript.sys, _path.default.dirname(tsConfigPath));
+        if (result.errors) {
+            result.errors = result.errors.filter(({ code })=>// No inputs were found in config file
+                code !== 18003);
+        }
+        if ((_result_errors = result.errors) == null ? void 0 : _result_errors.length) {
+            throw Object.defineProperty(new _fatalerror.FatalError(typescript.formatDiagnostic(result.errors[0], formatDiagnosticsHost)), "__NEXT_ERROR_CODE", {
+                value: "E394",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        return result;
+    } catch (err) {
+        if ((0, _iserror.default)(err) && err.name === 'SyntaxError') {
+            const reason = '\n' + (err.message ?? '');
+            throw Object.defineProperty(new _fatalerror.FatalError((0, _picocolors.bold)('Could not parse' + (0, _picocolors.cyan)('tsconfig.json') + '.' + ' Please make sure it contains syntactically correct JSON.') + reason), "__NEXT_ERROR_CODE", {
+                value: "E339",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        throw err;
+    }
+}
+
+//# sourceMappingURL=getTypeScriptConfiguration.js.map

package/webapp-dist/vendor/next/dist/lib/typescript/getTypeScriptIntent.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getTypeScriptIntent", {
+    enumerable: true,
+    get: function() {
+        return getTypeScriptIntent;
+    }
+});
+const _fs = require("fs");
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _recursivereaddir = require("../recursive-readdir");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function getTypeScriptIntent(baseDir, intentDirs, tsconfigPath) {
+    const resolvedTsConfigPath = _path.default.join(baseDir, tsconfigPath);
+    // The integration turns on if we find a `tsconfig.json` in the user's
+    // project.
+    const hasTypeScriptConfiguration = (0, _fs.existsSync)(resolvedTsConfigPath);
+    if (hasTypeScriptConfiguration) {
+        const content = (0, _fs.readFileSync)(resolvedTsConfigPath, {
+            encoding: 'utf8'
+        }).trim();
+        return {
+            firstTimeSetup: content === '' || content === '{}'
+        };
+    }
+    // Next.js also offers a friendly setup mode that bootstraps a TypeScript
+    // project for the user when we detect TypeScript files. So, we need to check
+    // the `pages/` directory for a TypeScript file.
+    // Checking all directories is too slow, so this is a happy medium.
+    const tsFilesRegex = /.*\.(ts|tsx)$/;
+    const excludedRegex = /(node_modules|.*\.d\.ts$)/;
+    for (const dir of intentDirs){
+        const typescriptFiles = await (0, _recursivereaddir.recursiveReadDir)(dir, {
+            pathnameFilter: (name)=>tsFilesRegex.test(name),
+            ignoreFilter: (name)=>excludedRegex.test(name)
+        });
+        if (typescriptFiles.length) {
+            return {
+                firstTimeSetup: true
+            };
+        }
+    }
+    return false;
+}
+
+//# sourceMappingURL=getTypeScriptIntent.js.map

package/webapp-dist/vendor/next/dist/lib/typescript/missingDependencyError.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "missingDepsError", {
+    enumerable: true,
+    get: function() {
+        return missingDepsError;
+    }
+});
+const _picocolors = require("../picocolors");
+const _oxfordcommalist = require("../oxford-comma-list");
+const _fatalerror = require("../fatal-error");
+const _getpkgmanager = require("../helpers/get-pkg-manager");
+function missingDepsError(dir, missingPackages) {
+    const packagesHuman = (0, _oxfordcommalist.getOxfordCommaList)(missingPackages.map((p)=>p.pkg));
+    const packagesCli = missingPackages.map((p)=>p.pkg).join(' ');
+    const packageManager = (0, _getpkgmanager.getPkgManager)(dir);
+    const removalMsg = '\n\n' + (0, _picocolors.bold)('If you are not trying to use TypeScript, please remove the ' + (0, _picocolors.cyan)('tsconfig.json') + ' file from your package root (and any TypeScript files in your app and pages directories).');
+    throw Object.defineProperty(new _fatalerror.FatalError((0, _picocolors.bold)((0, _picocolors.red)(`It looks like you're trying to use TypeScript but do not have the required package(s) installed.`)) + '\n\n' + (0, _picocolors.bold)(`Please install ${(0, _picocolors.bold)(packagesHuman)} by running:`) + '\n\n' + `\t${(0, _picocolors.bold)((0, _picocolors.cyan)((packageManager === 'yarn' ? 'yarn add --dev' : packageManager === 'pnpm' ? 'pnpm install --save-dev' : 'npm install --save-dev') + ' ' + packagesCli))}` + removalMsg + '\n'), "__NEXT_ERROR_CODE", {
+        value: "E532",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=missingDependencyError.js.map