@serwist/turbopack 9.5.7 → 9.5.9

package/dist/index.js

@@ -1,190 +0,0 @@
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import { rebasePath, getFileManifestEntries } from '@serwist/build';
-import { validationErrorMap, SerwistConfigError } from '@serwist/build/schema';
-import { browserslistToEsbuild } from '@serwist/utils';
-import browserslist from 'browserslist';
-import { cyan, dim, yellow } from 'kolorist';
-import { MODERN_BROWSERSLIST_TARGET } from 'next/constants.js';
-import { NextResponse } from 'next/server.js';
-import { z } from 'zod';
-import { i as injectManifestOptions, l as logger } from './chunks/index.schema.js';
-import 'semver';
-import 'node:module';
-
-let esbuildWasm = null;
-let esbuildNative = null;
-const logSerwistResult = (filePath, buildResult)=>{
-    const { count, size, warnings } = buildResult;
-    const hasWarnings = warnings && warnings.length > 0;
-    if (filePath === "sw.js" && (hasWarnings || count > 0)) {
-        logger[hasWarnings ? "warn" : "event"](`${cyan(count)} precache entries ${dim(`(${(size / 1024).toFixed(2)} KiB)`)}${hasWarnings ? `\n${yellow([
-            "⚠ warnings",
-            ...warnings.map((w)=>`  ${w}`),
-            ""
-        ].join("\n"))}` : ""}`);
-    }
-};
-const validateGetManifestOptions = async (input)=>{
-    const result = await injectManifestOptions.spa(input, {
-        error: validationErrorMap
-    });
-    if (!result.success) {
-        throw new SerwistConfigError({
-            moduleName: "@serwist/turbopack",
-            message: z.prettifyError(result.error)
-        });
-    }
-    return result.data;
-};
-const isDev = process.env.NODE_ENV === "development";
-const contentTypeMap = {
-    ".js": "application/javascript",
-    ".map": "application/json; charset=UTF-8"
-};
-const createSerwistRoute = (options)=>{
-    const dynamic = "force-static", dynamicParams = false, revalidate = false;
-    const validation = validateGetManifestOptions(options).then((config)=>{
-        return {
-            ...config,
-            disablePrecacheManifest: isDev,
-            additionalPrecacheEntries: isDev ? [] : config.additionalPrecacheEntries,
-            globIgnores: [
-                ...config.globIgnores,
-                rebasePath({
-                    file: config.swSrc,
-                    baseDirectory: config.globDirectory
-                })
-            ],
-            manifestTransforms: [
-                ...config.manifestTransforms ?? [],
-                async (manifestEntries)=>{
-                    const manifest = manifestEntries.map((m)=>{
-                        if (m.url.startsWith(config.nextConfig.distDir)) {
-                            m.url = `${config.nextConfig.assetPrefix}/_next/${m.url.slice(config.nextConfig.distDir.length)}`;
-                        }
-                        if (m.url.startsWith("public/")) {
-                            m.url = path.posix.join(config.nextConfig.basePath, m.url.slice(7));
-                        }
-                        return m;
-                    });
-                    return {
-                        manifest,
-                        warnings: []
-                    };
-                }
-            ]
-        };
-    });
-    let lastHash = null;
-    let map = null;
-    const loadMap = async (filePath)=>{
-        const config = await validation;
-        const { count, size, manifestEntries, warnings } = await getFileManifestEntries(config);
-        const injectionPoint = config.injectionPoint || "";
-        const manifestString = manifestEntries === undefined ? "undefined" : JSON.stringify(manifestEntries, null, 2);
-        const log = (type, ...message)=>{
-            if (filePath === "sw.js") {
-                logger[type](...message);
-            }
-        };
-        let esbuild;
-        if (config.useNativeEsbuild) {
-            log("info", "Using esbuild to bundle the service worker.");
-            if (!esbuildNative) esbuildNative = import(/* webpackIgnore: true */ 'esbuild');
-            esbuild = await esbuildNative;
-        } else {
-            log("info", "Using esbuild-wasm to bundle the service worker.");
-            if (!esbuildWasm) esbuildWasm = import(/* webpackIgnore: true */ 'esbuild-wasm');
-            esbuild = await esbuildWasm;
-        }
-        logSerwistResult(filePath, {
-            count,
-            size,
-            warnings
-        });
-        const result = await esbuild.build({
-            sourcemap: true,
-            format: "esm",
-            treeShaking: true,
-            minify: !isDev,
-            bundle: true,
-            ...config.esbuildOptions,
-            target: config.esbuildOptions?.target ?? browserslistToEsbuild(browserslist, config.cwd, MODERN_BROWSERSLIST_TARGET),
-            platform: "browser",
-            define: {
-                ...config.esbuildOptions.define,
-                ...injectionPoint ? {
-                    [injectionPoint]: manifestString
-                } : {}
-            },
-            outdir: config.cwd,
-            write: false,
-            entryNames: "[name]",
-            assetNames: "[name]-[hash]",
-            chunkNames: "[name]-[hash]",
-            entryPoints: [
-                {
-                    in: config.swSrc,
-                    out: "sw"
-                }
-            ]
-        });
-        if (result.errors.length) {
-            console.error("Failed to build the service worker.", result.errors);
-            throw new Error();
-        }
-        if (result.warnings.length) {
-            console.warn(result.warnings);
-        }
-        return new Map(result.outputFiles.map((e)=>[
-                e.path,
-                e.text
-            ]));
-    };
-    const generateStaticParams = async ()=>{
-        const config = await validation;
-        if (!map) map = await loadMap("root");
-        return [
-            ...map.keys()
-        ].map((e)=>({
-                path: path.relative(config.cwd, e)
-            }));
-    };
-    const GET = async (_, { params })=>{
-        const { path: filePath } = await params;
-        const config = await validation;
-        if (isDev && config.rebuildOnChange) {
-            const swContent = fs.readFileSync(config.swSrc, "utf-8");
-            const currentHash = crypto.createHash("sha256").update(swContent).digest("hex");
-            if (!map || lastHash !== currentHash) {
-                map = await loadMap(filePath);
-                lastHash = currentHash;
-            }
-        } else if (!map) map = await loadMap(filePath);
-        return new NextResponse(map.get(path.join(config.cwd, filePath)), {
-            headers: {
-                "Content-Type": contentTypeMap[path.extname(filePath)] || "text/plain",
-                "Service-Worker-Allowed": "/"
-            }
-        });
-    };
-    return {
-        dynamic,
-        dynamicParams,
-        revalidate,
-        generateStaticParams,
-        GET
-    };
-};
-const withSerwist = (nextConfig = {})=>({
-        ...nextConfig,
-        serverExternalPackages: [
-            ...nextConfig.serverExternalPackages ?? [],
-            "esbuild",
-            "esbuild-wasm"
-        ]
-    });
-
-export { createSerwistRoute, withSerwist };

