bupkis 0.2.0 → 0.4.0

package/dist/esm/util.d.ts

@@ -1,11 +1,5 @@
 /**
- * Utility functions for object satisfaction and shape validation.
- *
- * This module provides core utility functions for checking if objects satisfy
- * expected shapes, including `satisfies` for partial matching,
- * `exhaustivelySatisfies` for exact matching, and `shallowSatisfiesShape` for
- * converting shapes to Zod schemas. All functions handle circular references
- * safely.
+ * Utility functions.
  *
  * @category API
  * @example
@@ -17,58 +11,80 @@
  * @packageDocumentation
  */
 import { type StringKeyOf } from 'type-fest';
-import { z } from 'zod/v4';
-export declare function keyBy<const T extends readonly Record<PropertyKey, any>[], K extends StringKeyOf<T[number]>>(collection: T, key: K): Record<string, T[number]>;
+export * from './value-to-schema.js';
 /**
- * Recursively converts an arbitrary value to a Zod v4 schema that would
- * validate values with the same structure.
+ * _Recursively_ searches within an object, array, or any nested structure to
+ * find whether a specific key exists.
  *
- * This function analyzes the runtime value and generates a corresponding Zod
- * schema that captures the value's structure and type information. It handles
- * primitives, objects, arrays, functions, and various built-in types, with
- * support for circular reference detection.
+ * Handles circular references by tracking visited objects to prevent infinite
+ * recursion.
  *
  * @example
  *
- * ```typescript
- * // Primitive types
- * valueToSchema('hello'); // z.string()
- * valueToSchema(42); // z.number()
- * valueToSchema(true); // z.boolean()
+ * ```ts
+ * const obj = { a: 1, b: { c: 2, d: [{ e: 3 }] } };
  *
- * // Objects
- * valueToSchema({ name: 'John', age: 30 });
- * // z.object({ name: z.string(), age: z.number() })
+ * hasKey(obj, 'c'); // true
+ * hasKey(obj, 'e'); // true
+ * hasKey(obj, 'x'); // false (key not found)
+ * ```
  *
- * // Arrays
- * valueToSchema(['a', 'b', 'c']); // z.array(z.string())
- * valueToSchema([1, 'mixed']); // z.array(z.union([z.number(), z.string()]))
+ * @param obj The object, array, or value to search within
+ * @param key The key to search for
+ * @param visited Internal set for circular reference detection
+ * @returns True if the key is found anywhere in the structure, false otherwise
+ */
+export declare function hasKey(obj: unknown, key: PropertyKey, visited?: WeakSet<object>): boolean;
+/**
+ * _Recursively_ searches within an object, array, or any nested structure to
+ * find whether a specific value exists.
+ *
+ * Uses strict equality (===) to compare values, with special handling for empty
+ * objects. Handles circular references by tracking visited objects to prevent
+ * infinite recursion.
+ *
+ * @example
+ *
+ * ```ts
+ * const obj = { a: 1, b: { c: 2, d: [{ e: 3 }] }, empty: {} };
  *
- * // Nested structures
- * valueToSchema({ users: [{ name: 'John' }] });
- * // z.object({ users: z.array(z.object({ name: z.string() })) })
+ * hasValue(obj, 2); // true (found in obj.b.c)
+ * hasValue(obj, 3); // true (found in obj.b.d[0].e)
+ * hasValue(obj, {}); // true (found in obj.empty, matches empty objects)
+ * hasValue(obj, '1'); // false (strict equality, 1 !== '1')
+ * hasValue(obj, 999); // false (value not found)
  * ```
  *
- * @param value - The value to convert to a schema
- * @param options - Configuration options for schema generation
- * @param visited - Internal WeakSet for circular reference detection
- * @returns A Zod schema that validates values matching the input's structure
+ * @param obj The object, array, or value to search within
+ * @param value The value to search for (using strict equality, with special
+ *   empty object handling)
+ * @param visited Internal set for circular reference detection
+ * @returns True if the value is found anywhere in the structure, false
+ *   otherwise
  */
