@spudlabs/guardis 0.4.0

package/esm/mod.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Guardis is a utility to help build type guard libraries while
+ * addressing one of the main potential sources of error in TypeScript's
+ * "type guard" behavior.
+ *
+ * @module Guardis
+ */
+export * from "./src/guard.js";
+export * from "./src/extend.js";
+export * from "./src/batch.js";
+export * from "./src/brand.js";
+export * from "./src/types.js";
+export { unionOf } from "./src/utilities.js";
+/**
+ * "Is" serves as the main libray object and contains
+ * keys corresponding to most of JavaScript's basic
+ * data types. The key values are callbacks that function as
+ * type guards for their respective types.
+ */
+export declare const Is: {
+    readonly Boolean: import("./mod.js").TypeGuard<boolean>;
+    readonly String: import("./mod.js").TypeGuard<string>;
+    readonly Number: import("./mod.js").TypeGuard<number>;
+    readonly Binary: import("./mod.js").TypeGuard<0 | 1>;
+    readonly Numeric: import("./mod.js").TypeGuard<number>;
+    readonly Symbol: import("./mod.js").TypeGuard<symbol>;
+    readonly Function: import("./mod.js").TypeGuard<(...args: unknown[]) => unknown>;
+    readonly Object: import("./mod.js").TypeGuard<object>;
+    readonly PropertyKey: import("./mod.js").TypeGuard<PropertyKey>;
+    readonly Undefined: import("./mod.js").TypeGuard<undefined>;
+    readonly Array: import("./mod.js").TypeGuard<unknown[]> & {
+        of: <T>(guard: import("./mod.js").TypeGuard<T>) => import("./mod.js").TypeGuard<T[]>;
+    };
+    readonly JsonPrimitive: import("./mod.js").TypeGuard<import("./mod.js").JsonPrimitive>;
+    readonly JsonArray: import("./mod.js").TypeGuard<import("./mod.js").JsonValue[] | readonly import("./mod.js").JsonValue[]>;
+    readonly JsonObject: import("./mod.js").TypeGuard<import("./mod.js").JsonObject>;
+    readonly JsonValue: import("./mod.js").TypeGuard<import("./mod.js").JsonValue>;
+    readonly Null: import("./mod.js").TypeGuard<null>;
+    readonly Nil: import("./mod.js").TypeGuard<null | undefined>;
+    readonly Empty: import("./mod.js").TypeGuard<"" | [] | Record<string, never> | null | undefined>;
+    readonly Iterable: import("./mod.js").TypeGuard<Iterable<unknown>>;
+    readonly Tuple: {
+        <N extends number>(t: unknown, length: N): t is import("./mod.js").TupleOfLength<N>;
+        strict<N extends number>(t: unknown, length: N, errorMsg?: string): t is import("./mod.js").TupleOfLength<N>;
+        assert: <N extends number>(t: unknown, length: N, errorMsg?: string) => asserts t is import("./mod.js").TupleOfLength<N>;
+        or<N extends number, T2>(length: N, guard: import("./mod.js").TypeGuard<T2>): import("./mod.js").TypeGuard<import("./mod.js").TupleOfLength<N> | T2>;
+        optional: {
+            <N extends number>(t: unknown, length: N): t is import("./mod.js").TupleOfLength<N> | undefined;
+            strict<N extends number>(t: unknown, length: N, errorMsg?: string): t is import("./mod.js").TupleOfLength<N> | undefined;
+            assert: <N extends number>(t: unknown, length: N, errorMsg?: string) => t is import("./mod.js").TupleOfLength<N> | undefined;
+        };
+    };
+    readonly Date: import("./mod.js").TypeGuard<Date>;
+};
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAI7C;;;;;GAKG;AACH,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBL,CAAC"}

package/esm/mod.js