package/dist/index.react.d.ts

@@ -1,25 +0,0 @@
-import { Serwist } from "@serwist/window";
-import { type ReactNode } from "react";
-import { useSerwist } from "./lib/context.js";
-export interface SerwistProviderProps {
-    swUrl: string;
-    disable?: boolean;
-    register?: boolean;
-    cacheOnNavigation?: boolean;
-    reloadOnOnline?: boolean;
-    options?: RegistrationOptions;
-    children?: ReactNode;
-}
-declare global {
-    interface Window {
-        serwist: Serwist;
-    }
-}
-/**
- * `@serwist/window` provider for Next.js apps.
- * @param options
- * @returns
- */
-export declare function SerwistProvider({ swUrl, disable, register, cacheOnNavigation, reloadOnOnline, options, children, }: SerwistProviderProps): import("react").JSX.Element;
-export { useSerwist };
-//# sourceMappingURL=index.react.d.ts.map

package/dist/index.react.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.react.d.ts","sourceRoot":"","sources":["../src/index.react.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE1C,OAAO,EAAE,KAAK,SAAS,EAAuB,MAAM,OAAO,CAAC;AAC5D,OAAO,EAAkB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9D,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,mBAAmB,CAAC;IAC9B,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,OAAO,EAAE,OAAO,CAAC;KAClB;CACF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAC9B,KAAK,EACL,OAAe,EACf,QAAe,EACf,iBAAwB,EACxB,cAAqB,EACrB,OAAO,EACP,QAAQ,GACT,EAAE,oBAAoB,+BAuDtB;AAED,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/index.react.js

