@serwist/build 10.0.0-preview.8 → 10.0.0-preview.9

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,32 +8,25 @@ import type {
   RequiredGlobDirectoryPartial,
   RequiredGlobDirectoryResolved,
 } from "../types.js";
-import { type Equals, assertType } from "./assertType.js";
-import { DEFAULT_GLOB_PATTERNS } from "../lib/constants.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(DEFAULT_GLOB_PATTERNS),
-    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().default("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,7 @@
+import { z } from "zod";
+
+export const manifestEntry = z.strictObject({
+  integrity: z.string().optional(),
+  revision: z.string().nullable().optional(),
+  url: z.string(),
+});

package/src/schema/manifest-transform.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { manifestEntry } from "./manifest-entry.js";
+import { asyncFn } from "./utils.js";
+
+const sizeObject = z.object({ size: z.number() });
+
+const manifestEntryWithSize = z.object({ ...manifestEntry.shape, ...sizeObject.shape });
+
+export const manifestTransformResult = z.strictObject({
+  manifest: z.array(manifestEntryWithSize),
+  warnings: z.array(z.string()).optional(),
+});
+
+export const manifestTransform = asyncFn({
+  input: [z.array(manifestEntryWithSize), z.unknown().optional()],
+  output: 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,27 @@
+import { z } from "zod";
+
+export const fn = <TInput extends [z.ZodType, ...z.ZodType[]], TOutput extends z.ZodType>({ input, output }: { input: TInput; output: TOutput }) => {
+  const schema = z.function({
+    input: z.tuple(input),
+    output,
+  });
+  return z
+    .custom<z.core.$InferInnerFunctionType<z.ZodTuple<TInput, null>, TOutput>>((arg) => typeof arg === "function")
+    .transform((arg) => schema.implement(arg));
+};
+
+export const asyncFn = <TInput extends [z.ZodType, ...z.ZodType[]], TOutput extends z.ZodType>({
+  input,
+  output,
+}: {
+  input: TInput;
+  output: TOutput;
+}) => {
+  const schema = z.function({
+    input: z.tuple(input),
+    output,
+  });
+  return z
+    .custom<z.core.$InferInnerFunctionTypeAsync<z.ZodTuple<TInput, null>, TOutput>>((arg) => typeof arg === "function")
+    .transform((arg) => schema.implementAsync(arg));
+};

package/src/types.ts

@@ -1,14 +1,20 @@
-import type { Prettify, Require } from "@serwist/utils";
+import type { MaybePromise, Prettify, Require } from "@serwist/utils";
 import type { PackageJson } from "type-fest";
 import type { z } from "zod";
-import type { manifestEntry } from "./schema/manifestEntry.js";
-import type { manifestTransform, manifestTransformResult } from "./schema/manifestTransform.js";
+import type { manifestEntry } from "./schema/manifest-entry.js";
+import type { manifestTransformResult } from "./schema/manifest-transform.js";
 
 export type ManifestEntry = z.input<typeof manifestEntry>;
 
 export type ManifestTransformResult = z.input<typeof manifestTransformResult>;
 
-export type ManifestTransform = z.input<typeof manifestTransform>;
+export type ManifestTransform = (
+  entries: (ManifestEntry & { size: number })[],
+  params?: unknown,
+) => MaybePromise<{
+  manifest: (ManifestEntry & { size: number })[];
+  warnings?: string[] | undefined;
+}>;
 
 export interface BasePartial {
   /**

package/dist/chunks/getManifest.js

@@ -1,7 +0,0 @@
-import { b as basePartial, g as globPartial, r as requiredGlobDirectoryPartial } from './glob.js';
-import 'zod';
-import './constants.js';
-
-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/schema/assertType.d.ts.map

@@ -1 +0,0 @@
-{"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,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAE9D,wBAAgB,UAAU,CAAC,EAAE,SAAS,IAAI,UAEzC"}

package/dist/schema/getManifest.d.ts

@@ -1,192 +0,0 @@
-import type { z } from "zod";
-export declare const getManifestOptions: z.ZodObject<{
-    additionalPrecacheEntries: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        url: string;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    }, {
-        url: string;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    }>]>, "many">>;
-    disablePrecacheManifest: z.ZodDefault<z.ZodBoolean>;
-    dontCacheBustURLsMatching: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
-    manifestTransforms: z.ZodOptional<z.ZodArray<z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    } & {
-        size: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    }, {
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    }>, "many">, z.ZodOptional<z.ZodUnknown>], null>, z.ZodUnion<[z.ZodPromise<z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        } & {
-            size: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }, {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }>, "many">;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }, {
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        } & {
-            size: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }, {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }>, "many">;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }, {
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>]>>, "many">>;
-    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, "many">>;
-    globPatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    globStrict: z.ZodDefault<z.ZodBoolean>;
-    templatedURLs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
-} & {
-    globDirectory: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    disablePrecacheManifest: boolean;
-    maximumFileSizeToCacheInBytes: number;
-    globFollow: boolean;
-    globIgnores: string[];
-    globPatterns: string[];
-    globStrict: boolean;
-    globDirectory: string;
-    additionalPrecacheEntries?: (string | {
-        url: string;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    })[] | undefined;
-    dontCacheBustURLsMatching?: RegExp | undefined;
-    manifestTransforms?: ((args_0: {
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    }[], args_1: unknown) => {
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    } | Promise<{
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>)[] | undefined;
-    modifyURLPrefix?: Record<string, string> | undefined;
-    templatedURLs?: Record<string, string | string[]> | undefined;
-}, {
-    globDirectory: string;
-    disablePrecacheManifest?: boolean | undefined;
-    maximumFileSizeToCacheInBytes?: number | undefined;
-    additionalPrecacheEntries?: (string | {
-        url: string;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    })[] | undefined;
-    dontCacheBustURLsMatching?: RegExp | undefined;
-    manifestTransforms?: ((args_0: {
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    }[], args_1: unknown) => {
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    } | Promise<{
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>)[] | undefined;
-    modifyURLPrefix?: Record<string, string> | undefined;
-    globFollow?: boolean | undefined;
-    globIgnores?: string[] | undefined;
-    globPatterns?: string[] | undefined;
-    globStrict?: boolean | undefined;
-    templatedURLs?: Record<string, string | string[]> | undefined;
-}>;
-//# sourceMappingURL=getManifest.d.ts.map

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

@@ -1 +0,0 @@
-{"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/injectManifest.d.ts

@@ -1,213 +0,0 @@
-import { z } from "zod";
-export declare const baseInjectPartial: z.ZodObject<{
-    injectionPoint: z.ZodDefault<z.ZodString>;
-    swSrc: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    injectionPoint: string;
-    swSrc: string;
-}, {
-    swSrc: string;
-    injectionPoint?: string | undefined;
-}>;
-export declare const injectManifestOptions: z.ZodObject<{
-    additionalPrecacheEntries: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        url: string;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    }, {
-        url: string;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    }>]>, "many">>;
-    disablePrecacheManifest: z.ZodDefault<z.ZodBoolean>;
-    dontCacheBustURLsMatching: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
-    manifestTransforms: z.ZodOptional<z.ZodArray<z.ZodFunction<z.ZodTuple<[z.ZodArray<z.ZodObject<{
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        url: z.ZodString;
-    } & {
-        size: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    }, {
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    }>, "many">, z.ZodOptional<z.ZodUnknown>], null>, z.ZodUnion<[z.ZodPromise<z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        } & {
-            size: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }, {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }>, "many">;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }, {
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            url: z.ZodString;
-        } & {
-            size: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }, {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }>, "many">;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }, {
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>]>>, "many">>;
-    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, "many">>;
-    globPatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    globStrict: z.ZodDefault<z.ZodBoolean>;
-    templatedURLs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>>;
-} & {
-    injectionPoint: z.ZodDefault<z.ZodString>;
-    swSrc: z.ZodString;
-} & {
-    swDest: z.ZodString;
-} & {
-    globDirectory: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    disablePrecacheManifest: boolean;
-    maximumFileSizeToCacheInBytes: number;
-    globFollow: boolean;
-    globIgnores: string[];
-    globPatterns: string[];
-    globStrict: boolean;
-    injectionPoint: string;
-    swSrc: string;
-    globDirectory: string;
-    swDest: string;
-    additionalPrecacheEntries?: (string | {
-        url: string;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    })[] | undefined;
-    dontCacheBustURLsMatching?: RegExp | undefined;
-    manifestTransforms?: ((args_0: {
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    }[], args_1: unknown) => {
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    } | Promise<{
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>)[] | undefined;
-    modifyURLPrefix?: Record<string, string> | undefined;
-    templatedURLs?: Record<string, string | string[]> | undefined;
-}, {
-    swSrc: string;
-    globDirectory: string;
-    swDest: string;
-    disablePrecacheManifest?: boolean | undefined;
-    maximumFileSizeToCacheInBytes?: number | undefined;
-    additionalPrecacheEntries?: (string | {
-        url: string;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    })[] | undefined;
-    dontCacheBustURLsMatching?: RegExp | undefined;
-    manifestTransforms?: ((args_0: {
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-        revision?: string | null | undefined;
-    }[], args_1: unknown) => {
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    } | Promise<{
-        manifest: {
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-            revision?: string | null | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>)[] | undefined;
-    modifyURLPrefix?: Record<string, string> | undefined;
-    globFollow?: boolean | undefined;
-    globIgnores?: string[] | undefined;
-    globPatterns?: string[] | undefined;
-    globStrict?: boolean | undefined;
-    templatedURLs?: Record<string, string | string[]> | undefined;
-    injectionPoint?: string | undefined;
-}>;
-//# sourceMappingURL=injectManifest.d.ts.map

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

@@ -1 +0,0 @@
-{"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,iBAAiB;;;;;;;;;EAK+B,CAAC;AAE9D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKmC,CAAC"}

package/dist/schema/manifestEntry.d.ts

@@ -1,15 +0,0 @@
-import { z } from "zod";
-export declare const manifestEntry: z.ZodObject<{
-    integrity: z.ZodOptional<z.ZodString>;
-    revision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    url: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    url: string;
-    integrity?: string | undefined;
-    revision?: string | null | undefined;
-}, {
-    url: string;
-    integrity?: string | undefined;
-    revision?: string | null | undefined;
-}>;
-//# sourceMappingURL=manifestEntry.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"manifestEntry.d.ts","sourceRoot":"","sources":["../../src/schema/manifestEntry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,aAAa;;;;;;;;;;;;EAMmC,CAAC"}