-export declare const valueToSchema: (value: unknown, options?: {
-    /** Current depth (internal) */
-    _currentDepth?: number;
-    /** Whether to allow mixed types in arrays (default: true) */
-    allowMixedArrays?: boolean;
-    /** If `true`, use `z.literal()` for primitive values instead of type schemas */
-    literalPrimitives?: boolean;
-    /**
-     * If `true`, treat `RegExp` literals as `RegExp` literals; otherwise treat
-     * as strings and attempt match
-     */
-    literalRegExp?: boolean;
-    /** Maximum nesting depth to prevent stack overflow (default: 10) */
-    maxDepth?: number;
-    /** If `true`, will disallow unknown properties in objects */
-    strict?: boolean;
-}, visited?: WeakSet<object>) => z.ZodType;
+export declare function hasValue(obj: unknown, value: unknown, visited?: WeakSet<object>): boolean;
+/**
+ * _Recursively_ searches for a key-value pair within an object or array.
+ *
+ * Uses strict equality (===) to compare values. Handles circular references by
+ * tracking visited objects to prevent infinite recursion.
+ *
+ * @example
+ *
+ * ```ts
+ * const obj = { a: 1, b: { c: 2, d: [{ e: 3 }] } };
+ *
+ * hasKeyValue(obj, 'c', 2); // true
+ * hasKeyValue(obj, 'e', 3); // true
+ * hasKeyValue(obj, 'a', '1'); // false (strict equality)
+ * hasKeyValue(obj, 'x', 1); // false (key not found)
+ * /**
+ * Maps an array of objects to an object keyed by the specified key.
+ *
+ * @param collection Array of objects
+ * @param key Name of key
+ * @returns Object mapping key values to objects
+ * ```
+ */
+export declare function keyBy<const T extends readonly Record<PropertyKey, any>[], K extends StringKeyOf<T[number]>>(collection: T, key: K): Record<string, T[number]>;
 //# sourceMappingURL=util.d.ts.map

package/dist/esm/util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAW3B,wBAAgB,KAAK,CACnB,KAAK,CAAC,CAAC,SAAS,SAAS,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,EAAE,EACnD,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAChC,UAAU,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAelD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,OAAO,EACd,UAAS;IACP,+BAA+B;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gFAAgF;IAChF,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,MAAM,CAAC,EAAE,OAAO,CAAC;CACb,EACN,yBAA+B,KAC9B,CAAC,CAAC,OAoKJ,CAAC"}
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAE7C,cAAc,sBAAsB,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,MAAM,CACpB,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,WAAW,EAChB,OAAO,kBAAwB,GAC9B,OAAO,CAuCT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,QAAQ,CACtB,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,OAAO,EACd,OAAO,kBAAwB,GAC9B,OAAO,CAyDT;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,KAAK,CACnB,KAAK,CAAC,CAAC,SAAS,SAAS,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,EAAE,EACnD,CAAC,SAAS,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAChC,UAAU,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAelD"}

package/dist/esm/util.js

@@ -1,11 +1,5 @@
 /**
- * Utility functions for object satisfaction and shape validation.
- *
- * This module provides core utility functions for checking if objects satisfy
- * expected shapes, including `satisfies` for partial matching,
- * `exhaustivelySatisfies` for exact matching, and `shallowSatisfiesShape` for
- * converting shapes to Zod schemas. All functions handle circular references
- * safely.
+ * Utility functions.
  *
  * @category API
  * @example
@@ -16,174 +10,179 @@
  *
  * @packageDocumentation
  */