@@ -1,88 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { Serwist } from '@serwist/window';
-import { isCurrentPageOutOfScope } from '@serwist/window/internal';
-import { createContext, useContext, useState, useEffect } from 'react';
-
-const SerwistContext = createContext(null);
-const useSerwist = ()=>{
-    const context = useContext(SerwistContext);
-    if (!context) {
-        throw new Error("[useSerwist]: 'SerwistContext' is not available.");
-    }
-    return context;
-};
-
-function SerwistProvider({ swUrl, disable = false, register = true, cacheOnNavigation = true, reloadOnOnline = true, options, children }) {
-    const [serwist] = useState(()=>{
-        if (typeof window === "undefined") return null;
-        if (disable) return null;
-        const scope = options?.scope || "/";
-        if (!(window.serwist && window.serwist instanceof Serwist) && "serviceWorker" in navigator) {
-            window.serwist = new Serwist(swUrl, {
-                ...options,
-                scope,
-                type: options?.type || "module"
-            });
-            if (register && !isCurrentPageOutOfScope(scope)) {
-                void window.serwist.register();
-            }
-        }
-        return window.serwist ?? null;
-    });
-    useEffect(()=>{
-        const cacheUrls = async (url)=>{
-            if (!window.navigator.onLine || !url) {
-                return;
-            }
-            serwist?.messageSW({
-                type: "CACHE_URLS",
-                payload: {
-                    urlsToCache: [
-                        url
-                    ]
-                }
-            });
-        };
-        const cacheCurrentPathname = ()=>cacheUrls(window.location.pathname);
-        const pushState = history.pushState;
-        const replaceState = history.replaceState;
-        if (cacheOnNavigation) {
-            history.pushState = (...args)=>{
-                pushState.apply(history, args);
-                cacheUrls(args[2]);
-            };
-            history.replaceState = (...args)=>{
-                replaceState.apply(history, args);
-                cacheUrls(args[2]);
-            };
-            window.addEventListener("online", cacheCurrentPathname);
-        }
-        return ()=>{
-            history.pushState = pushState;
-            history.replaceState = replaceState;
-            window.removeEventListener("online", cacheCurrentPathname);
-        };
-    }, [
-        serwist,
-        cacheOnNavigation
-    ]);
-    useEffect(()=>{
-        const reload = ()=>location.reload();
-        if (reloadOnOnline) {
-            window.addEventListener("online", reload);
-        }
-        return ()=>{
-            window.removeEventListener("online", reload);
-        };
-    }, [
-        reloadOnOnline
-    ]);
-    return jsx(SerwistContext.Provider, {
-        value: {
-            serwist
-        },
-        children: children
-    });
-}
-
-export { SerwistProvider, useSerwist };

package/dist/index.schema.d.ts