@@ -0,0 +1,43 @@
+/**
+ * Guardis is a utility to help build type guard libraries while
+ * addressing one of the main potential sources of error in TypeScript's
+ * "type guard" behavior.
+ *
+ * @module Guardis
+ */
+export * from "./src/guard.js";
+export * from "./src/extend.js";
+export * from "./src/batch.js";
+export * from "./src/brand.js";
+export * from "./src/types.js";
+export { unionOf } from "./src/utilities.js";
+import * as g from "./src/guard.js";
+/**
+ * "Is" serves as the main libray object and contains
+ * keys corresponding to most of JavaScript's basic
+ * data types. The key values are callbacks that function as
+ * type guards for their respective types.
+ */
+export const Is = {
+    Boolean: g.isBoolean,
+    String: g.isString,
+    Number: g.isNumber,
+    Binary: g.isBinary,
+    Numeric: g.isNumeric,
+    Symbol: g.isSymbol,
+    Function: g.isFunction,
+    Object: g.isObject,
+    PropertyKey: g.isPropertyKey,
+    Undefined: g.isUndefined,
+    Array: g.isArray,
+    JsonPrimitive: g.isJsonPrimitive,
+    JsonArray: g.isJsonArray,
+    JsonObject: g.isJsonObject,
+    JsonValue: g.isJsonValue,
+    Null: g.isNull,
+    Nil: g.isNil,
+    Empty: g.isEmpty,
+    Iterable: g.isIterable,
+    Tuple: g.isTuple,
+    Date: g.isDate,
+};

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/specs/standard-schema-spec.v1.d.ts

@@ -0,0 +1,56 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** The non-existent issues. */
+        readonly issues?: undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+//# sourceMappingURL=standard-schema-spec.v1.d.ts.map

package/esm/specs/standard-schema-spec.v1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema-spec.v1.d.ts","sourceRoot":"","sources":["../../src/specs/standard-schema-spec.v1.ts"],"names":[],"mappings":"AAAA,qCAAqC;AACrC,MAAM,WAAW,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;IAC/D,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CAC7D;AAED,MAAM,CAAC,OAAO,WAAW,gBAAgB,CAAC;IACxC,gDAAgD;IAChD,UAAiB,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QACpD,0CAA0C;QAC1C,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;QACpB,6CAA6C;QAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,sCAAsC;QACtC,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QAChF,iDAAiD;QACjD,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;KACnD;IAED,qDAAqD;IACrD,KAAY,MAAM,CAAC,MAAM,IAAI,aAAa,CAAC,MAAM,CAAC,GAAG,aAAa,CAAC;IAEnE,mDAAmD;IACnD,UAAiB,aAAa,CAAC,MAAM;QACnC,8BAA8B;QAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,+BAA+B;QAC/B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;KAC7B;IAED,gDAAgD;IAChD,UAAiB,aAAa;QAC5B,uCAAuC;QACvC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAC;KACvC;IAED,iDAAiD;IACjD,UAAiB,KAAK;QACpB,sCAAsC;QACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,qCAAqC;QACrC,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,WAAW,GAAG,WAAW,CAAC,GAAG,SAAS,CAAC;KACtE;IAED,+CAA+C;IAC/C,UAAiB,WAAW;QAC1B,2CAA2C;QAC3C,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;KAC3B;IAED,2CAA2C;IAC3C,UAAiB,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QACpD,oCAAoC;QACpC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;QACtB,qCAAqC;QACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KACzB;IAED,kDAAkD;IAClD,KAAY,UAAU,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CACnE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,OAAO,CAAC,CAAC;IAEX,mDAAmD;IACnD,KAAY,WAAW,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CACpE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,QAAQ,CAAC,CAAC;CACb"}

package/esm/specs/standard-schema-spec.v1.js

@@ -0,0 +1 @@
+export {};

package/esm/src/batch.d.ts

