@serwist/build 9.0.0-preview.12 → 9.0.0-preview.14

package/dist/schema/vite.d.ts

@@ -1,196 +0,0 @@
-import type { z } from "zod";
-export declare const viteInjectManifestOptions: z.ZodObject<{
-    disablePrecacheManifest: z.ZodDefault<z.ZodBoolean>;
-    maximumFileSizeToCacheInBytes: z.ZodDefault<z.ZodNumber>;
-    additionalPrecacheEntries: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodNullable<z.ZodString>;
-        url: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        revision: string | null;
-        url: string;
-        integrity?: string | undefined;
-    }, {
-        revision: string | null;
-        url: string;
-        integrity?: string | undefined;
-    }>]>, "many">>;
-    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.ZodNullable<z.ZodString>;
-        url: z.ZodString;
-        size: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        revision: string | null;
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-    }, {
-        revision: string | null;
-        url: string;
-        size: number;
-        integrity?: string | 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.ZodNullable<z.ZodString>;
-            url: z.ZodString;
-            size: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }, {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }>, "many">;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }, {
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodNullable<z.ZodString>;
-            url: z.ZodString;
-            size: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }, {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }>, "many">;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }, {
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>]>>, "many">>;
-    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;
-    swDest: string;
-    globDirectory: string;
-    additionalPrecacheEntries?: (string | {
-        revision: string | null;
-        url: string;
-        integrity?: string | undefined;
-    })[] | undefined;
-    dontCacheBustURLsMatching?: RegExp | undefined;
-    manifestTransforms?: ((args_0: {
-        revision: string | null;
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-    }[], args_1: unknown) => {
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    } | Promise<{
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>)[] | undefined;
-    modifyURLPrefix?: Record<string, string> | undefined;
-    templatedURLs?: Record<string, string | string[]> | undefined;
-}, {
-    swSrc: string;
-    swDest: string;
-    globDirectory: string;
-    disablePrecacheManifest?: boolean | undefined;
-    maximumFileSizeToCacheInBytes?: number | undefined;
-    additionalPrecacheEntries?: (string | {
-        revision: string | null;
-        url: string;
-        integrity?: string | undefined;
-    })[] | undefined;
-    dontCacheBustURLsMatching?: RegExp | undefined;
-    manifestTransforms?: ((args_0: {
-        revision: string | null;
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-    }[], args_1: unknown) => {
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    } | Promise<{
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | 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=vite.d.ts.map

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

@@ -1 +0,0 @@
-{"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"}

package/dist/schema/webpack.d.ts

@@ -1,225 +0,0 @@
-import { z } from "zod";
-export declare const webpackPartial: z.ZodObject<{
-    chunks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    exclude: z.ZodDefault<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>, z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>]>, "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">>;
-}, "strict", z.ZodTypeAny, {
-    exclude: (string | RegExp | ((args_0: any) => boolean))[];
-    chunks?: string[] | undefined;
-    excludeChunks?: string[] | undefined;
-    include?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
-}, {
-    chunks?: string[] | undefined;
-    exclude?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
-    excludeChunks?: string[] | undefined;
-    include?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
-}>;
-export declare const webpackInjectManifestPartial: z.ZodObject<{
-    compileSrc: z.ZodDefault<z.ZodBoolean>;
-    swDest: z.ZodOptional<z.ZodString>;
-    webpackCompilationPlugins: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
-}, "strict", z.ZodTypeAny, {
-    compileSrc: boolean;
-    swDest?: string | undefined;
-    webpackCompilationPlugins?: any[] | undefined;
-}, {
-    compileSrc?: boolean | undefined;
-    swDest?: string | undefined;
-    webpackCompilationPlugins?: any[] | undefined;
-}>;
-export declare const webpackInjectManifestOptions: z.ZodObject<{
-    disablePrecacheManifest: z.ZodDefault<z.ZodBoolean>;
-    maximumFileSizeToCacheInBytes: z.ZodDefault<z.ZodNumber>;
-    additionalPrecacheEntries: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
-        integrity: z.ZodOptional<z.ZodString>;
-        revision: z.ZodNullable<z.ZodString>;
-        url: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        revision: string | null;
-        url: string;
-        integrity?: string | undefined;
-    }, {
-        revision: string | null;
-        url: string;
-        integrity?: string | undefined;
-    }>]>, "many">>;
-    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.ZodNullable<z.ZodString>;
-        url: z.ZodString;
-        size: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        revision: string | null;
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-    }, {
-        revision: string | null;
-        url: string;
-        size: number;
-        integrity?: string | 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.ZodNullable<z.ZodString>;
-            url: z.ZodString;
-            size: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }, {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }>, "many">;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }, {
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>>, z.ZodObject<{
-        manifest: z.ZodArray<z.ZodObject<{
-            integrity: z.ZodOptional<z.ZodString>;
-            revision: z.ZodNullable<z.ZodString>;
-            url: z.ZodString;
-            size: z.ZodNumber;
-        }, "strip", z.ZodTypeAny, {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }, {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }>, "many">;
-        warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }, {
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>]>>, "many">>;
-    modifyURLPrefix: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    injectionPoint: z.ZodDefault<z.ZodString>;
-    swSrc: z.ZodString;
-    exclude: z.ZodDefault<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>, z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodBoolean>]>, "many">>;
-    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">>;
-    compileSrc: z.ZodDefault<z.ZodBoolean>;
-    swDest: z.ZodOptional<z.ZodString>;
-    webpackCompilationPlugins: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
-}, "strict", z.ZodTypeAny, {
-    disablePrecacheManifest: boolean;
-    maximumFileSizeToCacheInBytes: number;
-    injectionPoint: string;
-    swSrc: string;
-    exclude: (string | RegExp | ((args_0: any) => boolean))[];
-    compileSrc: boolean;
-    additionalPrecacheEntries?: (string | {
-        revision: string | null;
-        url: string;
-        integrity?: string | undefined;
-    })[] | undefined;
-    dontCacheBustURLsMatching?: RegExp | undefined;
-    manifestTransforms?: ((args_0: {
-        revision: string | null;
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-    }[], args_1: unknown) => {
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    } | Promise<{
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>)[] | undefined;
-    modifyURLPrefix?: Record<string, string> | undefined;
-    chunks?: string[] | undefined;
-    excludeChunks?: string[] | undefined;
-    include?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
-    swDest?: string | undefined;
-    webpackCompilationPlugins?: any[] | undefined;
-}, {
-    swSrc: string;
-    disablePrecacheManifest?: boolean | undefined;
-    maximumFileSizeToCacheInBytes?: number | undefined;
-    additionalPrecacheEntries?: (string | {
-        revision: string | null;
-        url: string;
-        integrity?: string | undefined;
-    })[] | undefined;
-    dontCacheBustURLsMatching?: RegExp | undefined;
-    manifestTransforms?: ((args_0: {
-        revision: string | null;
-        url: string;
-        size: number;
-        integrity?: string | undefined;
-    }[], args_1: unknown) => {
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    } | Promise<{
-        manifest: {
-            revision: string | null;
-            url: string;
-            size: number;
-            integrity?: string | undefined;
-        }[];
-        warnings?: string[] | undefined;
-    }>)[] | undefined;
-    modifyURLPrefix?: Record<string, string> | undefined;
-    injectionPoint?: string | undefined;
-    exclude?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
-    chunks?: string[] | undefined;
-    excludeChunks?: string[] | undefined;
-    include?: (string | RegExp | ((args_0: any) => boolean))[] | undefined;
-    compileSrc?: boolean | undefined;
-    swDest?: string | undefined;
-    webpackCompilationPlugins?: any[] | undefined;
-}>;
-//# sourceMappingURL=webpack.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"webpack.d.ts","sourceRoot":"","sources":["../../src/schema/webpack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;EASmC,CAAC;AAE/D,eAAO,MAAM,4BAA4B;;;;;;;;;;;;EAMmC,CAAC;AAE7E,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKmC,CAAC"}

package/src/index.next.ts

@@ -1,3 +0,0 @@
-import { validateNextInjectManifestOptions } from "./lib/validate-next-options.js";
-
-export { validateNextInjectManifestOptions };

package/src/lib/validate-next-options.ts

@@ -1,14 +0,0 @@
-import { nextInjectManifestOptions } from "../schema/next.js";
-import { validationErrorMap } from "../schema/validationErrorMap.js";
-import type { NextInjectManifestOptionsComplete } from "../types.js";
-import { SerwistConfigError } from "./serwist-config-error.js";
-
-export const validateNextInjectManifestOptions = (input: unknown): NextInjectManifestOptionsComplete => {
-  const result = nextInjectManifestOptions.safeParse(input, {
-    errorMap: validationErrorMap,
-  });
-  if (!result.success) {
-    throw new SerwistConfigError({ moduleName: "@serwist/next", message: JSON.stringify(result.error.format(), null, 2) });
-  }
-  return result.data;
-};

package/src/schema/next.ts

@@ -1,33 +0,0 @@
-import { z } from "zod";
-import type {
-  NextInjectManifestOptions,
-  NextInjectManifestOptionsComplete,
-  NextInjectManifestPartial,
-  NextInjectManifestResolved,
-} from "../types.js";
-import { type Equals, assertType } from "./assertType.js";
-import { requiredSwDestPartial } from "./swDest.js";
-import { webpackInjectManifestOptions } from "./webpack.js";
-
-export const nextInjectManifestPartial = z
-  .object({
-    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.union([z.string(), z.array(z.string())]).default(["**/*"]),
-  })
-  .strict("Do not pass invalid properties to NextInjectManifestPartial!");
-
-export const nextInjectManifestOptions = webpackInjectManifestOptions
-  .merge(requiredSwDestPartial)
-  .merge(nextInjectManifestPartial)
-  .omit({ disablePrecacheManifest: true })
-  .strict("Do not pass invalid properties to NextInjectManifestOptions!");
-
-assertType<Equals<NextInjectManifestPartial, z.input<typeof nextInjectManifestPartial>>>();
-assertType<Equals<NextInjectManifestResolved, z.output<typeof nextInjectManifestPartial>>>();
-assertType<Equals<NextInjectManifestOptions, z.input<typeof nextInjectManifestOptions>>>();
-assertType<Equals<NextInjectManifestOptionsComplete, z.output<typeof nextInjectManifestOptions>>>();

package/src/schema/vite.ts

@@ -1,18 +0,0 @@
-import type { z } from "zod";
-import type { ViteInjectManifestOptions, ViteInjectManifestOptionsComplete } from "../types.js";
-import { type Equals, assertType } from "./assertType.js";
-import { basePartial } from "./base.js";
-import { globPartial } from "./glob.js";
-import { requiredGlobDirectoryPartial } from "./glob.js";
-import { injectPartial } from "./injectManifest.js";
-import { requiredSwDestPartial } from "./swDest.js";
-
-export const viteInjectManifestOptions = basePartial
-  .merge(globPartial)
-  .merge(injectPartial)
-  .merge(requiredSwDestPartial)
-  .merge(requiredGlobDirectoryPartial)
-  .strict("Do not pass invalid properties to ViteInjectManifestPartial!");
-
-assertType<Equals<ViteInjectManifestOptions, z.input<typeof viteInjectManifestOptions>>>();
-assertType<Equals<ViteInjectManifestOptionsComplete, z.output<typeof viteInjectManifestOptions>>>();

package/src/schema/webpack.ts

@@ -1,46 +0,0 @@
-import { z } from "zod";
-import type {
-  WebpackInjectManifestOptions,
-  WebpackInjectManifestOptionsComplete,
-  WebpackInjectManifestPartial,
-  WebpackInjectManifestResolved,
-  WebpackPartial,
-  WebpackResolved,
-} from "../types.js";
-import { type Equals, assertType } from "./assertType.js";
-import { basePartial } from "./base.js";
-import { injectPartial } from "./injectManifest.js";
-import { optionalSwDestPartial } from "./swDest.js";
-
-export const webpackPartial = z
-  .object({
-    chunks: z.array(z.string()).optional(),
-    exclude: z
-      .array(z.union([z.string(), z.instanceof(RegExp), z.function(z.tuple([z.any()]), z.boolean())]))
-      .default([/\.map$/, /^manifest.*\.js$/]),
-    excludeChunks: z.array(z.string()).optional(),
-    include: z.array(z.union([z.string(), z.instanceof(RegExp), z.function(z.tuple([z.any()]), z.boolean())])).optional(),
-  })
-  .strict("Do not pass invalid properties to WebpackPartial!");
-
-export const webpackInjectManifestPartial = z
-  .object({
-    compileSrc: z.boolean().default(true),
-    swDest: z.string().optional(),
-    webpackCompilationPlugins: z.array(z.any()).optional(),
-  })
-  .strict("Do not pass invalid properties to WebpackInjectManifestPartial!");
-
-export const webpackInjectManifestOptions = basePartial
-  .merge(webpackPartial)
-  .merge(injectPartial)
-  .merge(optionalSwDestPartial)
-  .merge(webpackInjectManifestPartial)
-  .strict("Do not pass invalid properties to WebpackInjectManifestOptions!");
-
-assertType<Equals<z.input<typeof webpackPartial>, WebpackPartial>>();
-assertType<Equals<WebpackResolved, z.output<typeof webpackPartial>>>();
-assertType<Equals<WebpackInjectManifestPartial, z.input<typeof webpackInjectManifestPartial>>>();
-assertType<Equals<WebpackInjectManifestResolved, z.output<typeof webpackInjectManifestPartial>>>();
-assertType<Equals<WebpackInjectManifestOptions, z.input<typeof webpackInjectManifestOptions>>>();
-assertType<Equals<WebpackInjectManifestOptionsComplete, z.output<typeof webpackInjectManifestOptions>>>();

package/dist/chunks/{serwist-config-error.js → validationErrorMap.js}

@@ -1,5 +1,12 @@
 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:
@@ -44,11 +51,4 @@ const validationErrorMap = (error, ctx)=>{
     };
 };
 
-class SerwistConfigError extends Error {
-    constructor({ moduleName, message }){
-        super(`Received an invalid ${moduleName ?? "Serwist"} configuration: ${message}`);
-        Object.setPrototypeOf(this, new.target.prototype);
-    }
-}
-
 export { SerwistConfigError as S, validationErrorMap as v };