@serwist/build 9.0.0-preview.0 → 9.0.0-preview.10

package/dist/chunks/glob.js

@@ -51,8 +51,6 @@ const globPartial = z.object({
 z.object({
     globDirectory: z.string().optional()
 }).strict("Do not pass invalid properties to OptionalGlobDirectoryPartial!");
-// This needs to be set when using GetManifest or InjectManifest. This is
-// enforced via runtime validation, and needs to be documented.
 const requiredGlobDirectoryPartial = z.object({
     globDirectory: z.string()
 }).strict("Do not pass invalid properties to RequiredGlobDirectoryPartial!");

package/dist/chunks/serwist-config-error.js

@@ -1,9 +1,7 @@
 import { z } from 'zod';
 
 const validationErrorMap = (error, ctx)=>{
-    /*
-    This is where you override the various error codes
-    */ switch(error.code){
+    switch(error.code){
         case z.ZodIssueCode.invalid_type:
             {
                 return {
@@ -41,7 +39,6 @@ const validationErrorMap = (error, ctx)=>{
                 };
             }
     }
-    // Fallback to the default message.
     return {
         message: ctx.defaultError
     };

package/dist/chunks/webpack.js

@@ -21,8 +21,7 @@ const webpackPartial = z.object({
         z.function(z.tuple([
             z.any()
         ]), z.boolean())
-    ])).optional(),
-    mode: z.string().nullable().optional()
+    ])).optional()
 }).strict("Do not pass invalid properties to WebpackPartial!");
 const webpackInjectManifestPartial = z.object({
     compileSrc: z.boolean().default(true),

package/dist/index.js

@@ -3,9 +3,10 @@ export { default as stringify } from 'fast-json-stable-stringify';
 import assert from 'assert';
 import { oneLine } from 'common-tags';
 import crypto from 'crypto';
-import { glob } from 'glob';
+import { globSync } from 'glob';
 import upath from 'upath';
 import fse from 'fs-extra';
+import prettyBytes from 'pretty-bytes';
 import { v as validationErrorMap, S as SerwistConfigError } from './chunks/serwist-config-error.js';
 import { SourceMapGenerator, SourceMapConsumer } from 'source-map';
 import 'zod';
@@ -74,12 +75,6 @@ const errors = {
     Please remove or fix the following: `,
     "bad-template-urls-asset": oneLine`There was an issue using one of the provided
     'templatedURLs'.`,
-    "invalid-runtime-caching": oneLine`The 'runtimeCaching' parameter must an an
-    array of objects with at least a 'urlPattern' and 'handler'.`,
-    "urlPattern-is-required": oneLine`The 'urlPattern' option is required when using
-    'runtimeCaching'.`,
-    "handler-is-required": oneLine`The 'handler' option is required when using
-    runtimeCaching.`,
     "invalid-generate-file-manifest-arg": oneLine`The input to generateFileManifest()
     must be an Object.`,
     "invalid-sw-src": `The 'swSrc' file can't be read.`,
@@ -144,11 +139,11 @@ function getFileSize(file) {
     }
 }
 
-function getFileDetails({ globDirectory, globFollow, globIgnores, globPattern }) {
+const getFileDetails = ({ globDirectory, globFollow, globIgnores, globPattern })=>{
     let globbedFiles;
     let warning = "";
     try {
-        globbedFiles = glob.sync(globPattern, {
+        globbedFiles = globSync(globPattern, {
             cwd: globDirectory,
             follow: globFollow,
             ignore: globIgnores
@@ -180,7 +175,7 @@ function getFileDetails({ globDirectory, globFollow, globIgnores, globPattern })
         globbedFileDetails,
         warning
     };
-}
+};
 
 function getStringDetails(url, str) {
     return {
@@ -195,8 +190,6 @@ const additionalPrecacheEntriesTransform = (additionalPrecacheEntries)=>{
         const warnings = [];
         const stringEntries = new Set();
         for (const additionalEntry of additionalPrecacheEntries){
-            // Warn about either a string or an object that lacks a revision property.
-            // (An object with a revision property set to null is okay.)
             if (typeof additionalEntry === "string") {
                 stringEntries.add(additionalEntry);
                 manifest.push({
@@ -227,110 +220,6 @@ const additionalPrecacheEntriesTransform = (additionalPrecacheEntries)=>{
     };
 };
 
-const BYTE_UNITS = [
-    'B',
-    'kB',
-    'MB',
-    'GB',
-    'TB',
-    'PB',
-    'EB',
-    'ZB',
-    'YB'
-];
-const BIBYTE_UNITS = [
-    'B',
-    'KiB',
-    'MiB',
-    'GiB',
-    'TiB',
-    'PiB',
-    'EiB',
-    'ZiB',
-    'YiB'
-];
-const BIT_UNITS = [
-    'b',
-    'kbit',
-    'Mbit',
-    'Gbit',
-    'Tbit',
-    'Pbit',
-    'Ebit',
-    'Zbit',
-    'Ybit'
-];
-const BIBIT_UNITS = [
-    'b',
-    'kibit',
-    'Mibit',
-    'Gibit',
-    'Tibit',
-    'Pibit',
-    'Eibit',
-    'Zibit',
-    'Yibit'
-];
-/*
-Formats the given number using `Number#toLocaleString`.
-- If locale is a string, the value is expected to be a locale-key (for example: `de`).
-- If locale is true, the system default locale is used for translation.
-- If no value for locale is specified, the number is returned unmodified.
-*/ const toLocaleString = (number, locale, options)=>{
-    let result = number;
-    if (typeof locale === 'string' || Array.isArray(locale)) {
-        result = number.toLocaleString(locale, options);
-    } else if (locale === true || options !== undefined) {
-        result = number.toLocaleString(undefined, options);
-    }
-    return result;
-};
-function prettyBytes(number, options) {
-    if (!Number.isFinite(number)) {
-        throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
-    }
-    options = {
-        bits: false,
-        binary: false,
-        space: true,
-        ...options
-    };
-    const UNITS = options.bits ? options.binary ? BIBIT_UNITS : BIT_UNITS : options.binary ? BIBYTE_UNITS : BYTE_UNITS;
-    const separator = options.space ? ' ' : '';
-    if (options.signed && number === 0) {
-        return ` 0${separator}${UNITS[0]}`;
-    }
-    const isNegative = number < 0;
-    const prefix = isNegative ? '-' : options.signed ? '+' : '';
-    if (isNegative) {
-        number = -number;
-    }
-    let localeOptions;
-    if (options.minimumFractionDigits !== undefined) {
-        localeOptions = {
-            minimumFractionDigits: options.minimumFractionDigits
-        };
-    }
-    if (options.maximumFractionDigits !== undefined) {
-        localeOptions = {
-            maximumFractionDigits: options.maximumFractionDigits,
-            ...localeOptions
-        };
-    }
-    if (number < 1) {
-        const numberString = toLocaleString(number, options.locale, localeOptions);
-        return prefix + numberString + separator + UNITS[0];
-    }
-    const exponent = Math.min(Math.floor(options.binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3), UNITS.length - 1);
-    number /= (options.binary ? 1024 : 1000) ** exponent;
-    if (!localeOptions) {
-        number = number.toPrecision(3);
-    }
-    const numberString = toLocaleString(Number(number), options.locale, localeOptions);
-    const unit = UNITS[exponent];
-    return prefix + numberString + separator + unit;
-}
-
 function maximumSizeTransform(maximumFileSizeToCacheInBytes) {
     return (originalManifest)=>{
         const warnings = [];
@@ -348,13 +237,6 @@ function maximumSizeTransform(maximumFileSizeToCacheInBytes) {
     };
 }
 
-/*
-  Copyright 2019 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ // From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
 const escapeRegExp = (str)=>{
     return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 };
@@ -363,8 +245,6 @@ function modifyURLPrefixTransform(modifyURLPrefix) {
     if (!modifyURLPrefix || typeof modifyURLPrefix !== "object" || Array.isArray(modifyURLPrefix)) {
         throw new Error(errors["modify-url-prefix-bad-prefixes"]);
     }
-    // If there are no entries in modifyURLPrefix, just return an identity
-    // function as a shortcut.
     if (Object.keys(modifyURLPrefix).length === 0) {
         return (manifest)=>{
             return {
@@ -377,12 +257,8 @@ function modifyURLPrefixTransform(modifyURLPrefix) {
             throw new Error(errors["modify-url-prefix-bad-prefixes"]);
         }
     }
-    // Escape the user input so it's safe to use in a regex.
     const safeModifyURLPrefixes = Object.keys(modifyURLPrefix).map(escapeRegExp);
-    // Join all the `modifyURLPrefix` keys so a single regex can be used.
     const prefixMatchesStrings = safeModifyURLPrefixes.join("|");
-    // Add `^` to the front the prefix matches so it only matches the start of
-    // a string.
     const modifyRegex = new RegExp(`^(${prefixMatchesStrings})`);
     return (originalManifest)=>{
         const manifest = originalManifest.map((entry)=>{
@@ -430,8 +306,6 @@ async function transformManifest({ additionalPrecacheEntries, dontCacheBustURLsM
         };
     }
     const allWarnings = [];
-    // Take the array of fileDetail objects and convert it into an array of
-    // {url, revision, size} objects, with \ replaced with /.
     const normalizedManifest = fileDetails.map((fileDetails)=>{
         return {
             url: fileDetails.file.replace(/\\/g, "/"),
@@ -449,11 +323,9 @@ async function transformManifest({ additionalPrecacheEntries, dontCacheBustURLsM
     if (dontCacheBustURLsMatching) {
         transformsToApply.push(noRevisionForURLsMatchingTransform(dontCacheBustURLsMatching));
     }
-    // Run any manifestTransforms functions second-to-last.
     if (manifestTransforms) {
         transformsToApply.push(...manifestTransforms);
     }
-    // Run additionalPrecacheEntriesTransform last.
     if (additionalPrecacheEntries) {
         transformsToApply.push(additionalPrecacheEntriesTransform(additionalPrecacheEntries));
     }
@@ -466,13 +338,10 @@ async function transformManifest({ additionalPrecacheEntries, dontCacheBustURLsM
         transformedManifest = result.manifest;
         allWarnings.push(...result.warnings || []);
     }
-    // Generate some metadata about the manifest before we clear out the size
-    // properties from each entry.
     const count = transformedManifest.length;
     let size = 0;
     for (const manifestEntry of transformedManifest){
         size += manifestEntry.size || 0;
-        // biome-ignore lint/performance/noDelete: I don't understand this part yet.
         delete manifestEntry.size;
     }
     return {
@@ -513,8 +382,6 @@ async function getFileManifestEntries({ additionalPrecacheEntries, dontCacheBust
             }
         }
     } catch (error) {
-        // If there's an exception thrown while globbing, then report
-        // it back as a warning, and don't consider it fatal.
         if (error instanceof Error && error.message) {
             warnings.push(error.message);
         }
@@ -540,11 +407,11 @@ async function getFileManifestEntries({ additionalPrecacheEntries, dontCacheBust
                     } catch (error) {
                         const debugObj = {};
                         debugObj[url] = dependencies;
-                        throw new Error(`${errors["bad-template-urls-asset"]} ` + `'${globPattern}' from '${JSON.stringify(debugObj)}':\n` + `${error instanceof Error ? error.toString() : ""}`);
+                        throw new Error(`${errors["bad-template-urls-asset"]} '${globPattern}' from '${JSON.stringify(debugObj)}':\n${error instanceof Error ? error.toString() : ""}`);
                     }
                 }, []);
                 if (details.length === 0) {
-                    throw new Error(`${errors["bad-template-urls-asset"]} The glob ` + `pattern '${dependencies.toString()}' did not match anything.`);
+                    throw new Error(`${errors["bad-template-urls-asset"]} The glob pattern '${dependencies.toString()}' did not match anything.`);
                 }
                 allFileDetails.set(url, getCompositeDetails(url, details));
             } else if (typeof dependencies === "string") {
@@ -614,34 +481,11 @@ const validateViteInjectManifestOptions = async (input)=>{
     return result.data;
 };
 
-/**
- * This method returns a list of URLs to precache, referred to as a "precache
- * manifest", along with details about the number of entries and their size,
- * based on the options you provide.
- *
- * ```
- * // The following lists some common options; see the rest of the documentation
- * // for the full set of options and defaults.
- * const {count, manifestEntries, size, warnings} = await getManifest({
- *   dontCacheBustURLsMatching: [new RegExp('...')],
- *   globDirectory: '...',
- *   globPatterns: ['...', '...'],
- *   maximumFileSizeToCacheInBytes: ...,
- * });
- * ```
- */ const getManifest = async (config)=>{
+const getManifest = async (config)=>{
     const options = await validateGetManifestOptions(config);
     return await getFileManifestEntries(options);
 };
 
-/*
-  Copyright 2022 Google LLC
-
-  Use of this source code is governed by an MIT-style
-  license that can be found in the LICENSE file or at
-  https://opensource.org/licenses/MIT.
-*/ // Adapted from https://github.com/lydell/source-map-url/blob/master/source-map-url.js
-// See https://github.com/GoogleChrome/workbox/issues/3019
 const innerRegex = /[#@] sourceMappingURL=([^\s'"]*)/;
 const regex = RegExp(`(?:/\\*(?:\\s*\r?\n(?://)?)?(?:${innerRegex.source})\\s*\\*/|//(?:${innerRegex.source}))\\s*`);
 function getSourceMapURL(srcContents) {
@@ -650,24 +494,13 @@ function getSourceMapURL(srcContents) {
 }
 
 function rebasePath({ baseDirectory, file }) {
-    // The initial path is relative to the current directory, so make it absolute.
     const absolutePath = upath.resolve(file);
-    // Convert the absolute path so that it's relative to the baseDirectory.
     const relativePath = upath.relative(baseDirectory, absolutePath);
-    // Remove any leading ./ as it won't work in a glob pattern.
     const normalizedPath = upath.normalize(relativePath);
     return normalizedPath;
 }
 
-/**
- * Adapted from https://github.com/nsams/sourcemap-aware-replace, with modern
- * JavaScript updates, along with additional properties copied from originalMap.
- *
- * @param options
- * @returns An object containing both
- * originalSource with the replacement applied, and the modified originalMap.
- * @private
- */ async function replaceAndUpdateSourceMap({ jsFilename, originalMap, originalSource, replaceString, searchString }) {
+async function replaceAndUpdateSourceMap({ jsFilename, originalMap, originalSource, replaceString, searchString }) {
     const generator = new SourceMapGenerator({
         file: jsFilename
     });
@@ -717,8 +550,6 @@ function rebasePath({ baseDirectory, file }) {
         return mapping;
     });
     consumer.destroy();
-    // JSON.parse returns any.
-    // eslint-disable-next-line  @typescript-eslint/no-unsafe-assignment
     const updatedSourceMap = Object.assign(JSON.parse(generator.toString()), {
         names: originalMap.names,
         sourceRoot: originalMap.sourceRoot,
@@ -751,34 +582,8 @@ function translateURLToSourcemapPaths(url, swSrc, swDest) {
     };
 }
 
-/**
- * This method creates a list of URLs to precache, referred to as a "precache
- * manifest", based on the options you provide.
- *
- * The manifest is injected into the `swSrc` file, and the placeholder string
- * `injectionPoint` determines where in the file the manifest should go.
- *
- * The final service worker file, with the manifest injected, is written to
- * disk at `swDest`.
- *
- * This method will not compile or bundle your `swSrc` file; it just handles
- * injecting the manifest.
- *
- * ```
- * // The following lists some common options; see the rest of the documentation
- * // for the full set of options and defaults.
- * const {count, size, warnings} = await injectManifest({
- *   dontCacheBustURLsMatching: [new RegExp('...')],
- *   globDirectory: '...',
- *   globPatterns: ['...', '...'],
- *   maximumFileSizeToCacheInBytes: ...,
- *   swDest: '...',
- *   swSrc: '...',
- * });
- * ```
- */ const injectManifest = async (config)=>{
+const injectManifest = async (config)=>{
     const options = await validateInjectManifestOptions(config);
-    // Make sure we leave swSrc and swDest out of the precache manifest.
     for (const file of [
         options.swSrc,
         options.swDest
@@ -797,7 +602,6 @@ function translateURLToSourcemapPaths(url, swSrc, swDest) {
         throw new Error(`${errors["invalid-sw-src"]} ${error instanceof Error && error.message ? error.message : ""}`);
     }
     const injectionResults = swFileContents.match(globalRegexp);
-    // See https://github.com/GoogleChrome/workbox/issues/2230
     const injectionPoint = options.injectionPoint ? options.injectionPoint : "";
     if (!injectionResults) {
         if (upath.resolve(options.swSrc) === upath.resolve(options.swDest)) {
@@ -809,17 +613,10 @@ function translateURLToSourcemapPaths(url, swSrc, swDest) {
     const manifestString = manifestEntries === undefined ? "undefined" : stringify(manifestEntries);
     const filesToWrite = {};
     const url = getSourceMapURL(swFileContents);
-    // See https://github.com/GoogleChrome/workbox/issues/2957
     const { destPath, srcPath, warning } = translateURLToSourcemapPaths(url, options.swSrc, options.swDest);
     if (warning) {
         warnings.push(warning);
     }
-    // If our swSrc file contains a sourcemap, we would invalidate that
-    // mapping if we just replaced injectionPoint with the stringified manifest.
-    // Instead, we need to update the swDest contents as well as the sourcemap
-    // (assuming it's a real file, not a data: URL) at the same time.
-    // See https://github.com/GoogleChrome/workbox/issues/2235
-    // and https://github.com/GoogleChrome/workbox/issues/2648
     if (srcPath && destPath) {
         const originalMap = await fse.readJSON(srcPath, {
             encoding: "utf8"
@@ -834,8 +631,6 @@ function translateURLToSourcemapPaths(url, swSrc, swDest) {
         filesToWrite[options.swDest] = source;
         filesToWrite[destPath] = map;
     } else {
-        // If there's no sourcemap associated with swSrc, a simple string
-        // replacement will suffice.
         filesToWrite[options.swDest] = swFileContents.replace(globalRegexp, manifestString);
     }
     for (const [file, contents] of Object.entries(filesToWrite)){
@@ -850,7 +645,6 @@ function translateURLToSourcemapPaths(url, swSrc, swDest) {
         count,
         size,
         warnings,
-        // Use upath.resolve() to make all the paths absolute.
         filePaths: Object.keys(filesToWrite).map((f)=>upath.resolve(f))
     };
 };

package/dist/index.next.js

@@ -5,13 +5,16 @@ import { v as validationErrorMap, S as SerwistConfigError } from './chunks/serwi
 import './chunks/glob.js';
 
 const nextInjectManifestPartial = z.object({
-    cacheOnFrontEndNav: z.boolean().default(false),
+    cacheOnNavigation: z.boolean().default(false),
     disable: z.boolean().default(false),
     register: z.boolean().default(true),
     reloadOnOnline: z.boolean().default(true),
     scope: z.string().optional(),
     swUrl: z.string().default("/sw.js"),
-    globPublicPatterns: z.array(z.string()).default([
+    globPublicPatterns: z.union([
+        z.string(),
+        z.array(z.string())
+    ]).default([
         "**/*"
     ])
 }).strict("Do not pass invalid properties to NextInjectManifestPartial!");

package/dist/lib/errors.d.ts

@@ -35,9 +35,6 @@ export declare const errors: {
     "multiple-injection-points": string;
     "useless-glob-pattern": string;
     "bad-template-urls-asset": string;
-    "invalid-runtime-caching": string;
-    "urlPattern-is-required": string;
-    "handler-is-required": string;
     "invalid-generate-file-manifest-arg": string;
     "invalid-sw-src": string;
     "same-src-and-dest": string;

package/dist/lib/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/lib/errors.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwFlB,CAAC"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/lib/errors.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkFlB,CAAC"}

package/dist/lib/get-file-details.d.ts

@@ -4,10 +4,10 @@ interface FileDetails {
     hash: string;
     size: number;
 }
-export declare function getFileDetails({ globDirectory, globFollow, globIgnores, globPattern, }: Omit<GlobPartial, "globDirectory" | "globPatterns" | "templatedURLs"> & {
+export declare const getFileDetails: ({ globDirectory, globFollow, globIgnores, globPattern, }: Omit<GlobPartial, "globPatterns" | "templatedURLs" | "globDirectory"> & {
     globDirectory: string;
     globPattern: string;
-}): {
+}) => {
     globbedFileDetails: FileDetails[];
     warning: string;
 };

package/dist/lib/get-file-details.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-file-details.d.ts","sourceRoot":"","sources":["../../src/lib/get-file-details.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK/C,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,cAAc,CAAC,EAC7B,aAAa,EACb,UAAU,EACV,WAAW,EACX,WAAW,GACZ,EAAE,IAAI,CAAC,WAAW,EAAE,eAAe,GAAG,cAAc,GAAG,eAAe,CAAC,GAAG;IAEzE,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG;IACF,kBAAkB,EAAE,WAAW,EAAE,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;CACjB,CAiCA"}
+{"version":3,"file":"get-file-details.d.ts","sourceRoot":"","sources":["../../src/lib/get-file-details.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK/C,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,eAAO,MAAM,cAAc;mBAOV,MAAM;iBACR,MAAM;;wBAEC,WAAW,EAAE;aACxB,MAAM;CAkChB,CAAC"}

package/dist/schema/assertType.d.ts

@@ -0,0 +1,3 @@
+export type Equals<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false;
+export declare function assertType<_T extends true>(): void;
+//# sourceMappingURL=assertType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assertType.d.ts","sourceRoot":"","sources":["../../src/schema/assertType.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC,GAAG,KAAK,CAAC;AAEtF,wBAAgB,UAAU,CAAC,EAAE,SAAS,IAAI,UAEzC"}

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/schema/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASkG,CAAC"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/schema/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASmC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"getManifest.d.ts","sourceRoot":"","sources":["../../src/schema/getManifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAM7B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO9B,CAAC"}
+{"version":3,"file":"getManifest.d.ts","sourceRoot":"","sources":["../../src/schema/getManifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAM7B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGmC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../src/schema/glob.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;EAQkG,CAAC;AAE3H,eAAO,MAAM,4BAA4B;;;;;;EAQxC,CAAC;AAIF,eAAO,MAAM,4BAA4B;;;;;;EAQxC,CAAC"}
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../src/schema/glob.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;EAQmC,CAAC;AAE5D,eAAO,MAAM,4BAA4B;;;;;;EAImC,CAAC;AAI7E,eAAO,MAAM,4BAA4B;;;;;;EAImC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"injectManifest.d.ts","sourceRoot":"","sources":["../../src/schema/injectManifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,aAAa;;;;;;;;;EAKsG,CAAC;AAEjI,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASjC,CAAC"}
+{"version":3,"file":"injectManifest.d.ts","sourceRoot":"","sources":["../../src/schema/injectManifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,aAAa;;;;;;;;;EAKmC,CAAC;AAE9D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKmC,CAAC"}

package/dist/schema/next.d.ts

@@ -1,28 +1,28 @@
 import { z } from "zod";
 export declare const nextInjectManifestPartial: z.ZodObject<{
-    cacheOnFrontEndNav: z.ZodDefault<z.ZodBoolean>;
+    cacheOnNavigation: z.ZodDefault<z.ZodBoolean>;
     disable: z.ZodDefault<z.ZodBoolean>;
     register: z.ZodDefault<z.ZodBoolean>;
     reloadOnOnline: z.ZodDefault<z.ZodBoolean>;
     scope: z.ZodOptional<z.ZodString>;
     swUrl: z.ZodDefault<z.ZodString>;
-    globPublicPatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    globPublicPatterns: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
 }, "strict", z.ZodTypeAny, {
-    cacheOnFrontEndNav: boolean;
+    cacheOnNavigation: boolean;
     disable: boolean;
     register: boolean;
     reloadOnOnline: boolean;
     swUrl: string;
-    globPublicPatterns: string[];
+    globPublicPatterns: (string | string[]) & (string | string[] | undefined);
     scope?: string | undefined;
 }, {
-    cacheOnFrontEndNav?: boolean | undefined;
+    cacheOnNavigation?: boolean | undefined;
     disable?: boolean | undefined;
     register?: boolean | undefined;
     reloadOnOnline?: boolean | undefined;
     scope?: string | undefined;
     swUrl?: string | undefined;
-    globPublicPatterns?: string[] | undefined;
+    globPublicPatterns?: string | string[] | undefined;
 }>;
 export declare const nextInjectManifestOptions: z.ZodObject<Omit<{
     disablePrecacheManifest: z.ZodDefault<z.ZodBoolean>;
@@ -132,29 +132,28 @@ export declare const nextInjectManifestOptions: z.ZodObject<Omit<{
     chunks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     excludeChunks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     include: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>, z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>]>, "many">>;
-    mode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     compileSrc: z.ZodDefault<z.ZodBoolean>;
     webpackCompilationPlugins: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
     swDest: z.ZodString;
-    cacheOnFrontEndNav: z.ZodDefault<z.ZodBoolean>;
+    cacheOnNavigation: z.ZodDefault<z.ZodBoolean>;
     disable: z.ZodDefault<z.ZodBoolean>;
     register: z.ZodDefault<z.ZodBoolean>;
     reloadOnOnline: z.ZodDefault<z.ZodBoolean>;
     scope: z.ZodOptional<z.ZodString>;
     swUrl: z.ZodDefault<z.ZodString>;
-    globPublicPatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    globPublicPatterns: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
 }, "disablePrecacheManifest">, "strict", z.ZodTypeAny, {
     maximumFileSizeToCacheInBytes: number;
     injectionPoint: string;
     swSrc: string;
     exclude: (string | RegExp | ((args_0: any) => boolean))[];
     compileSrc: boolean;
-    cacheOnFrontEndNav: boolean;
+    cacheOnNavigation: boolean;
     disable: boolean;
     register: boolean;
     reloadOnOnline: boolean;
     swUrl: string;
-    globPublicPatterns: string[];
+    globPublicPatterns: (string | string[]) & (string | string[] | undefined);
     swDest: string;
     additionalPrecacheEntries?: (string | {
         revision: string | null;
@@ -188,7 +187,6 @@ export declare const nextInjectManifestOptions: z.ZodObject<Omit<{
     chunks?: string[] | undefined;
     excludeChunks?: string[] | undefined;
     include?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
-    mode?: string | null | undefined;
     webpackCompilationPlugins?: any[] | undefined;
     scope?: string | undefined;
 }, {
@@ -229,15 +227,14 @@ export declare const nextInjectManifestOptions: z.ZodObject<Omit<{
     chunks?: string[] | undefined;
     excludeChunks?: string[] | undefined;
     include?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
-    mode?: string | null | undefined;
     compileSrc?: boolean | undefined;
     webpackCompilationPlugins?: any[] | undefined;
-    cacheOnFrontEndNav?: boolean | undefined;
+    cacheOnNavigation?: boolean | undefined;
     disable?: boolean | undefined;
     register?: boolean | undefined;
     reloadOnOnline?: boolean | undefined;
     swUrl?: string | undefined;
-    globPublicPatterns?: string[] | undefined;
+    globPublicPatterns?: string | string[] | undefined;
     scope?: string | undefined;
 }>;
 //# sourceMappingURL=next.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../../src/schema/next.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;EAcrC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQrC,CAAC"}
+{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../../src/schema/next.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;EAUmC,CAAC;AAE1E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAImC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"swDest.d.ts","sourceRoot":"","sources":["../../src/schema/swDest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,qBAAqB;;;;;;EAI+G,CAAC;AAElJ,eAAO,MAAM,qBAAqB;;;;;;EAI+G,CAAC"}
+{"version":3,"file":"swDest.d.ts","sourceRoot":"","sources":["../../src/schema/swDest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,qBAAqB;;;;;;EAI4B,CAAC;AAE/D,eAAO,MAAM,qBAAqB;;;;;;EAI4B,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/schema/vite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQ7B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASrC,CAAC"}
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/schema/vite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAS7B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKmC,CAAC"}