@@ -0,0 +1,23 @@
+import type { InferEntry, ParserRecords, TypeGuard } from "./types.js";
+type GuardRecords<E extends ParserRecords, K extends keyof E = keyof E> = {
+    [key in K as `is${Capitalize<key & string>}`]: TypeGuard<InferEntry<E[key]>>;
+};
+/**
+ * Batch generate a set of type guard functions. The returned record
+ * will contain keys for each type, prefixed by `is`. These can be destructured
+ * to the corresponding type guards.
+ *
+ * @param config
+ * @returns
+ *
+ * Keys will be automatically capitalized in the returned object.
+ * _e.g._
+ * * `Meatball => isMeatball`
+ * * `sausage => isSausage`
+ *
+ * @example
+ * const { isMeatball } = batch({ Meatball: (v) => v === "meatball" ? v : null });
+ */
+export declare function batch<B extends ParserRecords>(config: B): GuardRecords<B>;
+export {};
+//# sourceMappingURL=batch.d.ts.map

package/esm/src/batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch.d.ts","sourceRoot":"","sources":["../../src/src/batch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAIvE,KAAK,YAAY,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI;KACvE,GAAG,IAAI,CAAC,IAAI,KAAK,UAAU,CAAC,GAAG,GAAG,MAAM,CAAC,EAAE,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;CAC7E,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,aAAa,EAAE,MAAM,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAKzE"}

package/esm/src/batch.js

@@ -0,0 +1,23 @@
+import { entryToGuard } from "./guard.js";
+import { toPascalCase } from "./helpers/strings.helpers.js";
+/**
+ * Batch generate a set of type guard functions. The returned record
+ * will contain keys for each type, prefixed by `is`. These can be destructured
+ * to the corresponding type guards.
+ *
+ * @param config
+ * @returns
+ *
+ * Keys will be automatically capitalized in the returned object.
+ * _e.g._
+ * * `Meatball => isMeatball`
+ * * `sausage => isSausage`
+ *
+ * @example
+ * const { isMeatball } = batch({ Meatball: (v) => v === "meatball" ? v : null });
+ */
+export function batch(config) {
+    const entries = Object.entries(config)
+        .map(([name, entry]) => [`is${toPascalCase(name)}`, entryToGuard(entry)]);
+    return Object.fromEntries(entries);
+}

package/esm/src/brand.d.ts

@@ -0,0 +1,62 @@
+import type { InferShape, Parser, TypeGuard, TypeGuardShape } from "./types.js";
+/**
+ * Creates a nominal type by intersecting a base type `T` with a unique brand `B`.
+ * This helps distinguish between types that are structurally identical but conceptually different.
+ */
+export type Brand<T, B extends string> = T & {
+    readonly __brand: B;
+};
+/**
+ * Removes the property with the key `brand` from the given type `T`.
+ */
+export type RemoveBrand<T> = T extends string ? string : T extends number ? number : T extends Record<infer K, infer V> ? Record<Exclude<K, "__brand">, V> : T extends (infer U)[] ? U[] : T extends object ? {
+    [P in Exclude<keyof T, "__brand">]: T[P];
+} : T[Exclude<keyof T, "__brand">];
+/**
+ * Creates a type guard for branded types, allowing runtime validation of nominal types.
+ *
+ * Branded types (also known as nominal types) are a TypeScript pattern that allows
+ * distinguishing between types that are structurally identical but conceptually different.
+ * This function creates a type guard that validates the underlying type while preserving
+ * the brand in the type system.
+ *
+ * @template T1 - The base type or a branded type
+ * @template B - The brand string (when using the first overload)
+ *
+ * @param parse - A parser function that validates the underlying type (without the brand)
+ * @returns A TypeGuard that validates the value and narrows it to the branded type
+ *
+ * @example
+ * ```typescript
+ * // Define branded types
+ * type UserId = Brand<string, "UserId">;
+ * type ProductId = Brand<string, "ProductId">;
+ *
+ * // Create parsers for the underlying type
+ * const parseUserId = (val: unknown): string | null =>
+ *   typeof val === "string" && val.startsWith("user_") ? val : null;
+ *
+ * // Create branded type guards
+ * const isUserId = createBrandedTypeGuard<string, "UserId">(parseUserId);
+ * const isProductId = createBrandedTypeGuard<ProductId>(isString._parser);
+ *
+ * // Create a named branded type guard (name infers the brand and appears in error messages)
+ * const isNamedUserId = createBrandedTypeGuard("UserId", parseUserId);
+ *
+ * // Create a branded type guard from a shape
+ * const isBrandedUser = createBrandedTypeGuard("User", { name: isString, age: isNumber });
+ *
+ * // Use the type guards
+ * const id: unknown = "user_123";
+ * if (isUserId(id)) {
+ *   // id is now typed as UserId
+ *   const userId: UserId = id;
+ * }
+ * ```
+ */
+export declare function createBrandedTypeGuard<S extends TypeGuardShape, B extends string>(name: B, shape: S): TypeGuard<Brand<InferShape<S>, B>>;
+export declare function createBrandedTypeGuard<S extends TypeGuardShape, B extends string>(shape: S): TypeGuard<Brand<InferShape<S>, B>>;
+export declare function createBrandedTypeGuard<T1, B extends string>(name: B, parse: Parser<T1>): TypeGuard<Brand<T1, B>>;
+export declare function createBrandedTypeGuard<T1, B extends string>(parse: Parser<T1>): TypeGuard<Brand<T1, B>>;
+export declare function createBrandedTypeGuard<T1 extends Brand<unknown, string>>(parse: Parser<RemoveBrand<T1>>): TypeGuard<T1>;
+//# sourceMappingURL=brand.d.ts.map

