@serwist/build 10.0.0-preview.1 → 10.0.0-preview.11

package/src/lib/get-file-manifest-entries.ts

@@ -7,12 +7,11 @@
 */
 
 import assert from "node:assert";
+import type { FileDetails } from "@serwist/utils";
+import { errors, getCompositeDetails, getStringDetails } from "@serwist/utils/node";
 
-import type { FileDetails, GetManifestOptionsComplete, GetManifestResult } from "../types.js";
-import { errors } from "./errors.js";
-import { getCompositeDetails } from "./get-composite-details.js";
+import type { GetManifestOptionsComplete, GetManifestResult } from "../types.js";
 import { getFileDetails } from "./get-file-details.js";
-import { getStringDetails } from "./get-string-details.js";
 import { transformManifest } from "./transform-manifest.js";
 
 export const getFileManifestEntries = async ({

package/src/lib/modify-url-prefix-transform.ts

@@ -5,9 +5,9 @@
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
+import { errors } from "@serwist/utils/node";
 
 import type { ManifestTransform } from "../types.js";
-import { errors } from "./errors.js";
 import { escapeRegExp } from "./escape-regexp.js";
 
 export function modifyURLPrefixTransform(modifyURLPrefix: { [key: string]: string }): ManifestTransform {

package/src/lib/no-revision-for-urls-matching-transform.ts

@@ -5,9 +5,9 @@
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
+import { errors } from "@serwist/utils/node";
 
 import type { ManifestTransform } from "../types.js";
-import { errors } from "./errors.js";
 
 export function noRevisionForURLsMatchingTransform(regexp: RegExp): ManifestTransform {
   if (!(regexp instanceof RegExp)) {

package/src/lib/rebase-path.ts

@@ -6,8 +6,8 @@
   https://opensource.org/licenses/MIT.
 */
 
-import { toUnix } from "@serwist/utils";
 import path from "node:path";
+import { toUnix } from "@serwist/utils";
 
 export function rebasePath({ baseDirectory, file }: { baseDirectory: string; file: string }): string {
   // The initial path is relative to the current directory, so make it absolute.

package/src/lib/transform-manifest.ts

@@ -5,10 +5,11 @@
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
+import type { FileDetails } from "@serwist/utils";
+import { errors } from "@serwist/utils/node";
 
-import type { BaseResolved, FileDetails, ManifestEntry, ManifestTransform } from "../types.js";
+import type { BaseResolved, ManifestEntry, ManifestTransform } from "../types.js";
 import { additionalPrecacheEntriesTransform } from "./additional-precache-entries-transform.js";
-import { errors } from "./errors.js";
 import { maximumSizeTransform } from "./maximum-size-transform.js";
 import { modifyURLPrefixTransform } from "./modify-url-prefix-transform.js";
 import { noRevisionForURLsMatchingTransform } from "./no-revision-for-urls-matching-transform.js";
@@ -155,7 +156,6 @@ export async function transformManifest({
   let size = 0;
   for (const manifestEntry of transformedManifest as (ManifestEntry & { size?: number })[]) {
     size += manifestEntry.size || 0;
-    // biome-ignore lint/performance/noDelete: These values are no longer necessary.
     delete manifestEntry.size;
   }
 

package/src/lib/translate-url-to-sourcemap-paths.ts

@@ -8,7 +8,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { toUnix } from "@serwist/utils";
-import { errors } from "./errors.js";
+import { errors } from "@serwist/utils/node";
 
 export function translateURLToSourcemapPaths(
   url: string | null,
@@ -19,9 +19,9 @@ export function translateURLToSourcemapPaths(
   srcPath: string | undefined;
   warning: string | undefined;
 } {
-  let destPath: string | undefined = undefined;
-  let srcPath: string | undefined = undefined;
-  let warning: string | undefined = undefined;
+  let destPath: string | undefined;
+  let srcPath: string | undefined;
+  let warning: string | undefined;
 
   if (url && !url.startsWith("data:")) {
     const possibleSrcPath = path.resolve(path.dirname(swSrc), url);

package/src/lib/validate-options.ts

@@ -1,4 +1,4 @@
-import { SerwistConfigError } from "../schema/serwistConfigError.js";
+import { z } from "zod";
 /*
   Copyright 2021 Google LLC
 
@@ -6,21 +6,27 @@ import { SerwistConfigError } from "../schema/serwistConfigError.js";
   license that can be found in the LICENSE file or at
   https://opensource.org/licenses/MIT.
 */
-import { validationErrorMap } from "../schema/validationErrorMap.js";
+import { SerwistConfigError, validationErrorMap } from "../schema/error.js";
 import type { GetManifestOptionsComplete, InjectManifestOptionsComplete } from "../types.js";
 
 export const validateGetManifestOptions = async (input: unknown): Promise<GetManifestOptionsComplete> => {
-  const result = await (await import("../schema/getManifest.js")).getManifestOptions.spa(input, { errorMap: validationErrorMap });
+  const result = await (await import("../schema/get-manifest.js")).getManifestOptions.spa(input, { error: validationErrorMap });
   if (!result.success) {
-    throw new SerwistConfigError({ moduleName: "@serwist/build", message: JSON.stringify(result.error.format(), null, 2) });
+    throw new SerwistConfigError({
+      moduleName: "@serwist/build",
+      message: z.prettifyError(result.error),
+    });
   }
   return result.data;
 };
 
 export const validateInjectManifestOptions = async (input: unknown): Promise<InjectManifestOptionsComplete> => {
-  const result = await (await import("../schema/injectManifest.js")).injectManifestOptions.spa(input, { errorMap: validationErrorMap });
+  const result = await (await import("../schema/inject-manifest.js")).injectManifestOptions.spa(input, { error: validationErrorMap });
   if (!result.success) {
-    throw new SerwistConfigError({ moduleName: "@serwist/build", message: JSON.stringify(result.error.format(), null, 2) });
+    throw new SerwistConfigError({
+      moduleName: "@serwist/build",
+      message: z.prettifyError(result.error),
+    });
   }
   return result.data;
 };

package/src/schema/base.ts

@@ -1,20 +1,18 @@
 import { z } from "zod";
+import type { BasePartial, BaseResolved, ManifestEntry, ManifestTransform } from "../types.js";
+import { assertType, type Equals } from "./assert-type.js";
+import { manifestEntry } from "./manifest-entry.js";
+import { manifestTransform } from "./manifest-transform.js";
+import { reference } from "./utils.js";
 
-import type { BasePartial, BaseResolved } from "../types.js";
-import { type Equals, assertType } from "./assertType.js";
-import { manifestEntry } from "./manifestEntry.js";
-import { manifestTransform } from "./manifestTransform.js";
-
-export const basePartial = z
-  .object({
-    additionalPrecacheEntries: z.array(z.union([z.string(), manifestEntry])).optional(),
-    disablePrecacheManifest: z.boolean().default(false),
-    dontCacheBustURLsMatching: z.instanceof(RegExp).optional(),
-    manifestTransforms: z.array(manifestTransform).optional(),
-    maximumFileSizeToCacheInBytes: z.number().default(2097152),
-    modifyURLPrefix: z.record(z.string(), z.string()).optional(),
-  })
-  .strict("Do not pass invalid properties to BasePartial!");
+export const basePartial = z.strictObject({
+  additionalPrecacheEntries: z.array(z.union([z.string(), reference<ManifestEntry>(manifestEntry)])).optional(),
+  disablePrecacheManifest: z.boolean().default(false),
+  dontCacheBustURLsMatching: z.instanceof(RegExp).optional(),
+  manifestTransforms: z.array(reference<ManifestTransform>(manifestTransform)).optional(),
+  maximumFileSizeToCacheInBytes: z.number().default(2097152),
+  modifyURLPrefix: z.record(z.string(), z.string()).optional(),
+});
 
 assertType<Equals<BasePartial, z.input<typeof basePartial>>>();
 assertType<Equals<BaseResolved, z.output<typeof basePartial>>>();

package/src/schema/error.ts

@@ -0,0 +1,53 @@
+import type { z } from "zod";
+
+export class SerwistConfigError extends Error {
+  constructor({ moduleName, message }: { moduleName?: string; message?: string }) {
+    super(`Invalid ${moduleName ?? "Serwist"} configuration:\n${message}`);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+const parsedType = (data: any): string => {
+  const t = typeof data;
+
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "NaN" : "number";
+    }
+    case "object": {
+      if (Array.isArray(data)) {
+        return "array";
+      }
+      if (data === null) {
+        return "null";
+      }
+
+      if (Object.getPrototypeOf(data) !== Object.prototype && data.constructor) {
+        return data.constructor.name;
+      }
+    }
+  }
+  return t;
+};
+
+export const validationErrorMap: z.core.$ZodErrorMap = (error) => {
+  /* This is where you override the various error codes */
+  switch (error.code) {
+    case "invalid_type": {
+      return `${error.message ?? "Received invalid type"}: expected ${error.expected}, received ${parsedType(error.input)}.`;
+    }
+    case "invalid_value": {
+      return `${error.message ?? "Received invalid value"}: expected ${error.expected}, received ${parsedType(error.input)}.`;
+    }
+    case "invalid_union": {
+      return `${error.message ?? "Received invalid union"}:\n${error.errors.flatMap((err) => err.map((e) => `  → ${e.message}`)).join("\n")}`;
+    }
+    case "unrecognized_keys": {
+      return `${error.message ?? "Received unrecognized keys"}: ${error.keys.join(".")}`;
+    }
+    case "custom": {
+      return error.message ?? undefined;
+    }
+  }
+  return undefined;
+};

package/src/schema/{getManifest.ts → get-manifest.ts}

@@ -1,13 +1,14 @@
-import type { z } from "zod";
+import { z } from "zod";
 import type { GetManifestOptions, GetManifestOptionsComplete } from "../types.js";
-import { type Equals, assertType } from "./assertType.js";
+import { assertType, type Equals } from "./assert-type.js";
 import { basePartial } from "./base.js";
 import { globPartial, requiredGlobDirectoryPartial } from "./glob.js";
 
-export const getManifestOptions = basePartial
-  .merge(globPartial)
-  .merge(requiredGlobDirectoryPartial)
-  .strict("Do not pass invalid properties to GetManifestOptions!");
+export const getManifestOptions = z.strictObject({
+  ...basePartial.shape,
+  ...globPartial.shape,
+  ...requiredGlobDirectoryPartial.shape,
+});
 
 assertType<Equals<GetManifestOptions, z.input<typeof getManifestOptions>>>();
 assertType<Equals<GetManifestOptionsComplete, z.output<typeof getManifestOptions>>>();

package/src/schema/glob.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DEFAULT_GLOB_PATTERNS } from "../lib/constants.js";
 import type {
   GlobPartial,
   GlobResolved,
@@ -7,31 +8,25 @@ import type {
   RequiredGlobDirectoryPartial,
   RequiredGlobDirectoryResolved,
 } from "../types.js";
-import { type Equals, assertType } from "./assertType.js";
+import { assertType, type Equals } from "./assert-type.js";
 
-export const globPartial = z
-  .object({
-    globFollow: z.boolean().default(true),
-    globIgnores: z.array(z.string()).default(["**/node_modules/**/*"]),
-    globPatterns: z.array(z.string()).default(["**/*.{js,css,html}"]),
-    globStrict: z.boolean().default(true),
-    templatedURLs: z.record(z.string(), z.union([z.string(), z.array(z.string())])).optional(),
-  })
-  .strict("Do not pass invalid properties to GlobPartial!");
+export const globPartial = z.strictObject({
+  globFollow: z.boolean().default(true),
+  globIgnores: z.array(z.string()).default(["**/node_modules/**/*"]),
+  globPatterns: z.array(z.string()).default(DEFAULT_GLOB_PATTERNS),
+  globStrict: z.boolean().default(true),
+  templatedURLs: z.record(z.string(), z.union([z.string(), z.array(z.string())])).optional(),
+});
 
-export const optionalGlobDirectoryPartial = z
-  .object({
-    globDirectory: z.string().optional(),
-  })
-  .strict("Do not pass invalid properties to OptionalGlobDirectoryPartial!");
+export const optionalGlobDirectoryPartial = z.strictObject({
+  globDirectory: z.string().optional(),
+});
 
 // This needs to be set when using GetManifest or InjectManifest. This is
 // enforced via runtime validation, and needs to be documented.
-export const requiredGlobDirectoryPartial = z
-  .object({
-    globDirectory: z.string(),
-  })
-  .strict("Do not pass invalid properties to RequiredGlobDirectoryPartial!");
+export const requiredGlobDirectoryPartial = z.strictObject({
+  globDirectory: z.string(),
+});
 
 assertType<Equals<GlobPartial, z.input<typeof globPartial>>>();
 assertType<Equals<GlobResolved, z.output<typeof globPartial>>>();

package/src/schema/inject-manifest.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import type { InjectManifestOptions, InjectManifestOptionsComplete, InjectPartial, InjectResolved } from "../types.js";
+import { assertType, type Equals } from "./assert-type.js";
+import { basePartial } from "./base.js";
+import { globPartial, requiredGlobDirectoryPartial } from "./glob.js";
+import { requiredSwDestPartial } from "./sw-dest.js";
+
+export const baseInjectPartial = z.strictObject({
+  injectionPoint: z.string().prefault("self.__SW_MANIFEST"),
+  swSrc: z.string(),
+});
+
+export const injectManifestOptions = z.strictObject({
+  ...basePartial.shape,
+  ...globPartial.shape,
+  ...baseInjectPartial.shape,
+  ...requiredSwDestPartial.shape,
+  ...requiredGlobDirectoryPartial.shape,
+});
+
+assertType<Equals<InjectPartial, z.input<typeof baseInjectPartial>>>();
+assertType<Equals<InjectResolved, z.output<typeof baseInjectPartial>>>();
+assertType<Equals<InjectManifestOptions, z.input<typeof injectManifestOptions>>>();
+assertType<Equals<InjectManifestOptionsComplete, z.output<typeof injectManifestOptions>>>();

package/src/schema/manifest-entry.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+
+export const manifestEntry = z.strictObject({
+  integrity: z.string().optional(),
+  revision: z.string().nullable().optional(),
+  url: z.string(),
+});
+
+export const sizeObject = z.object({ size: z.number() });
+
+export const manifestEntryWithSize = z.object({ ...manifestEntry.shape, ...sizeObject.shape });

package/src/schema/manifest-transform.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import type { ManifestEntryWithSize, ManifestTransformResult } from "../types.js";
+import { manifestEntryWithSize } from "./manifest-entry.js";
+import { asyncFn, reference } from "./utils.js";
+
+export const manifestTransformResult = z.strictObject({
+  manifest: z.array(reference<ManifestEntryWithSize>(manifestEntryWithSize)),
+  warnings: z.array(z.string()).optional(),
+});
+
+export const manifestTransform = asyncFn({
+  input: [z.array(reference<ManifestEntryWithSize>(manifestEntryWithSize)), z.unknown().optional()],
+  output: reference<ManifestTransformResult>(manifestTransformResult),
+});

package/src/schema/{swDest.ts → sw-dest.ts}

@@ -1,18 +1,14 @@
 import { z } from "zod";
 import type { OptionalSwDestPartial, OptionalSwDestResolved, RequiredSwDestPartial, RequiredSwDestResolved } from "../types.js";
-import { type Equals, assertType } from "./assertType.js";
+import { assertType, type Equals } from "./assert-type.js";
 
-export const optionalSwDestPartial = z
-  .object({
-    swDest: z.string().optional(),
-  })
-  .strict("Do not pass invalid properties to OptionalSwDest!");
+export const optionalSwDestPartial = z.strictObject({
+  swDest: z.string().optional(),
+});
 
-export const requiredSwDestPartial = z
-  .object({
-    swDest: z.string(),
-  })
-  .strict("Do not pass invalid properties to RequiredSwDest!");
+export const requiredSwDestPartial = z.strictObject({
+  swDest: z.string(),
+});
 
 assertType<Equals<OptionalSwDestPartial, z.input<typeof optionalSwDestPartial>>>();
 assertType<Equals<OptionalSwDestResolved, z.output<typeof optionalSwDestPartial>>>();

package/src/schema/utils.ts

@@ -0,0 +1,48 @@
+import type { MaybePromise } from "@serwist/utils";
+import { z } from "zod";
+
+/**
+ * Prevents TS from inlining a schema’s inferred type.
+ * @internal
+ */
+export const reference = <Output, Input = Output>(schema: z.ZodType<Output, Input>) => {
+  return schema;
+};
+
+export const asyncFn = <TInput extends [z.ZodType, ...z.ZodType[]], TOutput extends z.ZodType>({
+  input,
+  output,
+}: {
+  input: TInput;
+  output: TOutput;
+}): z.ZodType<
+  (...args: z.input<z.ZodTuple<TInput, null>>) => MaybePromise<z.output<TOutput>>,
+  (...args: z.output<z.ZodTuple<TInput, null>>) => MaybePromise<z.input<TOutput>>
+> => {
+  const schema = z.function({
+    input: z.tuple(input),
+    output,
+  });
+  return z
+    .custom<(...args: z.output<z.ZodTuple<TInput, null>>) => MaybePromise<z.input<TOutput>>>((arg) => typeof arg === "function")
+    .transform((arg) => schema.implementAsync(arg));
+};
+
+export const fn = <TInput extends [z.ZodType, ...z.ZodType[]], TOutput extends z.ZodType>({
+  input,
+  output,
+}: {
+  input: TInput;
+  output: TOutput;
+}): z.ZodType<
+  (...args: z.input<z.ZodTuple<TInput, null>>) => z.output<TOutput>,
+  (...args: z.output<z.ZodTuple<TInput, null>>) => z.input<TOutput>
+> => {
+  const schema = z.function({
+    input: z.tuple(input),
+    output,
+  });
+  return z
+    .custom<(...args: z.output<z.ZodTuple<TInput, null>>) => z.input<TOutput>>((arg) => typeof arg === "function")
+    .transform((arg) => schema.implement(arg));
+};

package/src/types.ts

@@ -1,14 +1,15 @@
-import type { Require, Prettify } from "@serwist/utils";
-import type { PackageJson } from "type-fest";
+import type { Prettify, Require } from "@serwist/utils";
 import type { z } from "zod";
-import type { manifestEntry } from "./schema/manifestEntry.js";
-import type { manifestTransform, manifestTransformResult } from "./schema/manifestTransform.js";
+import type { manifestEntry, manifestEntryWithSize } from "./schema/manifest-entry.js";
+import type { manifestTransform, manifestTransformResult } from "./schema/manifest-transform.js";
 
-export type ManifestEntry = z.input<typeof manifestEntry>;
+export interface ManifestTransformResult extends z.infer<typeof manifestTransformResult> {}
 
-export type ManifestTransformResult = z.input<typeof manifestTransformResult>;
+export interface ManifestEntry extends z.infer<typeof manifestEntry> {}
 
-export type ManifestTransform = z.input<typeof manifestTransform>;
+export interface ManifestEntryWithSize extends z.infer<typeof manifestEntryWithSize> {}
+
+export interface ManifestTransform extends z.infer<typeof manifestTransform> {}
 
 export interface BasePartial {
   /**
@@ -116,7 +117,7 @@ export interface GlobPartial {
    * [`node-glob`'s Glob Primer](https://github.com/isaacs/node-glob#glob-primer).
    * @default
    * ```
-   * ["**\/*.{js,css,html}"]
+   * ["**\/*.{js,css,html,ico,apng,png,avif,jpg,jpeg,jfif,pjpeg,pjp,gif,svg,webp,json,webmanifest}"]
    * ```
    */
   globPatterns?: string[];
@@ -201,27 +202,3 @@ export interface GetManifestResult {
 export type BuildResult = Omit<GetManifestResult, "manifestEntries"> & {
   filePaths: string[];
 };
-
-/**
- * @private
- */
-export interface FileDetails {
-  file: string;
-  hash: string | null;
-  size: number;
-}
-
-/**
- * @private
- */
-export type BuildType = "dev" | "prod";
-
-/**
- * @private
- */
-export type SerwistPackageJSON = Prettify<PackageJson>;
-
-/**
- * @private
- */
-export type MethodNames = "GetManifest" | "InjectManifest" | "WebpackInjectManifest" | "ViteInjectManifest";

package/dist/chunks/getManifest.js

@@ -1,6 +0,0 @@
-import { b as basePartial, g as globPartial, r as requiredGlobDirectoryPartial } from './glob.js';
-import 'zod';
-
-const getManifestOptions = basePartial.merge(globPartial).merge(requiredGlobDirectoryPartial).strict("Do not pass invalid properties to GetManifestOptions!");
-
-export { getManifestOptions };

package/dist/chunks/injectManifest.js

@@ -1,23 +0,0 @@
-import { z } from 'zod';
-import { b as basePartial, g as globPartial, r as requiredGlobDirectoryPartial } from './glob.js';
-
-const optionalSwDestPartial = z.object({
-    swDest: z.string().optional()
-}).strict("Do not pass invalid properties to OptionalSwDest!");
-const requiredSwDestPartial = z.object({
-    swDest: z.string()
-}).strict("Do not pass invalid properties to RequiredSwDest!");
-
-const baseInjectPartial = z.object({
-    injectionPoint: z.string().min(1, "`injectionPoint` must not be empty!").default("self.__SW_MANIFEST"),
-    swSrc: z.string().min(1, "`swSrc` must not be empty!")
-}).strict("Do not pass invalid properties to InjectPartial!");
-const injectManifestOptions = basePartial.merge(globPartial).merge(baseInjectPartial).merge(requiredSwDestPartial).merge(requiredGlobDirectoryPartial).strict("Do not pass invalid properties to InjectManifestOptions!");
-
-var injectManifest = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  baseInjectPartial: baseInjectPartial,
-  injectManifestOptions: injectManifestOptions
-});
-
-export { injectManifest as a, baseInjectPartial as b, injectManifestOptions as i, optionalSwDestPartial as o, requiredSwDestPartial as r };

package/dist/chunks/validationErrorMap.js

@@ -1,54 +0,0 @@
-import { z } from 'zod';
-
-class SerwistConfigError extends Error {
-    constructor({ moduleName, message }){
-        super(`Received an invalid ${moduleName ?? "Serwist"} configuration: ${message}`);
-        Object.setPrototypeOf(this, new.target.prototype);
-    }
-}
-
-const validationErrorMap = (error, ctx)=>{
-    switch(error.code){
-        case z.ZodIssueCode.invalid_type:
-            {
-                return {
-                    message: `${error.message ?? "Received invalid type"}: expected ${error.expected}, received ${error.received}.`
-                };
-            }
-        case z.ZodIssueCode.invalid_literal:
-            {
-                return {
-                    message: `${error.message ?? "Received invalid literal"}: expected ${error.expected}, received ${error.received}.`
-                };
-            }
-        case z.ZodIssueCode.unrecognized_keys:
-            {
-                return {
-                    message: `${error.message ?? "Received unrecognized keys"}: ${error.keys.join(",")}`
-                };
-            }
-        case z.ZodIssueCode.invalid_arguments:
-            {
-                return {
-                    message: `${error.message ?? "Received invalid arguments"}: ${error.argumentsError.errors.map((e)=>validationErrorMap(e, ctx)).join(",")}.`
-                };
-            }
-        case z.ZodIssueCode.invalid_return_type:
-            {
-                return {
-                    message: `${error.message ?? "Received invalid return type"}: ${error.returnTypeError.errors.map((e)=>validationErrorMap(e, ctx)).join(",")}.`
-                };
-            }
-        case z.ZodIssueCode.custom:
-            {
-                return {
-                    message: error.message ?? ctx.defaultError
-                };
-            }
-    }
-    return {
-        message: ctx.defaultError
-    };
-};
-
-export { SerwistConfigError as S, validationErrorMap as v };

package/dist/lib/errors.d.ts

@@ -1,47 +0,0 @@
-export declare const errors: {
-    "unable-to-get-rootdir": string;
-    "no-extension": string;
-    "invalid-file-manifest-name": string;
-    "unable-to-get-file-manifest-name": string;
-    "invalid-sw-dest": string;
-    "unable-to-get-sw-name": string;
-    "unable-to-get-save-config": string;
-    "unable-to-get-file-hash": string;
-    "unable-to-get-file-size": string;
-    "unable-to-glob-files": string;
-    "unable-to-make-manifest-directory": string;
-    "read-manifest-template-failure": string;
-    "populating-manifest-tmpl-failed": string;
-    "manifest-file-write-failure": string;
-    "unable-to-make-sw-directory": string;
-    "sw-write-failure": string;
-    "sw-write-failure-directory": string;
-    "unable-to-copy-serwist-libraries": string;
-    "invalid-glob-directory": string;
-    "invalid-dont-cache-bust": string;
-    "invalid-exclude-files": string;
-    "invalid-get-manifest-entries-input": string;
-    "invalid-manifest-path": string;
-    "invalid-manifest-entries": string;
-    "invalid-manifest-format": string;
-    "invalid-static-file-globs": string;
-    "invalid-templated-urls": string;
-    "templated-url-matches-glob": string;
-    "invalid-glob-ignores": string;
-    "manifest-entry-bad-url": string;
-    "modify-url-prefix-bad-prefixes": string;
-    "invalid-inject-manifest-arg": string;
-    "injection-point-not-found": string;
-    "multiple-injection-points": string;
-    "useless-glob-pattern": string;
-    "bad-template-urls-asset": string;
-    "invalid-generate-file-manifest-arg": string;
-    "invalid-sw-src": string;
-    "same-src-and-dest": string;
-    "no-module-name": string;
-    "bad-manifest-transforms-return-value": string;
-    "string-entry-warning": string;
-    "cant-find-sourcemap": string;
-    "manifest-transforms": string;
-};
-//# sourceMappingURL=errors.d.ts.map

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

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

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

@@ -1,3 +0,0 @@
-import type { FileDetails } from "../types.js";
-export declare const getCompositeDetails: (compositeURL: string, dependencyDetails: FileDetails[]) => FileDetails;
-//# sourceMappingURL=get-composite-details.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"get-composite-details.d.ts","sourceRoot":"","sources":["../../src/lib/get-composite-details.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,eAAO,MAAM,mBAAmB,iBAAkB,MAAM,qBAAqB,WAAW,EAAE,KAAG,WAkB5F,CAAC"}

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

@@ -1,2 +0,0 @@
-export declare const getFileHash: (file: string) => string;
-//# sourceMappingURL=get-file-hash.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"get-file-hash.d.ts","sourceRoot":"","sources":["../../src/lib/get-file-hash.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,WAAW,SAAU,MAAM,KAAG,MAO1C,CAAC"}

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

@@ -1,2 +0,0 @@
-export declare const getFileSize: (file: string) => number | null;
-//# sourceMappingURL=get-file-size.d.ts.map