@@ -1,301 +0,0 @@
-import z from "zod";
-export declare const turboPartial: z.ZodObject<{
-    cwd: z.ZodPrefault<z.ZodString>;
-    nextConfig: z.ZodOptional<z.ZodObject<{
-        assetPrefix: z.ZodOptional<z.ZodString>;
-        basePath: z.ZodOptional<z.ZodString>;
-        distDir: z.ZodOptional<z.ZodString>;
-    }, z.z.core.$strip>>;
-    useNativeEsbuild: z.ZodPrefault<z.ZodBoolean>;
-    rebuildOnChange: z.ZodPrefault<z.ZodBoolean>;
-    esbuildOptions: z.ZodPrefault<z.ZodRecord<z.ZodLiteral<"bundle" | "splitting" | "preserveSymlinks" | "external" | "packages" | "alias" | "loader" | "resolveExtensions" | "mainFields" | "conditions" | "allowOverwrite" | "tsconfig" | "outExtension" | "publicPath" | "inject" | "banner" | "footer" | "plugins" | "sourcemap" | "legalComments" | "sourceRoot" | "sourcesContent" | "format" | "globalName" | "target" | "supported" | "mangleProps" | "reserveProps" | "mangleQuoted" | "mangleCache" | "drop" | "dropLabels" | "minify" | "minifyWhitespace" | "minifyIdentifiers" | "minifySyntax" | "lineLimit" | "charset" | "treeShaking" | "ignoreAnnotations" | "jsx" | "jsxFactory" | "jsxFragment" | "jsxImportSource" | "jsxDev" | "jsxSideEffects" | "define" | "pure" | "keepNames" | "absPaths" | "color" | "logLevel" | "logLimit" | "logOverride" | "tsconfigRaw"> & z.z.core.$partial, z.ZodAny>>;
-}, z.z.core.$strict>;
-export declare const injectManifestOptions: z.ZodPipe<z.ZodObject<{
-    cwd: z.ZodPrefault<z.ZodString>;
-    useNativeEsbuild: z.ZodPrefault<z.ZodBoolean>;
-    rebuildOnChange: z.ZodPrefault<z.ZodBoolean>;
-    esbuildOptions: z.ZodPrefault<z.ZodRecord<z.ZodLiteral<"bundle" | "splitting" | "preserveSymlinks" | "external" | "packages" | "alias" | "loader" | "resolveExtensions" | "mainFields" | "conditions" | "allowOverwrite" | "tsconfig" | "outExtension" | "publicPath" | "inject" | "banner" | "footer" | "plugins" | "sourcemap" | "legalComments" | "sourceRoot" | "sourcesContent" | "format" | "globalName" | "target" | "supported" | "mangleProps" | "reserveProps" | "mangleQuoted" | "mangleCache" | "drop" | "dropLabels" | "minify" | "minifyWhitespace" | "minifyIdentifiers" | "minifySyntax" | "lineLimit" | "charset" | "treeShaking" | "ignoreAnnotations" | "jsx" | "jsxFactory" | "jsxFragment" | "jsxImportSource" | "jsxDev" | "jsxSideEffects" | "define" | "pure" | "keepNames" | "absPaths" | "color" | "logLevel" | "logLimit" | "logOverride" | "tsconfigRaw"> & z.z.core.$partial, z.ZodAny>>;
-    nextConfig: z.ZodOptional<z.ZodObject<{
-        assetPrefix: z.ZodOptional<z.ZodString>;
-        basePath: z.ZodOptional<z.ZodString>;
-        distDir: z.ZodOptional<z.ZodString>;
-    }, z.z.core.$strip>>;
-    additionalPrecacheEntries: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strict>]>>>;
-    dontCacheBustURLsMatching: z.ZodOptional<z.ZodCustom<RegExp, RegExp>>;
-    manifestTransforms: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodCustom<z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$strict>>, z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$strict>>>, z.ZodTransform<z.z.core.$InferOuterFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$strict>>, z.z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$strict>>>>>>;
-    maximumFileSizeToCacheInBytes: z.ZodDefault<z.ZodNumber>;
-    modifyURLPrefix: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    globFollow: z.ZodDefault<z.ZodBoolean>;
-    globIgnores: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    globPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    globStrict: z.ZodDefault<z.ZodBoolean>;
-    templatedURLs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
-    injectionPoint: z.ZodDefault<z.ZodString>;
-    swSrc: z.ZodString;
-    globDirectory: z.ZodOptional<z.ZodString>;
-}, z.z.core.$strict>, z.ZodTransform<{
-    swSrc: string;
-    globPatterns: string[];
-    globDirectory: string;
-    dontCacheBustURLsMatching: RegExp;
-    nextConfig: {
-        distDir: string;
-        basePath: string;
-        assetPrefix: string;
-        allowedDevOrigins: string[];
-        exportPathMap: (defaultMap: import("next/dist/server/config-shared.js").ExportPathMap, ctx: {
-            dev: boolean;
-            dir: string;
-            outDir: string | null;
-            distDir: string;
-            buildId: string;
-        }) => Promise<import("next/dist/server/config-shared.js").ExportPathMap> | import("next/dist/server/config-shared.js").ExportPathMap;
-        i18n: import("next/dist/server/config-shared.js").I18NConfig | null;
-        typescript: import("next/dist/server/config-shared.js").TypeScriptConfig;
-        typedRoutes: boolean;
-        headers: () => Promise<import("next/dist/lib/load-custom-routes.js").Header[]> | import("next/dist/lib/load-custom-routes.js").Header[];
-        rewrites: () => Promise<import("next/dist/lib/load-custom-routes.js").Rewrite[] | {
-            beforeFiles?: import("next/dist/lib/load-custom-routes.js").Rewrite[];
-            afterFiles?: import("next/dist/lib/load-custom-routes.js").Rewrite[];
-            fallback?: import("next/dist/lib/load-custom-routes.js").Rewrite[];
-        }> | import("next/dist/lib/load-custom-routes.js").Rewrite[] | {
-            beforeFiles?: import("next/dist/lib/load-custom-routes.js").Rewrite[];
-            afterFiles?: import("next/dist/lib/load-custom-routes.js").Rewrite[];
-            fallback?: import("next/dist/lib/load-custom-routes.js").Rewrite[];
-        };
-        redirects: () => Promise<import("next/dist/lib/load-custom-routes.js").Redirect[]> | import("next/dist/lib/load-custom-routes.js").Redirect[];
-        excludeDefaultMomentLocales: boolean;
-        webpack: import("next/dist/server/config-shared.js").NextJsWebpackConfig | null;
-        trailingSlash: boolean;
-        env: Record<string, string | undefined>;
-        cleanDistDir: boolean;
-        cacheHandler: string;
-        cacheHandlers: {
-            default?: string;
-            remote?: string;
-            static?: string;
-            [handlerName: string]: string | undefined;
-        };
-        cacheMaxMemorySize: number;
-        useFileSystemPublicRoutes: boolean;
-        generateBuildId: () => string | null | Promise<string | null>;
-        generateEtags: boolean;
-        pageExtensions: string[];
-        compress: boolean;
-        poweredByHeader: boolean;
-        images: Partial<import("next/dist/shared/lib/image-config.js").ImageConfigComplete> & Required<import("next/dist/shared/lib/image-config.js").ImageConfigComplete>;
-        devIndicators: false | {
-            position?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
-        };
-        onDemandEntries: {
-            maxInactiveAge?: number;
-            pagesBufferLength?: number;
-        };
-        deploymentId: string;
-        sassOptions: {
-            implementation?: string;
-            [key: string]: any;
-        };
-        productionBrowserSourceMaps: boolean;
-        reactCompiler: boolean | import("next/dist/server/config-shared.js").ReactCompilerOptions;
-        reactProductionProfiling: boolean;
-        reactStrictMode: boolean | null;
-        reactMaxHeadersLength: number;
-        httpAgentOptions: {
-            keepAlive?: boolean;
-        };
-        staticPageGenerationTimeout: number;
-        crossOrigin: "anonymous" | "use-credentials";
-        compiler: {
-            reactRemoveProperties?: boolean | {
-                properties?: string[];
-            };
-            relay?: {
-                src: string;
-                artifactDirectory?: string;
-                language?: "typescript" | "javascript" | "flow";
-                eagerEsModules?: boolean;
-            };
-            removeConsole?: boolean | {
-                exclude?: string[];
-            };
-            styledComponents?: boolean | import("next/dist/server/config-shared.js").StyledComponentsConfig;
-            emotion?: boolean | import("next/dist/server/config-shared.js").EmotionConfig;
-            styledJsx?: boolean | {
-                useLightningcss?: boolean;
-            };
-            define?: Record<string, string>;
-            defineServer?: Record<string, string>;
-            runAfterProductionCompile?: (metadata: {
-                projectDir: string;
-                distDir: string;
-            }) => Promise<void>;
-        };
-        output: "standalone" | "export";
-        transpilePackages: string[];
-        turbopack: import("next/dist/server/config-shared.js").TurbopackOptions;
-        skipMiddlewareUrlNormalize: boolean;
-        skipProxyUrlNormalize: boolean;
-        skipTrailingSlashRedirect: boolean;
-        modularizeImports: Record<string, {
-            transform: string | Record<string, string>;
-            preventFullImport?: boolean;
-            skipDefaultConversion?: boolean;
-        }>;
-        logging: import("next/dist/server/config-shared.js").LoggingConfig | false;
-        enablePrerenderSourceMaps: boolean;
-        cacheComponents: boolean;
-        cacheLife: {
-            [profile: string]: {
-                stale?: number;
-                revalidate?: number;
-                expire?: number;
-            };
-        };
-        expireTime: number;
-        experimental: import("next/dist/server/config-shared.js").ExperimentalConfig;
-        bundlePagesRouterDependencies: boolean;
-        serverExternalPackages: string[];
-        outputFileTracingRoot: string;
-        outputFileTracingExcludes: Record<string, string[]>;
-        outputFileTracingIncludes: Record<string, string[]>;
-        watchOptions: {
-            pollIntervalMs?: number;
-        };
-        htmlLimitedBots: RegExp & string;
-        configFile: string | undefined;
-        configFileName: string;
-        distDirRoot: string;
-    } | {
-        distDir: string;
-        basePath: string;
-        assetPrefix: string;
-    };
-    cwd: string;
-    useNativeEsbuild: boolean;
-    rebuildOnChange: boolean;
-    esbuildOptions: Partial<Record<"bundle" | "splitting" | "preserveSymlinks" | "external" | "packages" | "alias" | "loader" | "resolveExtensions" | "mainFields" | "conditions" | "allowOverwrite" | "tsconfig" | "outExtension" | "publicPath" | "inject" | "banner" | "footer" | "plugins" | "sourcemap" | "legalComments" | "sourceRoot" | "sourcesContent" | "format" | "globalName" | "target" | "supported" | "mangleProps" | "reserveProps" | "mangleQuoted" | "mangleCache" | "drop" | "dropLabels" | "minify" | "minifyWhitespace" | "minifyIdentifiers" | "minifySyntax" | "lineLimit" | "charset" | "treeShaking" | "ignoreAnnotations" | "jsx" | "jsxFactory" | "jsxFragment" | "jsxImportSource" | "jsxDev" | "jsxSideEffects" | "define" | "pure" | "keepNames" | "absPaths" | "color" | "logLevel" | "logLimit" | "logOverride" | "tsconfigRaw", any>>;
-    maximumFileSizeToCacheInBytes: number;
-    globFollow: boolean;
-    globIgnores: string[];
-    globStrict: boolean;
-    injectionPoint: string;
-    additionalPrecacheEntries?: (string | {
-        url: string;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    })[] | undefined;
-    manifestTransforms?: z.z.core.$InferOuterFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$strict>>[] | undefined;
-    modifyURLPrefix?: Record<string, string> | undefined;
-    templatedURLs?: Record<string, string | string[]> | undefined;
-}, {
-    cwd: string;
-    useNativeEsbuild: boolean;
-    rebuildOnChange: boolean;
-    esbuildOptions: Partial<Record<"bundle" | "splitting" | "preserveSymlinks" | "external" | "packages" | "alias" | "loader" | "resolveExtensions" | "mainFields" | "conditions" | "allowOverwrite" | "tsconfig" | "outExtension" | "publicPath" | "inject" | "banner" | "footer" | "plugins" | "sourcemap" | "legalComments" | "sourceRoot" | "sourcesContent" | "format" | "globalName" | "target" | "supported" | "mangleProps" | "reserveProps" | "mangleQuoted" | "mangleCache" | "drop" | "dropLabels" | "minify" | "minifyWhitespace" | "minifyIdentifiers" | "minifySyntax" | "lineLimit" | "charset" | "treeShaking" | "ignoreAnnotations" | "jsx" | "jsxFactory" | "jsxFragment" | "jsxImportSource" | "jsxDev" | "jsxSideEffects" | "define" | "pure" | "keepNames" | "absPaths" | "color" | "logLevel" | "logLimit" | "logOverride" | "tsconfigRaw", any>>;
-    maximumFileSizeToCacheInBytes: number;
-    globFollow: boolean;
-    globIgnores: string[];
-    globStrict: boolean;
-    injectionPoint: string;
-    swSrc: string;
-    nextConfig?: {
-        assetPrefix?: string | undefined;
-        basePath?: string | undefined;
-        distDir?: string | undefined;
-    } | undefined;
-    additionalPrecacheEntries?: (string | {
-        url: string;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    })[] | undefined;
-    dontCacheBustURLsMatching?: RegExp | undefined;
-    manifestTransforms?: z.z.core.$InferOuterFunctionTypeAsync<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        size: z.ZodNumber;
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, z.z.core.$strip>>, z.ZodOptional<z.ZodUnknown>], null>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            size: z.ZodNumber;
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        }, z.z.core.$strip>>;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.z.core.$strict>>[] | undefined;
-    modifyURLPrefix?: Record<string, string> | undefined;
-    globPatterns?: string[] | undefined;
-    templatedURLs?: Record<string, string | string[]> | undefined;
-    globDirectory?: string | undefined;
-}>>;
-//# sourceMappingURL=index.schema.d.ts.map