package/esm/src/brand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brand.d.ts","sourceRoot":"","sources":["../../src/src/brand.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEhF;;;GAGG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;CAAE,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,MAAM,GAClD,CAAC,SAAS,MAAM,GAAG,MAAM,GACzB,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC,GACrE,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,GAC3B,CAAC,SAAS,MAAM,GAAG;KAAG,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,GAC/D,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,cAAc,EAAE,CAAC,SAAS,MAAM,EAC/E,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,CAAC,GACP,SAAS,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACtC,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,cAAc,EAAE,CAAC,SAAS,MAAM,EAC/E,KAAK,EAAE,CAAC,GACP,SAAS,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACtC,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,CAAC,SAAS,MAAM,EACzD,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,GAChB,SAAS,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AAC3B,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,CAAC,SAAS,MAAM,EACzD,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC,GAChB,SAAS,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AAC3B,wBAAgB,sBAAsB,CAAC,EAAE,SAAS,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,EACtE,KAAK,EAAE,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,GAC7B,SAAS,CAAC,EAAE,CAAC,CAAC"}

package/esm/src/brand.js

@@ -0,0 +1,9 @@
+import { createTypeGuard } from "./guard.js";
+export function createBrandedTypeGuard(...args) {
+    const parserOrShape = args.length === 2 ? args[1] : args[0];
+    const name = args.length === 2 ? args[0] : undefined;
+    if (name !== undefined) {
+        return createTypeGuard(name, parserOrShape);
+    }
+    return createTypeGuard(parserOrShape);
+}

package/esm/src/context.d.ts

@@ -0,0 +1,19 @@
+import type { StandardSchemaV1 } from "../specs/standard-schema-spec.v1.js";
+import type { Context } from "./types.js";
+/**
+ * Creates a validation context for tracking paths and collecting issues during validation.
+ *
+ * @param path The current path segments (defaults to empty array for root)
+ * @param rootIssues Optional shared issues array (for propagating issues to parent context)
+ * @returns A new Context instance
+ */
+export declare function createContext(path?: PropertyKey[], rootIssues?: StandardSchemaV1.Issue[]): Context;
+/**
+ * Creates a strict validation context that throws TypeError immediately on first issue.
+ * Used by strict type guards to provide detailed error messages with path information.
+ *
+ * @param path The current path segments (defaults to empty array for root)
+ * @returns A Context that throws on addIssue instead of collecting issues
+ */
+export declare function createStrictContext(path?: PropertyKey[]): Context;
+//# sourceMappingURL=context.d.ts.map