-import { z } from 'zod/v4';
-import { isNonNullObject, isPromiseLike, isString } from './guards.js';
-import { FunctionSchema, RegExpSchema, StrongMapSchema, StrongSetSchema, WrappedPromiseLikeSchema, } from './schema.js';
-export function keyBy(collection, key) {
-    const result = {};
-    for (const item of collection) {
-        const keyValue = item[key];
-        if (typeof keyValue === 'string' ||
-            typeof keyValue === 'number' ||
-            typeof keyValue === 'symbol') {
-            result[String(keyValue)] = item;
+export * from './value-to-schema.js';
+/**
+ * _Recursively_ searches within an object, array, or any nested structure to
+ * find whether a specific key exists.
+ *
+ * Handles circular references by tracking visited objects to prevent infinite
+ * recursion.
+ *
+ * @example
+ *
+ * ```ts
+ * const obj = { a: 1, b: { c: 2, d: [{ e: 3 }] } };
+ *
+ * hasKey(obj, 'c'); // true
+ * hasKey(obj, 'e'); // true
+ * hasKey(obj, 'x'); // false (key not found)
+ * ```
+ *
+ * @param obj The object, array, or value to search within
+ * @param key The key to search for
+ * @param visited Internal set for circular reference detection
+ * @returns True if the key is found anywhere in the structure, false otherwise
+ */
+export function hasKey(obj, key, visited = new WeakSet()) {
+    // Handle primitives that can't contain keys
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    // Prevent infinite recursion with circular references
+    if (visited.has(obj)) {
+        return false;
+    }
+    visited.add(obj);
+    try {
+        // Check if this object has the key
+        if (Object.hasOwn(obj, key)) {
+            return true;
+        }
+        // Recursively search in object/array values
+        if (Array.isArray(obj)) {
+            // For arrays, search in each element
+            for (const item of obj) {
+                if (hasKey(item, key, visited)) {
+                    return true;
+                }
+            }
+        }
+        else {
+            // For objects, search in each property value
+            for (const propValue of Object.values(obj)) {
+                if (hasKey(propValue, key, visited)) {
+                    return true;
+                }
+            }
         }
+        return false;
+    }
+    finally {
+        visited.delete(obj);
     }
-    return result;
 }
 /**
- * Recursively converts an arbitrary value to a Zod v4 schema that would
- * validate values with the same structure.
+ * _Recursively_ searches within an object, array, or any nested structure to
+ * find whether a specific value exists.
  *
- * This function analyzes the runtime value and generates a corresponding Zod
- * schema that captures the value's structure and type information. It handles
- * primitives, objects, arrays, functions, and various built-in types, with
- * support for circular reference detection.
+ * Uses strict equality (===) to compare values, with special handling for empty
+ * objects. Handles circular references by tracking visited objects to prevent
+ * infinite recursion.
  *
  * @example
  *
- * ```typescript
- * // Primitive types
- * valueToSchema('hello'); // z.string()
- * valueToSchema(42); // z.number()
- * valueToSchema(true); // z.boolean()
- *
- * // Objects
- * valueToSchema({ name: 'John', age: 30 });
- * // z.object({ name: z.string(), age: z.number() })
- *
- * // Arrays
- * valueToSchema(['a', 'b', 'c']); // z.array(z.string())
- * valueToSchema([1, 'mixed']); // z.array(z.union([z.number(), z.string()]))
+ * ```ts
+ * const obj = { a: 1, b: { c: 2, d: [{ e: 3 }] }, empty: {} };
  *
- * // Nested structures
- * valueToSchema({ users: [{ name: 'John' }] });
- * // z.object({ users: z.array(z.object({ name: z.string() })) })
+ * hasValue(obj, 2); // true (found in obj.b.c)
+ * hasValue(obj, 3); // true (found in obj.b.d[0].e)
+ * hasValue(obj, {}); // true (found in obj.empty, matches empty objects)
+ * hasValue(obj, '1'); // false (strict equality, 1 !== '1')
+ * hasValue(obj, 999); // false (value not found)
  * ```
  *
- * @param value - The value to convert to a schema
- * @param options - Configuration options for schema generation
- * @param visited - Internal WeakSet for circular reference detection
- * @returns A Zod schema that validates values matching the input's structure
+ * @param obj The object, array, or value to search within
+ * @param value The value to search for (using strict equality, with special
+ *   empty object handling)
+ * @param visited Internal set for circular reference detection
+ * @returns True if the value is found anywhere in the structure, false
+ *   otherwise
  */
-export const valueToSchema = (value, options = {}, visited = new WeakSet()) => {
-    const { _currentDepth = 0, allowMixedArrays = true, literalPrimitives = false, literalRegExp = false, maxDepth = 10, strict = false, } = options;
-    // Prevent infinite recursion
-    if (_currentDepth >= maxDepth) {
-        return z.unknown();
+export function hasValue(obj, value, visited = new WeakSet()) {
+    // Direct value comparison
+    if (obj === value) {
+        return true;
     }
-    // Handle primitives
-    if (value === null) {
-        return z.null();
-    }
-    if (value === undefined) {
-        return z.undefined();
-    }
-    if (Number.isNaN(value)) {
-        return z.nan();
+    // Special case: Check for empty objects
+    if (typeof obj === 'object' &&
+        obj !== null &&
+        !Array.isArray(obj) &&
+        typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value)) {
+        const objKeys = Object.keys(obj);
+        const valueKeys = Object.keys(value);
+        // Both are empty objects
+        if (objKeys.length === 0 && valueKeys.length === 0) {
+            return true;
+        }
     }
-    if (value === Infinity || value === -Infinity) {
-        return z.literal(value);
+    // Handle primitives that can't contain nested values
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
     }
-    const valueType = typeof value;
-    switch (valueType) {
-        case 'bigint':
-            return literalPrimitives ? z.literal(value) : z.bigint();
-        case 'boolean':
-            return literalPrimitives ? z.literal(value) : z.boolean();
-        case 'function':
-            return FunctionSchema;
-        case 'number':
-            return literalPrimitives ? z.literal(value) : z.number();
-        case 'string':
-            return literalPrimitives ? z.literal(value) : z.string();
-        case 'symbol':
-            return z.symbol();
+    // Prevent infinite recursion with circular references
+    if (visited.has(obj)) {
+        return false;
     }
-    // Handle objects
-    if (typeof value === 'object' && value !== null) {
-        // Check for circular references
-        if (visited.has(value)) {
-            // Return a recursive schema reference or unknown for circular refs
-            return z.unknown();
-        }
-        visited.add(value);
-        try {
-            // Handle built-in object types
-            if (value instanceof Date) {
-                return z.date();
-            }
-            if (value instanceof RegExp) {
-                if (literalRegExp) {
-                    return RegExpSchema;
-                }
-                return z.coerce.string().regex(value);
-            }
-            if (value instanceof Map) {
-                return StrongMapSchema;
-            }
-            if (value instanceof Set) {
-                return StrongSetSchema;
-            }
-            if (value instanceof WeakMap) {
-                return z.instanceof(WeakMap);
-            }
-            if (value instanceof WeakSet) {
-                return z.instanceof(WeakSet);
-            }
-            if (value instanceof Error) {
-                return z.instanceof(Error);
-            }
-            if (isPromiseLike(value)) {
-                return WrappedPromiseLikeSchema;
-            }
-            // Handle arrays
-            if (Array.isArray(value)) {
-                if (value.length === 0) {
-                    return z.array(z.unknown());
-                }
-                const elementSchemas = value.map((item) => valueToSchema(item, {
-                    ...options,
-                    _currentDepth: _currentDepth + 1,
-                }, visited));
-                if (allowMixedArrays) {
-                    // Create a union of all unique element types
-                    const uniqueSchemas = Array.from(new Set(elementSchemas.map((schema) => schema.constructor.name))).map((_, index) => elementSchemas[index]);
-                    if (uniqueSchemas.length === 1) {
-                        return z.array(uniqueSchemas[0]);
-                    }
-                    else {
-                        return z.array(z.union(uniqueSchemas));
-                    }
-                }
-                else {
-                    // Use the first element's schema for all elements
-                    return z.array(elementSchemas[0]);
+    visited.add(obj);
+    try {
+        // Recursively search in object/array values
+        if (Array.isArray(obj)) {
+            // For arrays, search in each element
+            for (const item of obj) {
+                if (hasValue(item, value, visited)) {
+                    return true;
                 }
             }
-            // Handle plain objects
-            if (isNonNullObject(value)) {
-                const schemaShape = {};
-                for (const [key, val] of Object.entries(value)) {
-                    if (isString(key)) {
-                        schemaShape[key] = valueToSchema(val, {
-                            ...options,
-                            _currentDepth: _currentDepth + 1,
-                        }, visited);
-                    }
+        }
+        else {
+            // For objects, search in each property value
+            for (const propValue of Object.values(obj)) {
+                if (hasValue(propValue, value, visited)) {
+                    return true;
                 }
-                return strict
-                    ? z.strictObject(schemaShape)
-                    : z.looseObject(schemaShape);
             }
-            // Handle other object types (ArrayBuffer, etc.)
-            return z.custom((val) => typeof val === 'object' && val !== null, { message: 'Expected an object' });
         }
-        finally {
-            visited.delete(value);
+        return false;
+    }
+    finally {
+        visited.delete(obj);
+    }
+}
+/**
+ * _Recursively_ searches for a key-value pair within an object or array.
+ *
+ * Uses strict equality (===) to compare values. Handles circular references by
+ * tracking visited objects to prevent infinite recursion.
+ *
+ * @example
+ *
+ * ```ts
+ * const obj = { a: 1, b: { c: 2, d: [{ e: 3 }] } };
+ *
+ * hasKeyValue(obj, 'c', 2); // true
+ * hasKeyValue(obj, 'e', 3); // true
+ * hasKeyValue(obj, 'a', '1'); // false (strict equality)
+ * hasKeyValue(obj, 'x', 1); // false (key not found)
+ * /**
+ * Maps an array of objects to an object keyed by the specified key.
+ *
+ * @param collection Array of objects
+ * @param key Name of key
+ * @returns Object mapping key values to objects
+ * ```
+ */
+export function keyBy(collection, key) {
+    const result = {};
+    for (const item of collection) {
+        const keyValue = item[key];
+        if (typeof keyValue === 'string' ||
+            typeof keyValue === 'number' ||
+            typeof keyValue === 'symbol') {
+            result[String(keyValue)] = item;
         }
     }
-    // Fallback for unknown types
-    return z.unknown();
-};
+    return result;
+}
 //# sourceMappingURL=util.js.map

package/dist/esm/util.js.map

@@ -1 +1 @@
-{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"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"}

package/dist/esm/value-to-schema.d.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod/v4';
+/**
+ * Recursively converts an arbitrary value to a Zod v4 schema that would
+ * validate values with the same structure.
+ *
+ * This function analyzes the runtime value and generates a corresponding Zod
+ * schema that captures the value's structure and type information. It handles
+ * primitives, objects, arrays, functions, and various built-in types, with
+ * support for circular reference detection.
+ *
+ * @example
+ *
+ * ```typescript
+ * // Primitive types
+ * valueToSchema('hello'); // z.string()
+ * valueToSchema(42); // z.number()
+ * valueToSchema(true); // z.boolean()
+ *
+ * // Objects
+ * valueToSchema({ name: 'John', age: 30 });
+ * // z.object({ name: z.string(), age: z.number() })
+ *
+ * // Arrays
+ * valueToSchema(['a', 'b', 'c']); // z.array(z.string())
+ * valueToSchema([1, 'mixed']); // z.array(z.union([z.number(), z.string()]))
+ *
+ * // Nested structures
+ * valueToSchema({ users: [{ name: 'John' }] });
+ * // z.object({ users: z.array(z.object({ name: z.string() })) })
+ * ```
+ *
+ * @param value - The value to convert to a schema
+ * @param options - Configuration options for schema generation
+ * @param visited - Internal WeakSet for circular reference detection
+ * @returns A Zod schema that validates values matching the input's structure.
+ *   This value is unfortunately untyped due to the complexity involved. But the
+ *   schema works!
+ */
+export declare const valueToSchema: (value: unknown, options?: ValueToSchemaOptions, visited?: WeakSet<object>) => z.ZodType<any>;
+/**
+ * Options for {@link valueToSchema}
+ */
+export interface ValueToSchemaOptions {
+    /**
+     * If `true`, treat empty objects `{}` as literal empty objects that only
+     * match objects with zero own properties
+     *
+     * @defaultValue false
+     */
+    literalEmptyObjects?: boolean;
+    /**
+     * If `true`, use literal schema for primitive values instead of type schema
+     *
+     * @defaultValue false
+     */
+    literalPrimitives?: boolean;
+    /**
+     * If `true`, treat `RegExp` literals as `RegExp` literals; otherwise treat as
+     * strings and attempt match
+     *
+     * @defaultValue false
+     */
+    literalRegExp?: boolean;
+    /**
+     * If `true`, treat arrays as tuples wherever possible.
+     *
+     * Implies `false` for {@link noMixedArrays}.
+     *
+     * @defaultValue false
+     */
+    literalTuples?: boolean;
+    /**
+     * Maximum nesting depth to prevent stack overflow
+     *
+     * @defaultValue 10
+     */
+    maxDepth?: number;
+    /**
+     * Whether to allow mixed types in arrays
+     *
+     * If {@link literalTuples} is `true`, this option is ignored and treated as
+     * `false`.
+     *
+     * @defaultValue false
+     */
+    noMixedArrays?: boolean;
+    /**
+     * If `true`, will disallow unknown properties in parsed objects
+     *
+     * @defaultValue false
+     */
+    strict?: boolean;
+}
+/**
+ * Predefined options for {@link valueToSchema} optimized for object satisfaction
+ * checks.
+ *
+ * Uses literal primitives and tuples for exact matching while allowing extra
+ * properties.
+ */
+export declare const valueToSchemaOptionsForSatisfies: Readonly<{
+    readonly literalEmptyObjects: true;
+    readonly literalPrimitives: true;
+    readonly literalRegExp: false;
+    readonly literalTuples: true;
+    readonly strict: false;
+}>;
+/**
+ * Predefined options for {@link valueToSchema} optimized for deep equality
+ * checks.
+ *
+ * Uses literal primitives, regexp, and tuples with strict validation for exact
+ * matching.
+ */
+export declare const valueToSchemaOptionsForDeepEqual: Readonly<{
+    readonly literalEmptyObjects: true;
+    readonly literalPrimitives: true;
+    readonly literalRegExp: true;
+    readonly literalTuples: true;
+    readonly strict: true;
+}>;
+//# sourceMappingURL=value-to-schema.d.ts.map

package/dist/esm/value-to-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-to-schema.d.ts","sourceRoot":"","sources":["../../src/value-to-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAiB3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,eAAO,MAAM,aAAa,GACxB,OAAO,OAAO,EACd,UAAS,oBAAyB,EAClC,yBAA+B,KAC9B,CAAC,CAAC,OAAO,CAAC,GAAG,CA2Uf,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,oBAAoB;IAQnC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAE9B;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC;;;;;;EAMH,CAAC;AAE3C;;;;;;GAMG;AACH,eAAO,MAAM,gCAAgC;;;;;;EAMH,CAAC"}