package/dist/index.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.schema.d.ts","sourceRoot":"","sources":["../src/index.schema.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAC;AAMpB,eAAO,MAAM,YAAY;;;;;;;;;;oBAYvB,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBA8C6o0B,CAAC;sBAA+B,CAAC;oBAA6B,CAAC;;uBAAuD,CAAC;sBAA+B,CAAC;oBAA6B,CAAC;;;;;;;;;;mBAA+5E,CAAC;kBAAwB,CAAC;kBAAwB,CAAC;;;;;;;;;;;;oBAAo9D,CAAC;;;0BAAie,CAAC;6BAA4H,CAAC;;;;0BAAkiB,CAAC;;;;;;;;;qBAA4+C,CAAC;;;;;iCAA+sB,CAAC;0BAAoC,CAAC;;iBAAoC,CAAC;;iCAA0D,CAAC;wBAA8B,CAAC;8BAAkE,CAAC;;yBAA2C,CAAC;uBAAiC,CAAC;;4BAA+C,CAAC;mBAAmD,CAAC;qBAA4C,CAAC;+BAAyC,CAAC;;kBAA6L,CAAC;wBAAsO,CAAC;qCAA2R,CAAC;;;;;;;;;;;;;6BAAm0D,CAAC;iCAAwC,CAAC;;;;;;;qBAAowB,CAAC;0BAAgC,CAAC;sBAA4B,CAAC;;;;;;;;;;;0BAA21C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GANnwuC,CAAC"}

package/dist/index.schema.js

@@ -1,8 +0,0 @@
-import 'node:path';
-import '@serwist/build/schema';
-import 'semver';
-import 'zod';
-export { i as injectManifestOptions, t as turboPartial } from './chunks/index.schema.js';
-import 'node:module';
-import 'kolorist';
-import 'next/constants.js';

package/dist/index.worker.d.ts

@@ -1,14 +0,0 @@
-import type { RuntimeCaching } from "serwist";
-export declare const PAGES_CACHE_NAME: {
-    readonly rscPrefetch: "pages-rsc-prefetch";
-    readonly rsc: "pages-rsc";
-    readonly html: "pages";
-};
-/**
- * The default, recommended list of caching strategies for applications
- * built with Next.js.
- *
- * @see https://serwist.pages.dev/docs/next/worker-exports#default-cache
- */
-export declare const defaultCache: RuntimeCaching[];
-//# sourceMappingURL=index.worker.d.ts.map

package/dist/index.worker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.worker.d.ts","sourceRoot":"","sources":["../src/index.worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAG9C,eAAO,MAAM,gBAAgB;;;;CAInB,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,cAAc,EAkQlC,CAAC"}