package/esm/src/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/src/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,IAAI,GAAE,WAAW,EAAO,EACxB,UAAU,CAAC,EAAE,gBAAgB,CAAC,KAAK,EAAE,GACpC,OAAO,CAcT;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,GAAE,WAAW,EAAO,GAAG,OAAO,CAYrE"}

package/esm/src/context.js

@@ -0,0 +1,41 @@
+/**
+ * Creates a validation context for tracking paths and collecting issues during validation.
+ *
+ * @param path The current path segments (defaults to empty array for root)
+ * @param rootIssues Optional shared issues array (for propagating issues to parent context)
+ * @returns A new Context instance
+ */
+export function createContext(path = [], rootIssues) {
+    const issues = rootIssues ?? [];
+    return {
+        path,
+        issues,
+        pushPath(segment) {
+            return createContext([...path, segment], issues);
+        },
+        addIssue(message) {
+            // Only include path if it has segments (not at root level)
+            issues.push(path.length > 0 ? { message, path: [...path] } : { message });
+        },
+    };
+}
+/**
+ * Creates a strict validation context that throws TypeError immediately on first issue.
+ * Used by strict type guards to provide detailed error messages with path information.
+ *
+ * @param path The current path segments (defaults to empty array for root)
+ * @returns A Context that throws on addIssue instead of collecting issues
+ */
+export function createStrictContext(path = []) {
+    return {
+        path,
+        issues: [],
+        pushPath(segment) {
+            return createStrictContext([...path, segment]);
+        },
+        addIssue(message) {
+            const pathStr = path.length > 0 ? ` at path: ${path.join(".")}` : "";
+            throw new TypeError(`${message}${pathStr}`);
+        },
+    };
+}

package/esm/src/extend.d.ts

@@ -0,0 +1,23 @@
+import type { InferEntry, ParserRecords, TypeGuard } from "./types.js";
+import { Is } from "../mod.js";
+/** The return Is dictionary, merging both the definitions from the standard library
+ * and the custom type guards generated from the GuardExtension record. */
+export type ExtendedIs<E extends ParserRecords, I extends typeof Is> = {
+    [K in keyof I | keyof E]: K extends keyof I ? I[K] : K extends keyof E ? TypeGuard<InferEntry<E[K]>> : never;
+};
+/**
+ * Generate a custom Is dictionary using an object with the names of your types
+ * and the parsers to use to create type guards.
+ * @param config
+ * @returns
+ */
+export declare function extend<P extends ParserRecords>(config: P): ExtendedIs<P, typeof Is>;
+/**
+ * Clones the provided Is library and extends it by adding in your
+ * new parsers.
+ * @param Is The Is library to extend.
+ * @param config The catalog of parsers to include in your library.
+ * @returns
+ */
+export declare function extend<P extends ParserRecords, I extends typeof Is>(is: I, config: P): ExtendedIs<P, I>;
+//# sourceMappingURL=extend.d.ts.map

package/esm/src/extend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extend.d.ts","sourceRoot":"","sources":["../../src/src/extend.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvE,OAAO,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AAE/B;0EAC0E;AAC1E,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,SAAS,OAAO,EAAE,IAAI;KACpE,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,SAAS,MAAM,CAAC,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAClG,KAAK;CACR,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,aAAa,EAC5C,MAAM,EAAE,CAAC,GACR,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;AAC5B;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,aAAa,EAAE,CAAC,SAAS,OAAO,EAAE,EACjE,EAAE,EAAE,CAAC,EACL,MAAM,EAAE,CAAC,GACR,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/esm/src/extend.js

@@ -0,0 +1,9 @@
+import { entryToGuard } from "./guard.js";
+import { Is } from "../mod.js";
+export function extend(...args) {
+    const config = (1 in args ? args[1] : args[0]);
+    const is = 1 in args ? args[0] : Is;
+    const entries = Object.entries(config)
+        .map(([name, entry]) => [name, entryToGuard(entry)]);
+    return { ...Object.fromEntries(entries), ...(is ?? Is) };
+}