create project

kitabcitab/node_modules/next/dist/export/index.d.ts

@@ -0,0 +1,15 @@
+import { NextConfigComplete } from '../server/config-shared';
+import { Span } from '../trace';
+interface ExportOptions {
+    outdir: string;
+    silent?: boolean;
+    threads?: number;
+    pages?: string[];
+    buildExport?: boolean;
+    statusMessage?: string;
+    exportPageWorker?: typeof import('./worker').default;
+    endWorker?: () => Promise<void>;
+    appPaths?: string[];
+}
+export default function exportApp(dir: string, options: ExportOptions, span: Span, configuration?: NextConfigComplete): Promise<void>;
+export {};

kitabcitab/node_modules/next/dist/export/index.js

@@ -0,0 +1,541 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = exportApp;
+var _chalk = _interopRequireDefault(require("next/dist/compiled/chalk"));
+var _findUp = _interopRequireDefault(require("next/dist/compiled/find-up"));
+var _fs = require("fs");
+var _worker = require("../lib/worker");
+var _path = require("path");
+var _util = require("util");
+var _index = require("../build/output/index");
+var Log = _interopRequireWildcard(require("../build/output/log"));
+var _spinner = _interopRequireDefault(require("../build/spinner"));
+var _constants = require("../lib/constants");
+var _recursiveCopy = require("../lib/recursive-copy");
+var _recursiveDelete = require("../lib/recursive-delete");
+var _constants1 = require("../shared/lib/constants");
+var _config = _interopRequireDefault(require("../server/config"));
+var _events = require("../telemetry/events");
+var _ciInfo = require("../telemetry/ci-info");
+var _storage = require("../telemetry/storage");
+var _normalizePagePath = require("../shared/lib/page-path/normalize-page-path");
+var _denormalizePagePath = require("../shared/lib/page-path/denormalize-page-path");
+var _env = require("@next/env");
+var _isApiRoute = require("../lib/is-api-route");
+var _require = require("../server/require");
+var _requireHook = require("../build/webpack/require-hook");
+async function exportApp(dir, options, span, configuration) {
+    const nextExportSpan = span.traceChild("next-export");
+    const hasAppDir = !!options.appPaths;
+    return nextExportSpan.traceAsyncFn(async ()=>{
+        var ref, ref1, ref2, ref3;
+        dir = (0, _path).resolve(dir);
+        // attempt to load global env values so they are available in next.config.js
+        nextExportSpan.traceChild("load-dotenv").traceFn(()=>(0, _env).loadEnvConfig(dir, false, Log));
+        const nextConfig = configuration || await nextExportSpan.traceChild("load-next-config").traceAsyncFn(()=>(0, _config).default(_constants1.PHASE_EXPORT, dir));
+        const threads = options.threads || nextConfig.experimental.cpus;
+        const distDir = (0, _path).join(dir, nextConfig.distDir);
+        const telemetry = options.buildExport ? null : new _storage.Telemetry({
+            distDir
+        });
+        if (telemetry) {
+            telemetry.record((0, _events).eventCliSession(distDir, nextConfig, {
+                webpackVersion: null,
+                cliCommand: "export",
+                isSrcDir: null,
+                hasNowJson: !!await (0, _findUp).default("now.json", {
+                    cwd: dir
+                }),
+                isCustomServer: null,
+                turboFlag: false,
+                pagesDir: null,
+                appDir: null
+            }));
+        }
+        const subFolders = nextConfig.trailingSlash && !options.buildExport;
+        if (!options.silent && !options.buildExport) {
+            Log.info(`using build directory: ${distDir}`);
+        }
+        const buildIdFile = (0, _path).join(distDir, _constants1.BUILD_ID_FILE);
+        if (!(0, _fs).existsSync(buildIdFile)) {
+            throw new Error(`Could not find a production build in the '${distDir}' directory. Try building your app with 'next build' before starting the static export. https://nextjs.org/docs/messages/next-export-no-build-id`);
+        }
+        const customRoutesDetected = [
+            "rewrites",
+            "redirects",
+            "headers"
+        ].filter((config)=>typeof nextConfig[config] === "function");
+        if (!_ciInfo.hasNextSupport && !options.buildExport && customRoutesDetected.length > 0) {
+            Log.warn(`rewrites, redirects, and headers are not applied when exporting your application, detected (${customRoutesDetected.join(", ")}). See more info here: https://nextjs.org/docs/messages/export-no-custom-routes`);
+        }
+        const buildId = (0, _fs).readFileSync(buildIdFile, "utf8");
+        const pagesManifest = !options.pages && require((0, _path).join(distDir, _constants1.SERVER_DIRECTORY, _constants1.PAGES_MANIFEST));
+        let prerenderManifest = undefined;
+        try {
+            prerenderManifest = require((0, _path).join(distDir, _constants1.PRERENDER_MANIFEST));
+        } catch (_) {}
+        const excludedPrerenderRoutes = new Set();
+        const pages = options.pages || Object.keys(pagesManifest);
+        const defaultPathMap = {};
+        let hasApiRoutes = false;
+        for (const page1 of pages){
+            // _document and _app are not real pages
+            // _error is exported as 404.html later on
+            // API Routes are Node.js functions
+            if ((0, _isApiRoute).isAPIRoute(page1)) {
+                hasApiRoutes = true;
+                continue;
+            }
+            if (page1 === "/_document" || page1 === "/_app" || page1 === "/_error") {
+                continue;
+            }
+            // iSSG pages that are dynamic should not export templated version by
+            // default. In most cases, this would never work. There is no server that
+            // could run `getStaticProps`. If users make their page work lazily, they
+            // can manually add it to the `exportPathMap`.
+            if (prerenderManifest == null ? void 0 : prerenderManifest.dynamicRoutes[page1]) {
+                excludedPrerenderRoutes.add(page1);
+                continue;
+            }
+            defaultPathMap[page1] = {
+                page: page1
+            };
+        }
+        // Initialize the output directory
+        const outDir = options.outdir;
+        if (outDir === (0, _path).join(dir, "public")) {
+            throw new Error(`The 'public' directory is reserved in Next.js and can not be used as the export out directory. https://nextjs.org/docs/messages/can-not-output-to-public`);
+        }
+        if (outDir === (0, _path).join(dir, "static")) {
+            throw new Error(`The 'static' directory is reserved in Next.js and can not be used as the export out directory. https://nextjs.org/docs/messages/can-not-output-to-static`);
+        }
+        await (0, _recursiveDelete).recursiveDelete((0, _path).join(outDir));
+        await _fs.promises.mkdir((0, _path).join(outDir, "_next", buildId), {
+            recursive: true
+        });
+        (0, _fs).writeFileSync((0, _path).join(distDir, _constants1.EXPORT_DETAIL), JSON.stringify({
+            version: 1,
+            outDirectory: outDir,
+            success: false
+        }), "utf8");
+        // Copy static directory
+        if (!options.buildExport && (0, _fs).existsSync((0, _path).join(dir, "static"))) {
+            if (!options.silent) {
+                Log.info('Copying "static" directory');
+            }
+            await nextExportSpan.traceChild("copy-static-directory").traceAsyncFn(()=>(0, _recursiveCopy).recursiveCopy((0, _path).join(dir, "static"), (0, _path).join(outDir, "static")));
+        }
+        // Copy .next/static directory
+        if (!options.buildExport && (0, _fs).existsSync((0, _path).join(distDir, _constants1.CLIENT_STATIC_FILES_PATH))) {
+            if (!options.silent) {
+                Log.info('Copying "static build" directory');
+            }
+            await nextExportSpan.traceChild("copy-next-static-directory").traceAsyncFn(()=>(0, _recursiveCopy).recursiveCopy((0, _path).join(distDir, _constants1.CLIENT_STATIC_FILES_PATH), (0, _path).join(outDir, "_next", _constants1.CLIENT_STATIC_FILES_PATH)));
+        }
+        // Get the exportPathMap from the config file
+        if (typeof nextConfig.exportPathMap !== "function") {
+            if (!options.silent) {
+                Log.info(`No "exportPathMap" found in "${nextConfig.configFile}". Generating map from "./pages"`);
+            }
+            nextConfig.exportPathMap = async (defaultMap)=>{
+                return defaultMap;
+            };
+        }
+        const { i18n , images: { loader ="default" , unoptimized  } ,  } = nextConfig;
+        if (i18n && !options.buildExport) {
+            throw new Error(`i18n support is not compatible with next export. See here for more info on deploying: https://nextjs.org/docs/deployment`);
+        }
+        if (!options.buildExport) {
+            const { isNextImageImported  } = await nextExportSpan.traceChild("is-next-image-imported").traceAsyncFn(()=>_fs.promises.readFile((0, _path).join(distDir, _constants1.EXPORT_MARKER), "utf8").then((text)=>JSON.parse(text)).catch(()=>({})));
+            if (isNextImageImported && loader === "default" && !unoptimized && !_ciInfo.hasNextSupport) {
+                throw new Error(`Image Optimization using Next.js' default loader is not compatible with \`next export\`.
+  Possible solutions:
+    - Use \`next start\` to run a server, which includes the Image Optimization API.
+    - Configure \`images.unoptimized = true\` in \`next.config.js\` to disable the Image Optimization API.
+  Read more: https://nextjs.org/docs/messages/export-image-api`);
+            }
+        }
+        // Start the rendering process
+        const renderOpts = {
+            dir,
+            buildId,
+            nextExport: true,
+            assetPrefix: nextConfig.assetPrefix.replace(/\/$/, ""),
+            distDir,
+            dev: false,
+            hotReloader: null,
+            basePath: nextConfig.basePath,
+            canonicalBase: ((ref = nextConfig.amp) == null ? void 0 : ref.canonicalBase) || "",
+            ampValidatorPath: ((ref1 = nextConfig.experimental.amp) == null ? void 0 : ref1.validator) || undefined,
+            ampSkipValidation: ((ref2 = nextConfig.experimental.amp) == null ? void 0 : ref2.skipValidation) || false,
+            ampOptimizerConfig: ((ref3 = nextConfig.experimental.amp) == null ? void 0 : ref3.optimizer) || undefined,
+            locales: i18n == null ? void 0 : i18n.locales,
+            locale: i18n == null ? void 0 : i18n.defaultLocale,
+            defaultLocale: i18n == null ? void 0 : i18n.defaultLocale,
+            domainLocales: i18n == null ? void 0 : i18n.domains,
+            trailingSlash: nextConfig.trailingSlash,
+            disableOptimizedLoading: nextConfig.experimental.disableOptimizedLoading,
+            // Exported pages do not currently support dynamic HTML.
+            supportsDynamicHTML: false,
+            runtime: nextConfig.experimental.runtime,
+            crossOrigin: nextConfig.crossOrigin,
+            optimizeCss: nextConfig.experimental.optimizeCss,
+            nextScriptWorkers: nextConfig.experimental.nextScriptWorkers,
+            optimizeFonts: nextConfig.optimizeFonts,
+            largePageDataBytes: nextConfig.experimental.largePageDataBytes,
+            serverComponents: hasAppDir,
+            fontLoaderManifest: nextConfig.experimental.fontLoaders ? require((0, _path).join(distDir, "server", `${_constants1.FONT_LOADER_MANIFEST}.json`)) : undefined
+        };
+        const { serverRuntimeConfig , publicRuntimeConfig  } = nextConfig;
+        if (Object.keys(publicRuntimeConfig).length > 0) {
+            renderOpts.runtimeConfig = publicRuntimeConfig;
+        }
+        globalThis.__NEXT_DATA__ = {
+            nextExport: true
+        };
+        if (!options.silent && !options.buildExport) {
+            Log.info(`Launching ${threads} workers`);
+        }
+        const exportPathMap = await nextExportSpan.traceChild("run-export-path-map").traceAsyncFn(async ()=>{
+            const exportMap = await nextConfig.exportPathMap(defaultPathMap, {
+                dev: false,
+                dir,
+                outDir,
+                distDir,
+                buildId
+            });
+            return exportMap;
+        });
+        if (options.buildExport && hasAppDir) {
+            // @ts-expect-error untyped
+            renderOpts.serverComponentManifest = require((0, _path).join(distDir, _constants1.SERVER_DIRECTORY, `${_constants1.FLIGHT_MANIFEST}.json`));
+            // @ts-expect-error untyped
+            renderOpts.serverCSSManifest = require((0, _path).join(distDir, _constants1.SERVER_DIRECTORY, _constants1.FLIGHT_SERVER_CSS_MANIFEST + ".json"));
+        }
+        // only add missing 404 page when `buildExport` is false
+        if (!options.buildExport) {
+            // only add missing /404 if not specified in `exportPathMap`
+            if (!exportPathMap["/404"]) {
+                exportPathMap["/404"] = {
+                    page: "/_error"
+                };
+            }
+            /**
+       * exports 404.html for backwards compat
+       * E.g. GitHub Pages, GitLab Pages, Cloudflare Pages, Netlify
+       */ if (!exportPathMap["/404.html"]) {
+                // alias /404.html to /404 to be compatible with custom 404 / _error page
+                exportPathMap["/404.html"] = exportPathMap["/404"];
+            }
+        }
+        // make sure to prevent duplicates
+        const exportPaths = [
+            ...new Set(Object.keys(exportPathMap).map((path)=>(0, _denormalizePagePath).denormalizePagePath((0, _normalizePagePath).normalizePagePath(path)))), 
+        ];
+        const filteredPaths = exportPaths.filter(// Remove API routes
+        (route)=>!(0, _isApiRoute).isAPIRoute(exportPathMap[route].page));
+        if (filteredPaths.length !== exportPaths.length) {
+            hasApiRoutes = true;
+        }
+        if (filteredPaths.length === 0) {
+            return;
+        }
+        if (prerenderManifest && !options.buildExport) {
+            const fallbackEnabledPages = new Set();
+            for (const path of Object.keys(exportPathMap)){
+                const page = exportPathMap[path].page;
+                const prerenderInfo = prerenderManifest.dynamicRoutes[page];
+                if (prerenderInfo && prerenderInfo.fallback !== false) {
+                    fallbackEnabledPages.add(page);
+                }
+            }
+            if (fallbackEnabledPages.size) {
+                throw new Error(`Found pages with \`fallback\` enabled:\n${[
+                    ...fallbackEnabledPages, 
+                ].join("\n")}\n${_constants.SSG_FALLBACK_EXPORT_ERROR}\n`);
+            }
+        }
+        // Warn if the user defines a path for an API page
+        if (hasApiRoutes) {
+            if (!options.silent) {
+                Log.warn(_chalk.default.yellow(`Statically exporting a Next.js application via \`next export\` disables API routes.`) + `\n` + _chalk.default.yellow(`This command is meant for static-only hosts, and is` + " " + _chalk.default.bold(`not necessary to make your application static.`)) + `\n` + _chalk.default.yellow(`Pages in your application without server-side data dependencies will be automatically statically exported by \`next build\`, including pages powered by \`getStaticProps\`.`) + `\n` + _chalk.default.yellow(`Learn more: https://nextjs.org/docs/messages/api-routes-static-export`));
+            }
+        }
+        const progress = !options.silent && createProgress(filteredPaths.length, `${Log.prefixes.info} ${options.statusMessage || "Exporting"}`);
+        const pagesDataDir = options.buildExport ? outDir : (0, _path).join(outDir, "_next/data", buildId);
+        const ampValidations = {};
+        let hadValidationError = false;
+        const publicDir = (0, _path).join(dir, _constants1.CLIENT_PUBLIC_FILES_PATH);
+        // Copy public directory
+        if (!options.buildExport && (0, _fs).existsSync(publicDir)) {
+            if (!options.silent) {
+                Log.info('Copying "public" directory');
+            }
+            await nextExportSpan.traceChild("copy-public-directory").traceAsyncFn(()=>(0, _recursiveCopy).recursiveCopy(publicDir, outDir, {
+                    filter (path) {
+                        // Exclude paths used by pages
+                        return !exportPathMap[path];
+                    }
+                }));
+        }
+        const timeout = (configuration == null ? void 0 : configuration.staticPageGenerationTimeout) || 0;
+        let infoPrinted = false;
+        let exportPage;
+        let endWorker;
+        if (options.exportPageWorker) {
+            exportPage = options.exportPageWorker;
+            endWorker = options.endWorker || (()=>Promise.resolve());
+        } else {
+            const worker = new _worker.Worker(require.resolve("./worker"), {
+                timeout: timeout * 1000,
+                onRestart: (_method, [{ path  }], attempts)=>{
+                    if (attempts >= 3) {
+                        throw new Error(`Static page generation for ${path} is still timing out after 3 attempts. See more info here https://nextjs.org/docs/messages/static-page-generation-timeout`);
+                    }
+                    Log.warn(`Restarted static page generation for ${path} because it took more than ${timeout} seconds`);
+                    if (!infoPrinted) {
+                        Log.warn("See more info here https://nextjs.org/docs/messages/static-page-generation-timeout");
+                        infoPrinted = true;
+                    }
+                },
+                maxRetries: 0,
+                numWorkers: threads,
+                enableWorkerThreads: nextConfig.experimental.workerThreads,
+                exposedMethods: [
+                    "default"
+                ]
+            });
+            exportPage = worker.default.bind(worker);
+            endWorker = async ()=>{
+                await worker.end();
+            };
+        }
+        let renderError = false;
+        const errorPaths = [];
+        await Promise.all(filteredPaths.map(async (path)=>{
+            const pageExportSpan = nextExportSpan.traceChild("export-page");
+            pageExportSpan.setAttribute("path", path);
+            return pageExportSpan.traceAsyncFn(async ()=>{
+                const pathMap = exportPathMap[path];
+                const result = await exportPage({
+                    path,
+                    pathMap,
+                    distDir,
+                    outDir,
+                    pagesDataDir,
+                    renderOpts,
+                    serverRuntimeConfig,
+                    subFolders,
+                    buildExport: options.buildExport,
+                    optimizeFonts: nextConfig.optimizeFonts,
+                    optimizeCss: nextConfig.experimental.optimizeCss,
+                    disableOptimizedLoading: nextConfig.experimental.disableOptimizedLoading,
+                    parentSpanId: pageExportSpan.id,
+                    httpAgentOptions: nextConfig.httpAgentOptions,
+                    serverComponents: hasAppDir,
+                    appPaths: options.appPaths || [],
+                    enableUndici: nextConfig.experimental.enableUndici
+                });
+                for (const validation of result.ampValidations || []){
+                    const { page , result: ampValidationResult  } = validation;
+                    ampValidations[page] = ampValidationResult;
+                    hadValidationError = hadValidationError || Array.isArray(ampValidationResult == null ? void 0 : ampValidationResult.errors) && ampValidationResult.errors.length > 0;
+                }
+                renderError = renderError || !!result.error;
+                if (!!result.error) {
+                    const { page  } = pathMap;
+                    errorPaths.push(page !== path ? `${page}: ${path}` : path);
+                }
+                if (options.buildExport && configuration) {
+                    if (typeof result.fromBuildExportRevalidate !== "undefined") {
+                        configuration.initialPageRevalidationMap[path] = result.fromBuildExportRevalidate;
+                    }
+                    if (result.ssgNotFound === true) {
+                        configuration.ssgNotFoundPaths.push(path);
+                    }
+                    const durations = configuration.pageDurationMap[pathMap.page] = configuration.pageDurationMap[pathMap.page] || {};
+                    durations[path] = result.duration;
+                }
+                if (progress) progress();
+            });
+        }));
+        const endWorkerPromise = endWorker();
+        // copy prerendered routes to outDir
+        if (!options.buildExport && prerenderManifest) {
+            await Promise.all(Object.keys(prerenderManifest.routes).map(async (route)=>{
+                const { srcRoute  } = prerenderManifest.routes[route];
+                const pageName = srcRoute || route;
+                // returning notFound: true from getStaticProps will not
+                // output html/json files during the build
+                if (prerenderManifest.notFoundRoutes.includes(route)) {
+                    return;
+                }
+                route = (0, _normalizePagePath).normalizePagePath(route);
+                const pagePath = (0, _require).getPagePath(pageName, distDir);
+                const distPagesDir = (0, _path).join(pagePath, // strip leading / and then recurse number of nested dirs
+                // to place from base folder
+                pageName.slice(1).split("/").map(()=>"..").join("/"));
+                const orig = (0, _path).join(distPagesDir, route);
+                const htmlDest = (0, _path).join(outDir, `${route}${subFolders && route !== "/index" ? `${_path.sep}index` : ""}.html`);
+                const ampHtmlDest = (0, _path).join(outDir, `${route}.amp${subFolders ? `${_path.sep}index` : ""}.html`);
+                const jsonDest = (0, _path).join(pagesDataDir, `${route}.json`);
+                await _fs.promises.mkdir((0, _path).dirname(htmlDest), {
+                    recursive: true
+                });
+                await _fs.promises.mkdir((0, _path).dirname(jsonDest), {
+                    recursive: true
+                });
+                const htmlSrc = `${orig}.html`;
+                const jsonSrc = `${orig}.json`;
+                await _fs.promises.copyFile(htmlSrc, htmlDest);
+                await _fs.promises.copyFile(jsonSrc, jsonDest);
+                if (await exists(`${orig}.amp.html`)) {
+                    await _fs.promises.mkdir((0, _path).dirname(ampHtmlDest), {
+                        recursive: true
+                    });
+                    await _fs.promises.copyFile(`${orig}.amp.html`, ampHtmlDest);
+                }
+            }));
+        }
+        if (Object.keys(ampValidations).length) {
+            console.log((0, _index).formatAmpMessages(ampValidations));
+        }
+        if (hadValidationError) {
+            throw new Error(`AMP Validation caused the export to fail. https://nextjs.org/docs/messages/amp-export-validation`);
+        }
+        if (renderError) {
+            throw new Error(`Export encountered errors on following paths:\n\t${errorPaths.sort().join("\n	")}`);
+        }
+        (0, _fs).writeFileSync((0, _path).join(distDir, _constants1.EXPORT_DETAIL), JSON.stringify({
+            version: 1,
+            outDirectory: outDir,
+            success: true
+        }), "utf8");
+        if (telemetry) {
+            await telemetry.flush();
+        }
+        await endWorkerPromise;
+    });
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache() {
+    if (typeof WeakMap !== "function") return null;
+    var cache = new WeakMap();
+    _getRequireWildcardCache = function() {
+        return cache;
+    };
+    return cache;
+}
+function _interopRequireWildcard(obj) {
+    if (obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache();
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (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;
+}
+(0, _requireHook).loadRequireHook();
+if (process.env.NEXT_PREBUNDLED_REACT) {
+    (0, _requireHook).overrideBuiltInReactPackages();
+}
+const exists = (0, _util).promisify(_fs.exists);
+function divideSegments(number, segments) {
+    const result = [];
+    while(number > 0 && segments > 0){
+        const dividedNumber = number < segments ? number : Math.floor(number / segments);
+        number -= dividedNumber;
+        segments--;
+        result.push(dividedNumber);
+    }
+    return result;
+}
+const createProgress = (total, label)=>{
+    const segments = divideSegments(total, 4);
+    if (total === 0) {
+        throw new Error("invariant: progress total can not be zero");
+    }
+    let currentSegmentTotal = segments.shift();
+    let currentSegmentCount = 0;
+    let lastProgressOutput = Date.now();
+    let curProgress = 0;
+    let progressSpinner = (0, _spinner).default(`${label} (${curProgress}/${total})`, {
+        spinner: {
+            frames: [
+                "[    ]",
+                "[=   ]",
+                "[==  ]",
+                "[=== ]",
+                "[ ===]",
+                "[  ==]",
+                "[   =]",
+                "[    ]",
+                "[   =]",
+                "[  ==]",
+                "[ ===]",
+                "[====]",
+                "[=== ]",
+                "[==  ]",
+                "[=   ]", 
+            ],
+            interval: 500
+        }
+    });
+    return ()=>{
+        curProgress++;
+        // Make sure we only log once
+        // - per fully generated segment, or
+        // - per minute
+        // when not showing the spinner
+        if (!progressSpinner) {
+            currentSegmentCount++;
+            if (currentSegmentCount === currentSegmentTotal) {
+                currentSegmentTotal = segments.shift();
+                currentSegmentCount = 0;
+            } else if (lastProgressOutput + 60000 > Date.now()) {
+                return;
+            }
+            lastProgressOutput = Date.now();
+        }
+        const newText = `${label} (${curProgress}/${total})`;
+        if (progressSpinner) {
+            progressSpinner.text = newText;
+        } else {
+            console.log(newText);
+        }
+        if (curProgress === total && progressSpinner) {
+            progressSpinner.stop();
+            console.log(newText);
+        }
+    };
+};
+
+//# sourceMappingURL=index.js.map

kitabcitab/node_modules/next/dist/export/worker.d.ts

@@ -0,0 +1,68 @@
+import type { FontManifest, FontConfig } from '../server/font-utils';
+import type { DomainLocale, NextConfigComplete } from '../server/config-shared';
+import type { NextParsedUrlQuery } from '../server/request-meta';
+import '../server/node-polyfill-fetch';
+import AmpHtmlValidator from 'next/dist/compiled/amphtml-validator';
+interface AmpValidation {
+    page: string;
+    result: {
+        errors: AmpHtmlValidator.ValidationError[];
+        warnings: AmpHtmlValidator.ValidationError[];
+    };
+}
+interface PathMap {
+    page: string;
+    query?: NextParsedUrlQuery;
+}
+interface ExportPageInput {
+    path: string;
+    pathMap: PathMap;
+    distDir: string;
+    outDir: string;
+    pagesDataDir: string;
+    renderOpts: RenderOpts;
+    buildExport?: boolean;
+    serverRuntimeConfig: {
+        [key: string]: any;
+    };
+    subFolders?: boolean;
+    optimizeFonts: FontConfig;
+    optimizeCss: any;
+    disableOptimizedLoading: any;
+    parentSpanId: any;
+    httpAgentOptions: NextConfigComplete['httpAgentOptions'];
+    serverComponents?: boolean;
+    appPaths: string[];
+    enableUndici: NextConfigComplete['experimental']['enableUndici'];
+}
+interface ExportPageResults {
+    ampValidations: AmpValidation[];
+    fromBuildExportRevalidate?: number;
+    error?: boolean;
+    ssgNotFound?: boolean;
+    duration: number;
+}
+interface RenderOpts {
+    runtimeConfig?: {
+        [key: string]: any;
+    };
+    params?: {
+        [key: string]: string | string[];
+    };
+    ampPath?: string;
+    ampValidatorPath?: string;
+    ampSkipValidation?: boolean;
+    optimizeFonts?: FontConfig;
+    disableOptimizedLoading?: boolean;
+    optimizeCss?: any;
+    fontManifest?: FontManifest;
+    locales?: string[];
+    locale?: string;
+    defaultLocale?: string;
+    domainLocales?: DomainLocale[];
+    trailingSlash?: boolean;
+    supportsDynamicHTML?: boolean;
+    incrementalCache?: import('../server/lib/incremental-cache').IncrementalCache;
+}
+export default function exportPage({ parentSpanId, path, pathMap, distDir, outDir, pagesDataDir, renderOpts, buildExport, serverRuntimeConfig, subFolders, optimizeFonts, optimizeCss, disableOptimizedLoading, httpAgentOptions, serverComponents, enableUndici, }: ExportPageInput): Promise<ExportPageResults>;
+export {};

kitabcitab/node_modules/next/dist/export/worker.js

@@ -0,0 +1,424 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = exportPage;
+require("../server/node-polyfill-fetch");
+var _requireHook = require("../build/webpack/require-hook");
+var _path = require("path");
+var _fs = _interopRequireWildcard(require("fs"));
+var _amphtmlValidator = _interopRequireDefault(require("next/dist/compiled/amphtml-validator"));
+var _loadComponents = require("../server/load-components");
+var _isDynamic = require("../shared/lib/router/utils/is-dynamic");
+var _routeMatcher = require("../shared/lib/router/utils/route-matcher");
+var _routeRegex = require("../shared/lib/router/utils/route-regex");
+var _normalizePagePath = require("../shared/lib/page-path/normalize-page-path");
+var _constants = require("../lib/constants");
+var _require = require("../server/require");
+var _normalizeLocalePath = require("../shared/lib/i18n/normalize-locale-path");
+var _trace = require("../trace");
+var _ampMode = require("../shared/lib/amp-mode");
+var _config = require("../server/config");
+var _renderResult = _interopRequireDefault(require("../server/render-result"));
+var _isError = _interopRequireDefault(require("../lib/is-error"));
+var _requestMeta = require("../server/request-meta");
+var _appPaths = require("../shared/lib/router/utils/app-paths");
+var _redirect = require("../client/components/redirect");
+var _hooksServerContext = require("../client/components/hooks-server-context");
+var _notFound = require("../client/components/not-found");
+var _noSsrError = require("../shared/lib/no-ssr-error");
+var _incrementalCache = require("../server/lib/incremental-cache");
+async function exportPage({ parentSpanId , path , pathMap , distDir , outDir , pagesDataDir , renderOpts , buildExport , serverRuntimeConfig , subFolders , optimizeFonts , optimizeCss , disableOptimizedLoading , httpAgentOptions , serverComponents , enableUndici  }) {
+    (0, _config).setHttpClientAndAgentOptions({
+        httpAgentOptions,
+        experimental: {
+            enableUndici
+        }
+    });
+    const exportPageSpan = (0, _trace).trace("export-page-worker", parentSpanId);
+    return exportPageSpan.traceAsyncFn(async ()=>{
+        const start = Date.now();
+        let results = {
+            ampValidations: []
+        };
+        try {
+            var ref4, ref1, ref2;
+            const { query: originalQuery = {}  } = pathMap;
+            const { page  } = pathMap;
+            const isAppDir = pathMap._isAppDir;
+            const isDynamicError = pathMap._isDynamicError;
+            const filePath = (0, _normalizePagePath).normalizePagePath(path);
+            const isDynamic = (0, _isDynamic).isDynamicRoute(page);
+            const ampPath = `${filePath}.amp`;
+            let renderAmpPath = ampPath;
+            let query = {
+                ...originalQuery
+            };
+            let params;
+            if (isAppDir) {
+                outDir = (0, _path).join(distDir, "server/app");
+            }
+            let updatedPath = query.__nextSsgPath || path;
+            let locale = query.__nextLocale || renderOpts.locale;
+            delete query.__nextLocale;
+            delete query.__nextSsgPath;
+            if (renderOpts.locale) {
+                const localePathResult = (0, _normalizeLocalePath).normalizeLocalePath(path, renderOpts.locales);
+                if (localePathResult.detectedLocale) {
+                    updatedPath = localePathResult.pathname;
+                    locale = localePathResult.detectedLocale;
+                    if (locale === renderOpts.defaultLocale) {
+                        renderAmpPath = `${(0, _normalizePagePath).normalizePagePath(updatedPath)}.amp`;
+                    }
+                }
+            }
+            // We need to show a warning if they try to provide query values
+            // for an auto-exported page since they won't be available
+            const hasOrigQueryValues = Object.keys(originalQuery).length > 0;
+            const queryWithAutoExportWarn = ()=>{
+                if (hasOrigQueryValues) {
+                    throw new Error(`\nError: you provided query values for ${path} which is an auto-exported page. These can not be applied since the page can no longer be re-rendered on the server. To disable auto-export for this page add \`getInitialProps\`\n`);
+                }
+            };
+            // Check if the page is a specified dynamic route
+            const nonLocalizedPath = (0, _normalizeLocalePath).normalizeLocalePath(path, renderOpts.locales).pathname;
+            if (isDynamic && page !== nonLocalizedPath) {
+                const normalizedPage = isAppDir ? (0, _appPaths).normalizeAppPath(page) : page;
+                params = (0, _routeMatcher).getRouteMatcher((0, _routeRegex).getRouteRegex(normalizedPage))(updatedPath) || undefined;
+                if (params) {
+                    query = {
+                        ...query,
+                        ...params
+                    };
+                } else {
+                    throw new Error(`The provided export path '${updatedPath}' doesn't match the '${page}' page.\nRead more: https://nextjs.org/docs/messages/export-path-mismatch`);
+                }
+            }
+            const headerMocks = {
+                headers: {},
+                getHeader: ()=>({}),
+                setHeader: ()=>{},
+                hasHeader: ()=>false,
+                removeHeader: ()=>{},
+                getHeaderNames: ()=>[]
+            };
+            const req = {
+                url: updatedPath,
+                ...headerMocks
+            };
+            const res = {
+                ...headerMocks
+            };
+            if (updatedPath === "/500" && page === "/_error") {
+                res.statusCode = 500;
+            }
+            if (renderOpts.trailingSlash && !((ref4 = req.url) == null ? void 0 : ref4.endsWith("/"))) {
+                req.url += "/";
+            }
+            if (locale && buildExport && renderOpts.domainLocales && renderOpts.domainLocales.some((dl)=>{
+                var ref;
+                return dl.defaultLocale === locale || ((ref = dl.locales) == null ? void 0 : ref.includes(locale || ""));
+            })) {
+                (0, _requestMeta).addRequestMeta(req, "__nextIsLocaleDomain", true);
+            }
+            envConfig.setConfig({
+                serverRuntimeConfig,
+                publicRuntimeConfig: renderOpts.runtimeConfig
+            });
+            const getHtmlFilename = (_path1)=>subFolders ? `${_path1}${_path.sep}index.html` : `${_path1}.html`;
+            let htmlFilename = getHtmlFilename(filePath);
+            // dynamic routes can provide invalid extensions e.g. /blog/[...slug] returns an
+            // extension of `.slug]`
+            const pageExt = isDynamic ? "" : (0, _path).extname(page);
+            const pathExt = isDynamic ? "" : (0, _path).extname(path);
+            // force output 404.html for backwards compat
+            if (path === "/404.html") {
+                htmlFilename = path;
+            } else if (pageExt !== pathExt && pathExt !== "") {
+                const isBuiltinPaths = [
+                    "/500",
+                    "/404"
+                ].some((p)=>p === path || p === path + ".html");
+                // If the ssg path has .html extension, and it's not builtin paths, use it directly
+                // Otherwise, use that as the filename instead
+                const isHtmlExtPath = !isBuiltinPaths && path.endsWith(".html");
+                htmlFilename = isHtmlExtPath ? getHtmlFilename(path) : path;
+            } else if (path === "/") {
+                // If the path is the root, just use index.html
+                htmlFilename = "index.html";
+            }
+            const baseDir = (0, _path).join(outDir, (0, _path).dirname(htmlFilename));
+            let htmlFilepath = (0, _path).join(outDir, htmlFilename);
+            await _fs.promises.mkdir(baseDir, {
+                recursive: true
+            });
+            let renderResult;
+            let curRenderOpts = {};
+            const { renderToHTML  } = require("../server/render");
+            let renderMethod = renderToHTML;
+            let inAmpMode = false, hybridAmp = false;
+            const renderedDuringBuild = (getStaticProps)=>{
+                return !buildExport && getStaticProps && !(0, _isDynamic).isDynamicRoute(path);
+            };
+            const components = await (0, _loadComponents).loadComponents({
+                distDir,
+                pathname: page,
+                hasServerComponents: !!serverComponents,
+                isAppPath: isAppDir
+            });
+            curRenderOpts = {
+                ...components,
+                ...renderOpts,
+                ampPath: renderAmpPath,
+                params,
+                optimizeFonts,
+                optimizeCss,
+                disableOptimizedLoading,
+                fontManifest: optimizeFonts ? (0, _require).requireFontManifest(distDir) : null,
+                locale: locale,
+                supportsDynamicHTML: false
+            };
+            // during build we attempt rendering app dir paths
+            // and bail when dynamic dependencies are detected
+            // only fully static paths are fully generated here
+            if (isAppDir) {
+                curRenderOpts.incrementalCache = new _incrementalCache.IncrementalCache({
+                    dev: false,
+                    requestHeaders: {},
+                    flushToDisk: true,
+                    maxMemoryCacheSize: 50 * 1024 * 1024,
+                    getPrerenderManifest: ()=>({
+                            version: 3,
+                            routes: {},
+                            dynamicRoutes: {},
+                            preview: {
+                                previewModeEncryptionKey: "",
+                                previewModeId: "",
+                                previewModeSigningKey: ""
+                            },
+                            notFoundRoutes: []
+                        }),
+                    fs: {
+                        readFile: (f)=>_fs.default.promises.readFile(f, "utf8"),
+                        readFileSync: (f)=>_fs.default.readFileSync(f, "utf8"),
+                        writeFile: (f, d)=>_fs.default.promises.writeFile(f, d, "utf8"),
+                        mkdir: (dir)=>_fs.default.promises.mkdir(dir, {
+                                recursive: true
+                            }),
+                        stat: (f)=>_fs.default.promises.stat(f)
+                    },
+                    serverDistDir: (0, _path).join(distDir, "server")
+                });
+                const { renderToHTMLOrFlight  } = require("../server/app-render");
+                try {
+                    (_curRenderOpts = curRenderOpts).params || (_curRenderOpts.params = {});
+                    const result = await renderToHTMLOrFlight(req, res, page, query, curRenderOpts);
+                    const html = result == null ? void 0 : result.toUnchunkedString();
+                    const flightData = curRenderOpts.pageData;
+                    const revalidate = curRenderOpts.revalidate;
+                    results.fromBuildExportRevalidate = revalidate;
+                    if (revalidate !== 0) {
+                        await _fs.promises.writeFile(htmlFilepath, html ?? "", "utf8");
+                        await _fs.promises.writeFile(htmlFilepath.replace(/\.html$/, ".rsc"), flightData);
+                    } else if (isDynamicError) {
+                        throw new Error(`Page with dynamic = "error" encountered dynamic data method ${path}.`);
+                    }
+                } catch (err) {
+                    var ref3;
+                    if (err.digest !== _hooksServerContext.DYNAMIC_ERROR_CODE && err.digest !== _notFound.NOT_FOUND_ERROR_CODE && err.digest !== _noSsrError.NEXT_DYNAMIC_NO_SSR_CODE && !((ref3 = err.digest) == null ? void 0 : ref3.startsWith(_redirect.REDIRECT_ERROR_CODE))) {
+                        throw err;
+                    }
+                }
+                return {
+                    ...results,
+                    duration: Date.now() - start
+                };
+            }
+            const ampState = {
+                ampFirst: ((ref1 = components.pageConfig) == null ? void 0 : ref1.amp) === true,
+                hasQuery: Boolean(query.amp),
+                hybrid: ((ref2 = components.pageConfig) == null ? void 0 : ref2.amp) === "hybrid"
+            };
+            inAmpMode = (0, _ampMode).isInAmpMode(ampState);
+            hybridAmp = ampState.hybrid;
+            if (components.getServerSideProps) {
+                throw new Error(`Error for page ${page}: ${_constants.SERVER_PROPS_EXPORT_ERROR}`);
+            }
+            // for non-dynamic SSG pages we should have already
+            // prerendered the file
+            if (renderedDuringBuild(components.getStaticProps)) {
+                return {
+                    ...results,
+                    duration: Date.now() - start
+                };
+            }
+            // TODO: de-dupe the logic here between serverless and server mode
+            if (components.getStaticProps && !htmlFilepath.endsWith(".html")) {
+                // make sure it ends with .html if the name contains a dot
+                htmlFilepath += ".html";
+                htmlFilename += ".html";
+            }
+            if (typeof components.Component === "string") {
+                renderResult = _renderResult.default.fromStatic(components.Component);
+                queryWithAutoExportWarn();
+            } else {
+                /**
+         * This sets environment variable to be used at the time of static export by head.tsx.
+         * Using this from process.env allows targeting both serverless and SSR by calling
+         * `process.env.__NEXT_OPTIMIZE_FONTS`.
+         * TODO(prateekbh@): Remove this when experimental.optimizeFonts are being cleaned up.
+         */ if (optimizeFonts) {
+                    process.env.__NEXT_OPTIMIZE_FONTS = JSON.stringify(optimizeFonts);
+                }
+                if (optimizeCss) {
+                    process.env.__NEXT_OPTIMIZE_CSS = JSON.stringify(true);
+                }
+                try {
+                    renderResult = await renderMethod(req, res, page, query, // @ts-ignore
+                    curRenderOpts);
+                } catch (err) {
+                    if (err.digest !== _noSsrError.NEXT_DYNAMIC_NO_SSR_CODE) {
+                        throw err;
+                    }
+                }
+            }
+            results.ssgNotFound = curRenderOpts.isNotFound;
+            const validateAmp = async (rawAmpHtml, ampPageName, validatorPath)=>{
+                const validator = await _amphtmlValidator.default.getInstance(validatorPath);
+                const result = validator.validateString(rawAmpHtml);
+                const errors = result.errors.filter((e)=>e.severity === "ERROR");
+                const warnings = result.errors.filter((e)=>e.severity !== "ERROR");
+                if (warnings.length || errors.length) {
+                    results.ampValidations.push({
+                        page: ampPageName,
+                        result: {
+                            errors,
+                            warnings
+                        }
+                    });
+                }
+            };
+            const html = renderResult ? renderResult.toUnchunkedString() : "";
+            if (inAmpMode && !curRenderOpts.ampSkipValidation) {
+                if (!results.ssgNotFound) {
+                    await validateAmp(html, path, curRenderOpts.ampValidatorPath);
+                }
+            } else if (hybridAmp) {
+                // we need to render the AMP version
+                let ampHtmlFilename = `${ampPath}${_path.sep}index.html`;
+                if (!subFolders) {
+                    ampHtmlFilename = `${ampPath}.html`;
+                }
+                const ampBaseDir = (0, _path).join(outDir, (0, _path).dirname(ampHtmlFilename));
+                const ampHtmlFilepath = (0, _path).join(outDir, ampHtmlFilename);
+                try {
+                    await _fs.promises.access(ampHtmlFilepath);
+                } catch (_) {
+                    let ampRenderResult;
+                    // make sure it doesn't exist from manual mapping
+                    try {
+                        ampRenderResult = await renderMethod(req, res, page, // @ts-ignore
+                        {
+                            ...query,
+                            amp: "1"
+                        }, curRenderOpts);
+                    } catch (err) {
+                        if (err.digest !== _noSsrError.NEXT_DYNAMIC_NO_SSR_CODE) {
+                            throw err;
+                        }
+                    }
+                    const ampHtml = ampRenderResult ? ampRenderResult.toUnchunkedString() : "";
+                    if (!curRenderOpts.ampSkipValidation) {
+                        await validateAmp(ampHtml, page + "?amp=1");
+                    }
+                    await _fs.promises.mkdir(ampBaseDir, {
+                        recursive: true
+                    });
+                    await _fs.promises.writeFile(ampHtmlFilepath, ampHtml, "utf8");
+                }
+            }
+            if (curRenderOpts.pageData) {
+                const dataFile = (0, _path).join(pagesDataDir, htmlFilename.replace(/\.html$/, ".json"));
+                await _fs.promises.mkdir((0, _path).dirname(dataFile), {
+                    recursive: true
+                });
+                await _fs.promises.writeFile(dataFile, JSON.stringify(curRenderOpts.pageData), "utf8");
+                if (hybridAmp) {
+                    await _fs.promises.writeFile(dataFile.replace(/\.json$/, ".amp.json"), JSON.stringify(curRenderOpts.pageData), "utf8");
+                }
+            }
+            results.fromBuildExportRevalidate = curRenderOpts.revalidate;
+            if (!results.ssgNotFound) {
+                // don't attempt writing to disk if getStaticProps returned not found
+                await _fs.promises.writeFile(htmlFilepath, html, "utf8");
+            }
+        } catch (error) {
+            console.error(`\nError occurred prerendering page "${path}". Read more: https://nextjs.org/docs/messages/prerender-error\n` + ((0, _isError).default(error) && error.stack ? error.stack : error));
+            results.error = true;
+        }
+        return {
+            ...results,
+            duration: Date.now() - start
+        };
+    });
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache() {
+    if (typeof WeakMap !== "function") return null;
+    var cache = new WeakMap();
+    _getRequireWildcardCache = function() {
+        return cache;
+    };
+    return cache;
+}
+function _interopRequireWildcard(obj) {
+    if (obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache();
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (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;
+}
+var _curRenderOpts;
+// `NEXT_PREBUNDLED_REACT` env var is inherited from parent process,
+// then override react packages here for export worker.
+if (process.env.NEXT_PREBUNDLED_REACT) {
+    require("../build/webpack/require-hook").overrideBuiltInReactPackages();
+}
+(0, _requireHook).loadRequireHook();
+const envConfig = require("../shared/lib/runtime-config");
+globalThis.__NEXT_DATA__ = {
+    nextExport: true
+};
+// expose AsyncLocalStorage on globalThis for react usage
+const { AsyncLocalStorage  } = require("async_hooks");
+globalThis.AsyncLocalStorage = AsyncLocalStorage;
+
+//# sourceMappingURL=worker.js.map