@nilsr0711/drydock 0.1.0 → 0.1.2

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/get-babel-loader-config.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getBabelLoader: null,
+    getReactCompilerLoader: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getBabelLoader: function() {
+        return getBabelLoader;
+    },
+    getReactCompilerLoader: function() {
+        return getReactCompilerLoader;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function getReactCompiler() {
+    try {
+        return require.resolve('babel-plugin-react-compiler');
+    } catch  {
+        throw Object.defineProperty(new Error('Failed to load the `babel-plugin-react-compiler`. It is required to use the React Compiler. Please install it.'), "__NEXT_ERROR_CODE", {
+            value: "E78",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+const getReactCompilerPlugins = (maybeOptions, isServer, isDev)=>{
+    if (!maybeOptions || isServer) {
+        return undefined;
+    }
+    const environment = {
+        enableNameAnonymousFunctions: isDev
+    };
+    const options = typeof maybeOptions === 'boolean' ? {} : maybeOptions;
+    const compilerOptions = {
+        ...options,
+        environment
+    };
+    return [
+        [
+            getReactCompiler(),
+            compilerOptions
+        ]
+    ];
+};
+const getBabelLoader = (useSWCLoader, babelConfigFile, isServer, distDir, pagesDir, cwd, srcDir, dev, isClient, reactCompilerOptions, reactCompilerExclude)=>{
+    if (!useSWCLoader) {
+        // Make sure these options are kept in sync with
+        // `packages/next/src/build/get-babel-loader-config.ts`
+        const options = {
+            transformMode: 'default',
+            configFile: babelConfigFile,
+            isServer,
+            distDir,
+            pagesDir,
+            cwd,
+            srcDir: _path.default.dirname(srcDir),
+            development: dev,
+            hasReactRefresh: dev && isClient,
+            hasJsxRuntime: true,
+            reactCompilerPlugins: getReactCompilerPlugins(reactCompilerOptions, isServer, dev),
+            reactCompilerExclude
+        };
+        return {
+            loader: require.resolve('./babel/loader/index'),
+            options
+        };
+    }
+    return undefined;
+};
+/**
+ * Get a separate babel loader for the react compiler, only used if Babel is not
+ * configured through e.g. .babelrc. If user have babel config, this should be configured in the babel loader itself.
+ * Note from react compiler:
+ * > For best results, compiler must run as the first plugin in your Babel pipeline so it receives input as close to the original source as possible.
+ */ const getReactCompilerLoader = (reactCompilerOptions, cwd, isServer, reactCompilerExclude, isDev)=>{
+    const reactCompilerPlugins = getReactCompilerPlugins(reactCompilerOptions, isServer, isDev);
+    if (!reactCompilerPlugins) {
+        return undefined;
+    }
+    const babelLoaderOptions = {
+        transformMode: 'standalone',
+        cwd,
+        reactCompilerPlugins,
+        isServer
+    };
+    if (reactCompilerExclude) {
+        babelLoaderOptions.reactCompilerExclude = reactCompilerExclude;
+    }
+    return {
+        loader: require.resolve('./babel/loader/index'),
+        options: babelLoaderOptions
+    };
+};
+
+//# sourceMappingURL=get-babel-loader-config.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/get-static-info-including-layouts.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getStaticInfoIncludingLayouts", {
+    enumerable: true,
+    get: function() {
+        return getStaticInfoIncludingLayouts;
+    }
+});
+const _path = require("path");
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _utils = require("./utils");
+const _getpagestaticinfo = require("./analysis/get-page-static-info");
+const _pagetypes = require("../lib/page-types");
+const _isapppageroute = require("../lib/is-app-page-route");
+const _entryconstants = require("../shared/lib/entry-constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+async function getStaticInfoIncludingLayouts({ isInsideAppDir, pageExtensions, pageFilePath, appDir, config: nextConfig, isDev, page }) {
+    // TODO: sync types for pages: PAGE_TYPES, ROUTER_TYPE, 'app' | 'pages', etc.
+    const pageType = isInsideAppDir ? _pagetypes.PAGE_TYPES.APP : _pagetypes.PAGE_TYPES.PAGES;
+    const pageStaticInfo = await (0, _getpagestaticinfo.getPageStaticInfo)({
+        nextConfig,
+        pageFilePath,
+        isDev,
+        page,
+        pageType
+    });
+    if (pageStaticInfo.type === _pagetypes.PAGE_TYPES.PAGES || !appDir) {
+        return pageStaticInfo;
+    }
+    // Skip inheritance for global-error pages - always use default config
+    if (page === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY) {
+        return pageStaticInfo;
+    }
+    const segments = [
+        pageStaticInfo
+    ];
+    // inherit from layout files only if it's a page route and not a builtin page
+    if ((0, _isapppageroute.isAppPageRoute)(page) && !(0, _utils.isAppBuiltinPage)(pageFilePath)) {
+        const layoutFiles = [];
+        const potentialLayoutFiles = pageExtensions.map((ext)=>'layout.' + ext);
+        let dir = (0, _path.dirname)(pageFilePath);
+        // Uses startsWith to not include directories further up.
+        while(dir.startsWith(appDir)){
+            for (const potentialLayoutFile of potentialLayoutFiles){
+                const layoutFile = (0, _path.join)(dir, potentialLayoutFile);
+                if (!_fs.default.existsSync(layoutFile)) {
+                    continue;
+                }
+                layoutFiles.push(layoutFile);
+            }
+            // Walk up the directory tree
+            dir = (0, _path.join)(dir, '..');
+        }
+        for (const layoutFile of layoutFiles){
+            const layoutStaticInfo = await (0, _getpagestaticinfo.getAppPageStaticInfo)({
+                nextConfig,
+                pageFilePath: layoutFile,
+                isDev,
+                page,
+                pageType: isInsideAppDir ? _pagetypes.PAGE_TYPES.APP : _pagetypes.PAGE_TYPES.PAGES
+            });
+            segments.unshift(layoutStaticInfo);
+        }
+    }
+    const config = (0, _utils.reduceAppConfig)(segments);
+    return {
+        ...pageStaticInfo,
+        config,
+        runtime: config.runtime,
+        preferredRegion: config.preferredRegion,
+        maxDuration: config.maxDuration
+    };
+}
+
+//# sourceMappingURL=get-static-info-including-layouts.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/handle-externals.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    isResourceInPackages: null,
+    makeExternalHandler: null,
+    resolveExternal: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isResourceInPackages: function() {
+        return isResourceInPackages;
+    },
+    makeExternalHandler: function() {
+        return makeExternalHandler;
+    },
+    resolveExternal: function() {
+        return resolveExternal;
+    }
+});
+const _requirehook = require("../server/require-hook");
+const _constants = require("../shared/lib/constants");
+const _path = /*#__PURE__*/ _interop_require_default(require("../shared/lib/isomorphic/path"));
+const _webpackconfig = require("./webpack-config");
+const _utils = require("./utils");
+const _normalizepathsep = require("../shared/lib/page-path/normalize-path-sep");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const reactPackagesRegex = /^(react|react-dom|react-server-dom-webpack)($|\/)/;
+const pathSeparators = '[/\\\\]';
+const optionalEsmPart = `((${pathSeparators}esm)?${pathSeparators})`;
+const externalFileEnd = '(\\.external(\\.js)?)$';
+const nextDist = `next${pathSeparators}dist`;
+const externalPattern = new RegExp(`${nextDist}${optionalEsmPart}.*${externalFileEnd}`);
+const nodeModulesRegex = /node_modules[/\\].*\.[mc]?js$/;
+function isResourceInPackages(resource, packageNames, packageDirMapping) {
+    if (!packageNames) return false;
+    return packageNames.some((p)=>packageDirMapping && packageDirMapping.has(p) ? resource.startsWith(packageDirMapping.get(p) + _path.default.sep) : resource.includes(_path.default.sep + _path.default.join('node_modules', p.replace(/\//g, _path.default.sep)) + _path.default.sep));
+}
+async function resolveExternal(dir, esmExternalsConfig, context, request, isEsmRequested, getResolve, isLocalCallback, baseResolveCheck = true, esmResolveOptions = _webpackconfig.NODE_ESM_RESOLVE_OPTIONS, nodeResolveOptions = _webpackconfig.NODE_RESOLVE_OPTIONS, baseEsmResolveOptions = _webpackconfig.NODE_BASE_ESM_RESOLVE_OPTIONS, baseResolveOptions = _webpackconfig.NODE_BASE_RESOLVE_OPTIONS) {
+    const esmExternals = !!esmExternalsConfig;
+    const looseEsmExternals = esmExternalsConfig === 'loose';
+    let res = null;
+    let isEsm = false;
+    const preferEsmOptions = esmExternals && isEsmRequested ? [
+        true,
+        false
+    ] : [
+        false
+    ];
+    for (const preferEsm of preferEsmOptions){
+        const resolveOptions = preferEsm ? esmResolveOptions : nodeResolveOptions;
+        const resolve = getResolve(resolveOptions);
+        // Resolve the import with the webpack provided context, this
+        // ensures we're resolving the correct version when multiple
+        // exist.
+        try {
+            ;
+            [res, isEsm] = await resolve(context, request);
+        } catch (err) {
+            res = null;
+        }
+        if (!res) {
+            continue;
+        }
+        // ESM externals can only be imported (and not required).
+        // Make an exception in loose mode.
+        if (!isEsmRequested && isEsm && !looseEsmExternals) {
+            continue;
+        }
+        if (isLocalCallback) {
+            return {
+                localRes: isLocalCallback(res)
+            };
+        }
+        // Bundled Node.js code is relocated without its node_modules tree.
+        // This means we need to make sure its request resolves to the same
+        // package that'll be available at runtime. If it's not identical,
+        // we need to bundle the code (even if it _should_ be external).
+        if (baseResolveCheck) {
+            let baseRes;
+            let baseIsEsm;
+            try {
+                const baseResolve = getResolve(isEsm ? baseEsmResolveOptions : baseResolveOptions);
+                [baseRes, baseIsEsm] = await baseResolve(dir, request);
+            } catch (err) {
+                baseRes = null;
+                baseIsEsm = false;
+            }
+            // Same as above: if the package, when required from the root,
+            // would be different from what the real resolution would use, we
+            // cannot externalize it.
+            // if request is pointing to a symlink it could point to the same file,
+            // the resolver will resolve symlinks so this is handled
+            if (baseRes !== res || isEsm !== baseIsEsm) {
+                res = null;
+                continue;
+            }
+        }
+        break;
+    }
+    return {
+        res,
+        isEsm
+    };
+}
+function makeExternalHandler({ config, optOutBundlingPackageRegex, transpiledPackages, dir }) {
+    var _config_experimental;
+    let resolvedExternalPackageDirs;
+    const looseEsmExternals = ((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.esmExternals) === 'loose';
+    return async function handleExternals(context, request, dependencyType, layer, getResolve) {
+        // We need to externalize internal requests for files intended to
+        // not be bundled.
+        const isLocal = request.startsWith('.') || // Always check for unix-style path, as webpack sometimes
+        // normalizes as posix.
+        _path.default.posix.isAbsolute(request) || // When on Windows, we also want to check for Windows-specific
+        // absolute paths.
+        process.platform === 'win32' && _path.default.win32.isAbsolute(request);
+        // make sure import "next" shows a warning when imported
+        // in pages/components
+        if (request === 'next') {
+            return `commonjs next/dist/lib/import-next-warning`;
+        }
+        const isAppLayer = (0, _utils.isWebpackBundledLayer)(layer);
+        // Relative requires don't need custom resolution, because they
+        // are relative to requests we've already resolved here.
+        // Absolute requires (require('/foo')) are extremely uncommon, but
+        // also have no need for customization as they're already resolved.
+        if (!isLocal) {
+            if (/^next$/.test(request)) {
+                return `commonjs ${request}`;
+            }
+            if (reactPackagesRegex.test(request) && !isAppLayer) {
+                return `commonjs ${request}`;
+            }
+            // Handle Bun builtins as external modules
+            if (request === 'bun' || request.startsWith('bun:')) {
+                return `commonjs ${request}`;
+            }
+            const notExternalModules = /^(?:private-next-pages\/|next\/(?:dist\/pages\/|(?:app|cache|document|link|form|head|image|legacy\/image|constants|dynamic|script|navigation|headers|router|compat\/router|server)$)|string-hash|private-next-rsc-action-validate|private-next-rsc-action-client-wrapper|private-next-rsc-server-reference|private-next-rsc-cache-wrapper|private-next-rsc-track-dynamic-import$)/;
+            if (notExternalModules.test(request)) {
+                return;
+            }
+        }
+        // @swc/helpers should not be external as it would
+        // require hoisting the package which we can't rely on
+        if (request.includes('@swc/helpers')) {
+            return;
+        }
+        // BARREL_OPTIMIZATION_PREFIX is a special marker that tells Next.js to
+        // optimize the import by removing unused exports. This has to be compiled.
+        if (request.startsWith(_constants.BARREL_OPTIMIZATION_PREFIX)) {
+            return;
+        }
+        // When in esm externals mode, and using import, we resolve with
+        // ESM resolving options.
+        // Also disable esm request when appDir is enabled
+        const isEsmRequested = dependencyType === 'esm';
+        // Don't bundle @vercel/og nodejs bundle for nodejs runtime.
+        // TODO-APP: bundle route.js with different layer that externals common node_module deps.
+        // Make sure @vercel/og is loaded as ESM for Node.js runtime
+        if ((0, _utils.shouldUseReactServerCondition)(layer) && request === 'next/dist/compiled/@vercel/og/index.node.js') {
+            return `module ${request}`;
+        }
+        // Specific Next.js imports that should remain external
+        // TODO-APP: Investigate if we can remove this.
+        if (request.startsWith('next/dist/')) {
+            // Non external that needs to be transpiled
+            // Image loader needs to be transpiled
+            if (/^next[\\/]dist[\\/]shared[\\/]lib[\\/]image-loader/.test(request)) {
+                return;
+            }
+            if (/^next[\\/]dist[\\/]compiled[\\/]next-server/.test(request)) {
+                return `commonjs ${request}`;
+            }
+            if (/^next[\\/]dist[\\/]shared[\\/](?!lib[\\/]router[\\/]router)/.test(request) || /^next[\\/]dist[\\/]compiled[\\/].*\.c?js$/.test(request)) {
+                return `commonjs ${request}`;
+            }
+            if (/^next[\\/]dist[\\/]esm[\\/]shared[\\/](?!lib[\\/]router[\\/]router)/.test(request) || /^next[\\/]dist[\\/]compiled[\\/].*\.mjs$/.test(request)) {
+                return `module ${request}`;
+            }
+            return resolveNextExternal(request);
+        }
+        // TODO-APP: Let's avoid this resolve call as much as possible, and eventually get rid of it.
+        const resolveResult = await resolveExternal(dir, config.experimental.esmExternals, context, request, isEsmRequested, getResolve, isLocal ? resolveNextExternal : undefined);
+        if ('localRes' in resolveResult) {
+            return resolveResult.localRes;
+        }
+        // Forcedly resolve the styled-jsx installed by next.js,
+        // since `resolveExternal` cannot find the styled-jsx dep with pnpm
+        if (request === 'styled-jsx/style') {
+            resolveResult.res = _requirehook.defaultOverrides['styled-jsx/style'];
+        }
+        const { res, isEsm } = resolveResult;
+        // If the request cannot be resolved we need to have
+        // webpack "bundle" it so it surfaces the not found error.
+        if (!res) {
+            return;
+        }
+        const isOptOutBundling = optOutBundlingPackageRegex.test(res);
+        // Apply bundling rules to all app layers.
+        // Since handleExternals only handle the server layers, we don't need to exclude client here
+        if (!isOptOutBundling && isAppLayer) {
+            return;
+        }
+        // ESM externals can only be imported (and not required).
+        // Make an exception in loose mode.
+        if (!isEsmRequested && isEsm && !looseEsmExternals && !isLocal) {
+            throw Object.defineProperty(new Error(`ESM packages (${request}) need to be imported. Use 'import' to reference the package instead. https://nextjs.org/docs/messages/import-esm-externals`), "__NEXT_ERROR_CODE", {
+                value: "E310",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const externalType = isEsm ? 'module' : 'commonjs';
+        // Default pages have to be transpiled
+        if (// This is the @babel/plugin-transform-runtime "helpers: true" option
+        /node_modules[/\\]@babel[/\\]runtime[/\\]/.test(res)) {
+            return;
+        }
+        // Webpack itself has to be compiled because it doesn't always use module relative paths
+        if (/node_modules[/\\]webpack/.test(res) || /node_modules[/\\]css-loader/.test(res)) {
+            return;
+        }
+        // If a package should be transpiled by Next.js, we skip making it external.
+        // It doesn't matter what the extension is, as we'll transpile it anyway.
+        if (transpiledPackages && !resolvedExternalPackageDirs) {
+            resolvedExternalPackageDirs = new Map();
+            // We need to resolve all the external package dirs initially.
+            for (const pkg of transpiledPackages){
+                const pkgRes = await resolveExternal(dir, config.experimental.esmExternals, context, pkg + '/package.json', isEsmRequested, getResolve, isLocal ? resolveNextExternal : undefined);
+                if (pkgRes.res) {
+                    resolvedExternalPackageDirs.set(pkg, _path.default.dirname(pkgRes.res));
+                }
+            }
+        }
+        const resolvedBundlingOptOutRes = resolveBundlingOptOutPackages({
+            resolvedRes: res,
+            config,
+            resolvedExternalPackageDirs,
+            isAppLayer,
+            externalType,
+            isOptOutBundling,
+            request,
+            transpiledPackages
+        });
+        if (resolvedBundlingOptOutRes) {
+            return resolvedBundlingOptOutRes;
+        }
+        // if here, we default to bundling the file
+        return;
+    };
+}
+function resolveBundlingOptOutPackages({ resolvedRes, config, resolvedExternalPackageDirs, isAppLayer, externalType, isOptOutBundling, request, transpiledPackages }) {
+    if (nodeModulesRegex.test(resolvedRes)) {
+        const shouldBundlePages = !isAppLayer && config.bundlePagesRouterDependencies && !isOptOutBundling;
+        const shouldBeBundled = shouldBundlePages || isResourceInPackages(resolvedRes, transpiledPackages, resolvedExternalPackageDirs);
+        if (!shouldBeBundled) {
+            return `${externalType} ${request}` // Externalize if not bundled or opted out
+            ;
+        }
+    }
+}
+/**
+ * @param localRes the full path to the file
+ * @returns the externalized path
+ * @description returns an externalized path if the file is a Next.js file and ends with either `.shared-runtime.js` or `.external.js`
+ * This is used to ensure that files used across the rendering runtime(s) and the user code are one and the same. The logic in this function
+ * will rewrite the require to the correct bundle location depending on the layer at which the file is being used.
+ */ function resolveNextExternal(localRes) {
+    const isExternal = externalPattern.test(localRes);
+    // if the file ends with .external, we need to make it a commonjs require in all cases
+    // this is used mainly to share the async local storage across the routing, rendering and user layers.
+    if (isExternal) {
+        // it's important we return the path that starts with `next/dist/` here instead of the absolute path
+        // otherwise NFT will get tripped up
+        return `commonjs ${(0, _normalizepathsep.normalizePathSep)(localRes.replace(/.*?next[/\\]dist/, 'next/dist'))}`;
+    }
+}
+
+//# sourceMappingURL=handle-externals.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/load-entrypoint.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "loadEntrypoint", {
+    enumerable: true,
+    get: function() {
+        return loadEntrypoint;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _swc = require("./swc");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+// NOTE: this should be updated if this loader file is moved.
+const PACKAGE_ROOT = _path.default.normalize(_path.default.join(__dirname, '../..'));
+const TEMPLATE_SRC_FOLDER = _path.default.normalize(_path.default.join(__dirname, './templates'));
+const TEMPLATES_ESM_FOLDER = _path.default.normalize(_path.default.join(__dirname, '../../dist/esm/build/templates'));
+async function loadEntrypoint(entrypoint, replacements, injections, imports) {
+    const templatePath = _path.default.resolve(_path.default.join(TEMPLATES_ESM_FOLDER, `${entrypoint}.js`));
+    let content = await _promises.default.readFile(templatePath);
+    return (0, _swc.getBindingsSync)().expandNextJsTemplate(content, // Ensure that we use unix-style path separators for the import paths
+    _path.default.join(TEMPLATE_SRC_FOLDER, `${entrypoint}.js`).replace(/\\/g, '/'), PACKAGE_ROOT.replace(/\\/g, '/'), replacements, injections ?? {}, imports ?? {});
+}
+
+//# sourceMappingURL=load-entrypoint.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/load-jsconfig.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    default: null,
+    parseJsonFile: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    default: function() {
+        return loadJsConfig;
+    },
+    parseJsonFile: function() {
+        return parseJsonFile;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("./output/log"));
+const _getTypeScriptConfiguration = require("../lib/typescript/getTypeScriptConfiguration");
+const _iserror = /*#__PURE__*/ _interop_require_default(require("../lib/is-error"));
+const _hasnecessarydependencies = require("../lib/has-necessary-dependencies");
+const _codeframe = require("../shared/lib/errors/code-frame");
+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;
+}
+let TSCONFIG_WARNED = false;
+function parseJsonFile(filePath) {
+    const JSON5 = require('next/dist/compiled/json5');
+    const contents = (0, _fs.readFileSync)(filePath, 'utf8');
+    // Special case an empty file
+    if (contents.trim() === '') {
+        return {};
+    }
+    try {
+        return JSON5.parse(contents);
+    } catch (err) {
+        if (!(0, _iserror.default)(err)) throw err;
+        const codeFrame = (0, _codeframe.codeFrameColumns)(String(contents), {
+            start: {
+                line: err.lineNumber || 1,
+                column: err.columnNumber || undefined
+            }
+        }, {
+            message: err.message,
+            color: true
+        });
+        throw Object.defineProperty(new Error(`Failed to parse "${filePath}":\n${codeFrame ?? err.message}`), "__NEXT_ERROR_CODE", {
+            value: "E1087",
+            enumerable: false,
+            configurable: true
+        });
+    }
+}
+async function loadJsConfig(dir, config) {
+    var _jsConfig_compilerOptions;
+    let typeScriptPath;
+    try {
+        const deps = (0, _hasnecessarydependencies.hasNecessaryDependencies)(dir, [
+            {
+                pkg: 'typescript',
+                file: 'typescript/lib/typescript.js',
+                exportsRestrict: true
+            }
+        ]);
+        typeScriptPath = deps.resolved.get('typescript');
+    } catch  {}
+    const tsConfigFileName = config.typescript.tsconfigPath || 'tsconfig.json';
+    const tsConfigPath = _path.default.join(dir, tsConfigFileName);
+    const useTypeScript = Boolean(typeScriptPath && _fs.default.existsSync(tsConfigPath));
+    let implicitBaseurl;
+    let jsConfig;
+    // jsconfig is a subset of tsconfig
+    if (useTypeScript) {
+        if (tsConfigFileName !== 'tsconfig.json' && TSCONFIG_WARNED === false) {
+            TSCONFIG_WARNED = true;
+            _log.info(`Using tsconfig file: ${tsConfigFileName}`);
+        }
+        const ts = await Promise.resolve(require(typeScriptPath));
+        const tsConfig = await (0, _getTypeScriptConfiguration.getTypeScriptConfiguration)(ts, tsConfigPath, true);
+        jsConfig = {
+            compilerOptions: tsConfig.options
+        };
+        implicitBaseurl = _path.default.dirname(tsConfigPath);
+    }
+    const jsConfigPath = _path.default.join(dir, 'jsconfig.json');
+    if (!useTypeScript && _fs.default.existsSync(jsConfigPath)) {
+        jsConfig = parseJsonFile(jsConfigPath);
+        implicitBaseurl = _path.default.dirname(jsConfigPath);
+    }
+    let resolvedBaseUrl;
+    if (jsConfig == null ? void 0 : (_jsConfig_compilerOptions = jsConfig.compilerOptions) == null ? void 0 : _jsConfig_compilerOptions.baseUrl) {
+        resolvedBaseUrl = {
+            baseUrl: _path.default.resolve(dir, jsConfig.compilerOptions.baseUrl),
+            isImplicit: false
+        };
+    } else {
+        if (implicitBaseurl) {
+            resolvedBaseUrl = {
+                baseUrl: implicitBaseurl,
+                isImplicit: true
+            };
+        }
+    }
+    return {
+        useTypeScript,
+        jsConfig,
+        resolvedBaseUrl,
+        jsConfigPath: useTypeScript ? tsConfigPath : _fs.default.existsSync(jsConfigPath) ? jsConfigPath : undefined
+    };
+}
+
+//# sourceMappingURL=load-jsconfig.js.map