@sinclair/typebox 0.24.38 → 0.24.41

package/compiler/compiler.js

@@ -151,6 +151,9 @@ var TypeCompiler;
             yield `(${value} === '${schema.const}')`;
         }
     }
+    function* Never(schema, value) {
+        yield `(false)`;
+    }
     function* Null(schema, value) {
         yield `(${value} === null)`;
     }
@@ -299,6 +302,8 @@ var TypeCompiler;
                 return yield* Integer(anySchema, value);
             case 'Literal':
                 return yield* Literal(anySchema, value);
+            case 'Never':
+                return yield* Never(anySchema, value);
             case 'Null':
                 return yield* Null(anySchema, value);
             case 'Number':

package/errors/errors.d.ts

@@ -13,34 +13,35 @@ export declare enum ValueErrorType {
     IntegerMinimum = 10,
     IntegerMaximum = 11,
     Literal = 12,
-    Null = 13,
-    Number = 14,
-    NumberMultipleOf = 15,
-    NumberExclusiveMinimum = 16,
-    NumberExclusiveMaximum = 17,
-    NumberMinumum = 18,
-    NumberMaximum = 19,
-    Object = 20,
-    ObjectMinProperties = 21,
-    ObjectMaxProperties = 22,
-    ObjectAdditionalProperties = 23,
-    Promise = 24,
-    RecordKeyNumeric = 25,
-    RecordKeyString = 26,
-    String = 27,
-    StringMinLength = 28,
-    StringMaxLength = 29,
-    StringPattern = 30,
-    StringFormatUnknown = 31,
-    StringFormat = 32,
-    TupleZeroLength = 33,
-    TupleLength = 34,
-    Undefined = 35,
-    Union = 36,
-    Uint8Array = 37,
-    Uint8ArrayMinByteLength = 38,
-    Uint8ArrayMaxByteLength = 39,
-    Void = 40
+    Never = 13,
+    Null = 14,
+    Number = 15,
+    NumberMultipleOf = 16,
+    NumberExclusiveMinimum = 17,
+    NumberExclusiveMaximum = 18,
+    NumberMinumum = 19,
+    NumberMaximum = 20,
+    Object = 21,
+    ObjectMinProperties = 22,
+    ObjectMaxProperties = 23,
+    ObjectAdditionalProperties = 24,
+    Promise = 25,
+    RecordKeyNumeric = 26,
+    RecordKeyString = 27,
+    String = 28,
+    StringMinLength = 29,
+    StringMaxLength = 30,
+    StringPattern = 31,
+    StringFormatUnknown = 32,
+    StringFormat = 33,
+    TupleZeroLength = 34,
+    TupleLength = 35,
+    Undefined = 36,
+    Union = 37,
+    Uint8Array = 38,
+    Uint8ArrayMinByteLength = 39,
+    Uint8ArrayMaxByteLength = 40,
+    Void = 41
 }
 export interface ValueError {
     type: ValueErrorType;

package/errors/errors.js

@@ -48,34 +48,35 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["IntegerMinimum"] = 10] = "IntegerMinimum";
     ValueErrorType[ValueErrorType["IntegerMaximum"] = 11] = "IntegerMaximum";
     ValueErrorType[ValueErrorType["Literal"] = 12] = "Literal";
-    ValueErrorType[ValueErrorType["Null"] = 13] = "Null";
-    ValueErrorType[ValueErrorType["Number"] = 14] = "Number";
-    ValueErrorType[ValueErrorType["NumberMultipleOf"] = 15] = "NumberMultipleOf";
-    ValueErrorType[ValueErrorType["NumberExclusiveMinimum"] = 16] = "NumberExclusiveMinimum";
-    ValueErrorType[ValueErrorType["NumberExclusiveMaximum"] = 17] = "NumberExclusiveMaximum";
-    ValueErrorType[ValueErrorType["NumberMinumum"] = 18] = "NumberMinumum";
-    ValueErrorType[ValueErrorType["NumberMaximum"] = 19] = "NumberMaximum";
-    ValueErrorType[ValueErrorType["Object"] = 20] = "Object";
-    ValueErrorType[ValueErrorType["ObjectMinProperties"] = 21] = "ObjectMinProperties";
-    ValueErrorType[ValueErrorType["ObjectMaxProperties"] = 22] = "ObjectMaxProperties";
-    ValueErrorType[ValueErrorType["ObjectAdditionalProperties"] = 23] = "ObjectAdditionalProperties";
-    ValueErrorType[ValueErrorType["Promise"] = 24] = "Promise";
-    ValueErrorType[ValueErrorType["RecordKeyNumeric"] = 25] = "RecordKeyNumeric";
-    ValueErrorType[ValueErrorType["RecordKeyString"] = 26] = "RecordKeyString";
-    ValueErrorType[ValueErrorType["String"] = 27] = "String";
-    ValueErrorType[ValueErrorType["StringMinLength"] = 28] = "StringMinLength";
-    ValueErrorType[ValueErrorType["StringMaxLength"] = 29] = "StringMaxLength";
-    ValueErrorType[ValueErrorType["StringPattern"] = 30] = "StringPattern";
-    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 31] = "StringFormatUnknown";
-    ValueErrorType[ValueErrorType["StringFormat"] = 32] = "StringFormat";
-    ValueErrorType[ValueErrorType["TupleZeroLength"] = 33] = "TupleZeroLength";
-    ValueErrorType[ValueErrorType["TupleLength"] = 34] = "TupleLength";
-    ValueErrorType[ValueErrorType["Undefined"] = 35] = "Undefined";
-    ValueErrorType[ValueErrorType["Union"] = 36] = "Union";
-    ValueErrorType[ValueErrorType["Uint8Array"] = 37] = "Uint8Array";
-    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 38] = "Uint8ArrayMinByteLength";
-    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 39] = "Uint8ArrayMaxByteLength";
-    ValueErrorType[ValueErrorType["Void"] = 40] = "Void";
+    ValueErrorType[ValueErrorType["Never"] = 13] = "Never";
+    ValueErrorType[ValueErrorType["Null"] = 14] = "Null";
+    ValueErrorType[ValueErrorType["Number"] = 15] = "Number";
+    ValueErrorType[ValueErrorType["NumberMultipleOf"] = 16] = "NumberMultipleOf";
+    ValueErrorType[ValueErrorType["NumberExclusiveMinimum"] = 17] = "NumberExclusiveMinimum";
+    ValueErrorType[ValueErrorType["NumberExclusiveMaximum"] = 18] = "NumberExclusiveMaximum";
+    ValueErrorType[ValueErrorType["NumberMinumum"] = 19] = "NumberMinumum";
+    ValueErrorType[ValueErrorType["NumberMaximum"] = 20] = "NumberMaximum";
+    ValueErrorType[ValueErrorType["Object"] = 21] = "Object";
+    ValueErrorType[ValueErrorType["ObjectMinProperties"] = 22] = "ObjectMinProperties";
+    ValueErrorType[ValueErrorType["ObjectMaxProperties"] = 23] = "ObjectMaxProperties";
+    ValueErrorType[ValueErrorType["ObjectAdditionalProperties"] = 24] = "ObjectAdditionalProperties";
+    ValueErrorType[ValueErrorType["Promise"] = 25] = "Promise";
+    ValueErrorType[ValueErrorType["RecordKeyNumeric"] = 26] = "RecordKeyNumeric";
+    ValueErrorType[ValueErrorType["RecordKeyString"] = 27] = "RecordKeyString";
+    ValueErrorType[ValueErrorType["String"] = 28] = "String";
+    ValueErrorType[ValueErrorType["StringMinLength"] = 29] = "StringMinLength";
+    ValueErrorType[ValueErrorType["StringMaxLength"] = 30] = "StringMaxLength";
+    ValueErrorType[ValueErrorType["StringPattern"] = 31] = "StringPattern";
+    ValueErrorType[ValueErrorType["StringFormatUnknown"] = 32] = "StringFormatUnknown";
+    ValueErrorType[ValueErrorType["StringFormat"] = 33] = "StringFormat";
+    ValueErrorType[ValueErrorType["TupleZeroLength"] = 34] = "TupleZeroLength";
+    ValueErrorType[ValueErrorType["TupleLength"] = 35] = "TupleLength";
+    ValueErrorType[ValueErrorType["Undefined"] = 36] = "Undefined";
+    ValueErrorType[ValueErrorType["Union"] = 37] = "Union";
+    ValueErrorType[ValueErrorType["Uint8Array"] = 38] = "Uint8Array";
+    ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 39] = "Uint8ArrayMinByteLength";
+    ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 40] = "Uint8ArrayMaxByteLength";
+    ValueErrorType[ValueErrorType["Void"] = 41] = "Void";
 })(ValueErrorType = exports.ValueErrorType || (exports.ValueErrorType = {}));
 // -------------------------------------------------------------------
 // ValueErrors
@@ -149,6 +150,9 @@ var ValueErrors;
             return yield { type: ValueErrorType.Literal, schema, path, value, message: `Expected ${error}` };
         }
     }
+    function* Never(schema, references, path, value) {
+        yield { type: ValueErrorType.Never, schema, path, value, message: `Value cannot be validated` };
+    }
     function* Null(schema, references, path, value) {
         if (!(value === null)) {
             return yield { type: ValueErrorType.Null, schema, path, value, message: `Expected null` };
@@ -337,6 +341,8 @@ var ValueErrors;
                 return yield* Integer(anySchema, anyReferences, path, value);
             case 'Literal':
                 return yield* Literal(anySchema, anyReferences, path, value);
+            case 'Never':
+                return yield* Never(anySchema, anyReferences, path, value);
             case 'Null':
                 return yield* Null(anySchema, anyReferences, path, value);
             case 'Number':

package/guard/guard.d.ts

@@ -19,6 +19,8 @@ export declare namespace TypeGuard {
     function TInteger(schema: unknown): schema is Types.TInteger;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema: unknown): schema is Types.TLiteral;
+    /** Returns true if the given schema is TNever */
+    function TNever(schema: unknown): schema is Types.TNever;
     /** Returns true if the given schema is TNull */
     function TNull(schema: unknown): schema is Types.TNull;
     /** Returns true if the given schema is TNumber */

package/guard/guard.js

@@ -153,6 +153,22 @@ var TypeGuard;
         return IsObject(schema) && schema[Types.Kind] === 'Literal' && IsOptionalString(schema.$id) && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const));
     }
     TypeGuard.TLiteral = TLiteral;
+    /** Returns true if the given schema is TNever */
+    function TNever(schema) {
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Never' &&
+            IsArray(schema.allOf) &&
+            schema.allOf.length === 2 &&
+            IsObject(schema.allOf[0]) &&
+            IsString(schema.allOf[0].type) &&
+            schema.allOf[0].type === 'number' &&
+            schema.allOf[0].const === 0 &&
+            IsObject(schema.allOf[1]) &&
+            IsString(schema.allOf[1].type) &&
+            schema.allOf[1].type === 'number' &&
+            schema.allOf[1].const === 1);
+    }
+    TypeGuard.TNever = TNever;
     /** Returns true if the given schema is TNull */
     function TNull(schema) {
         return IsObject(schema) && schema[Types.Kind] === 'Null' && schema.type === 'null' && IsOptionalString(schema.$id);
@@ -302,6 +318,7 @@ var TypeGuard;
             TFunction(schema) ||
             TInteger(schema) ||
             TLiteral(schema) ||
+            TNever(schema) ||
             TNull(schema) ||
             TNumber(schema) ||
             TObject(schema) ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.38",
+  "version": "0.24.41",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -302,6 +302,17 @@ The following table lists the standard TypeBox types.
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Never()         │ type T = never              │ const T = {                    │
+│                                │                             │   allOf: [{                    │
+│                                │                             │     type: 'number'             │
+│                                │                             │     const: 0                   │
+│                                │                             │   }, {                         │
+│                                │                             │     type: 'number'             │
+│                                │                             │     const: 1                   │
+│                                │                             │   }]                           │
+│                                │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Record(         │ type T = Record<            │ const T = {                    │
 │   Type.String(),               │   string,                   │   type: 'object',              │
 │   Type.Number()                │   number,                   │   patternProperties: {         │
@@ -428,7 +439,7 @@ const T = Type.Array(Type.Integer(), { minItems: 5 })
 
 ### Extended
 
-In addition to JSON schema types, TypeBox provides several extended types that allow for `function` and `constructor` types to be composed. These additional types are not valid JSON Schema and will not validate using typical JSON Schema validation. However, these types can be used to frame JSON schema and describe callable interfaces that may receive JSON validated data. These types are as follows.
+In addition to JSON schema types, TypeBox provides several extended types that allow for the composition of `function` and `constructor` types. These additional types are not valid JSON Schema and will not validate using typical JSON Schema validation. However, these types can be used to frame JSON schema and describe callable interfaces that may receive JSON validated data. These types are as follows.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐

package/typebox.d.ts

@@ -116,15 +116,26 @@ export declare type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? []
 export declare type UnionStringLiteralToTuple<T> = T extends TUnion<infer L> ? {
     [I in keyof L]: L[I] extends TLiteral<infer C> ? C : never;
 } : never;
-export declare type TKeyOf<T extends TObject> = {
+export declare type UnionLiteralsFromObject<T extends TObject> = {
     [K in ObjectPropertyKeys<T>]: TLiteral<K>;
 } extends infer R ? UnionToTuple<R[keyof R]> : never;
+export interface TKeyOf<T extends TObject> extends TUnion<UnionLiteralsFromObject<T>> {
+}
 export declare type TLiteralValue = string | number | boolean;
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
     [Kind]: 'Literal';
     static: T;
     const: T;
 }
+export interface TNever extends TSchema {
+    [Kind]: 'Never';
+    static: never;
+    allOf: [{
+        const: 0;
+    }, {
+        const: 1;
+    }];
+}
 export interface TNull extends TSchema {
     [Kind]: 'Null';
     static: null;
@@ -320,9 +331,11 @@ export declare class TypeBuilder {
     /** Creates a intersect type. */
     Intersect<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TIntersect<T>;
     /** Creates a keyof type */
-    KeyOf<T extends TObject>(object: T, options?: SchemaOptions): TUnion<TKeyOf<T>>;
+    KeyOf<T extends TObject>(object: T, options?: SchemaOptions): TKeyOf<T>;
     /** Creates a literal type. */
     Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
+    /** Creates a never type */
+    Never(options?: SchemaOptions): TNever;
     /** Creates a null type */
     Null(options?: SchemaOptions): TNull;
     /** Creates a number type */
@@ -366,6 +379,7 @@ export declare class TypeBuilder {
     /** Creates a undefined type */
     Undefined(options?: SchemaOptions): TUndefined;
     /** Creates a union type */
+    Union(items: [], options?: SchemaOptions): TNever;
     Union<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TUnion<T>;
     /** Creates a Uint8Array type */
     Uint8Array(options?: Uint8ArrayOptions): TUint8Array;

package/typebox.js

@@ -153,6 +153,17 @@ class TypeBuilder {
     Literal(value, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Literal', const: value, type: typeof value });
     }
+    /** Creates a never type */
+    Never(options = {}) {
+        return this.Create({
+            ...options,
+            [exports.Kind]: 'Never',
+            allOf: [
+                { type: 'number', const: 0 },
+                { type: 'number', const: 1 },
+            ],
+        });
+    }
     /** Creates a null type */
     Null(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Null', type: 'null' });
@@ -315,9 +326,8 @@ class TypeBuilder {
     Undefined(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Undefined', type: 'object', specialized: 'Undefined' });
     }
-    /** Creates a union type */
     Union(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: items });
+        return items.length === 0 ? exports.Type.Never({ ...options }) : this.Create({ ...options, [exports.Kind]: 'Union', anyOf: items });
     }
     /** Creates a Uint8Array type */
     Uint8Array(options = {}) {

package/value/cast.d.ts

@@ -1,4 +1,21 @@
 import * as Types from '../typebox';
+export declare class ValueCastReferenceTypeError extends Error {
+    readonly schema: Types.TRef | Types.TSelf;
+    constructor(schema: Types.TRef | Types.TSelf);
+}
+export declare class ValueCastArrayUniqueItemsTypeError extends Error {
+    readonly schema: Types.TSchema;
+    readonly value: unknown;
+    constructor(schema: Types.TSchema, value: unknown);
+}
+export declare class ValueCastNeverTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueCastRecursiveTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare class ValueCastUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);

package/value/cast.js

@@ -27,50 +27,84 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCast = exports.ValueCastUnknownTypeError = void 0;
+exports.ValueCast = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = exports.ValueCastReferenceTypeError = void 0;
 const Types = require("../typebox");
 const create_1 = require("./create");
 const check_1 = require("./check");
-// --------------------------------------------------------------------------
-// Specialized Union Cast. Because a union can be one of many varying types
-// with properties potentially overlapping, we need a strategy to determine
-// which of those types we should cast into. This strategy needs to factor
-// the value provided by the user to make this decision.
-//
-// The following will score each union type found within the types anyOf
-// array. Typically this is executed for objects only, so the score is a
-// essentially a tally of how many properties are valid. The reasoning
-// here is the discriminator field would tip the scales in favor of that
-// union if other properties overlap and match.
-// --------------------------------------------------------------------------
+const clone_1 = require("./clone");
 var UnionValueCast;
 (function (UnionValueCast) {
+    // ----------------------------------------------------------------------------------------------
+    // The following will score a schema against a value. For objects, the score is the tally of
+    // points awarded for each property of the value. Property points are (1.0 / propertyCount)
+    // to prevent large property counts biasing results. Properties that match literal values are
+    // maximally awarded as literals are typically used as union discriminator fields.
+    // ----------------------------------------------------------------------------------------------
     function Score(schema, references, value) {
-        let score = 0;
         if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
-            const objectSchema = schema;
-            const entries = globalThis.Object.entries(objectSchema.properties);
-            score += entries.reduce((acc, [key, schema]) => acc + (check_1.ValueCheck.Check(schema, references, value[key]) ? 1 : 0), 0);
+            const object = schema;
+            const keys = Object.keys(value);
+            const entries = globalThis.Object.entries(object.properties);
+            const [point, max] = [1 / entries.length, entries.length];
+            return entries.reduce((acc, [key, schema]) => {
+                const literal = schema[Types.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
+                const checks = check_1.ValueCheck.Check(schema, references, value[key]) ? point : 0;
+                const exists = keys.includes(key) ? point : 0;
+                return acc + (literal + checks + exists);
+            }, 0);
+        }
+        else {
+            return check_1.ValueCheck.Check(schema, references, value) ? 1 : 0;
         }
-        return score;
     }
-    function Select(schema, references, value) {
-        let select = schema.anyOf[0];
-        let best = 0;
-        for (const subschema of schema.anyOf) {
-            const score = Score(subschema, references, value);
+    function Select(union, references, value) {
+        let [select, best] = [union.anyOf[0], 0];
+        for (const schema of union.anyOf) {
+            const score = Score(schema, references, value);
             if (score > best) {
-                select = subschema;
+                select = schema;
                 best = score;
             }
         }
         return select;
     }
-    function Create(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : ValueCast.Cast(Select(schema, references, value), references, value);
+    function Create(union, references, value) {
+        return check_1.ValueCheck.Check(union, references, value) ? clone_1.ValueClone.Clone(value) : ValueCast.Cast(Select(union, references, value), references, value);
     }
     UnionValueCast.Create = Create;
 })(UnionValueCast || (UnionValueCast = {}));
+// -----------------------------------------------------------
+// Errors
+// -----------------------------------------------------------
+class ValueCastReferenceTypeError extends Error {
+    constructor(schema) {
+        super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.ValueCastReferenceTypeError = ValueCastReferenceTypeError;
+class ValueCastArrayUniqueItemsTypeError extends Error {
+    constructor(schema, value) {
+        super('ValueCast: Array cast produced invalid data due to uniqueItems constraint');
+        this.schema = schema;
+        this.value = value;
+    }
+}
+exports.ValueCastArrayUniqueItemsTypeError = ValueCastArrayUniqueItemsTypeError;
+class ValueCastNeverTypeError extends Error {
+    constructor(schema) {
+        super('ValueCast: Never types cannot be cast');
+        this.schema = schema;
+    }
+}
+exports.ValueCastNeverTypeError = ValueCastNeverTypeError;
+class ValueCastRecursiveTypeError extends Error {
+    constructor(schema) {
+        super('ValueCast.Recursive: Cannot cast recursive schemas');
+        this.schema = schema;
+    }
+}
+exports.ValueCastRecursiveTypeError = ValueCastRecursiveTypeError;
 class ValueCastUnknownTypeError extends Error {
     constructor(schema) {
         super('ValueCast: Unknown type');
@@ -81,8 +115,11 @@ exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
 var ValueCast;
 (function (ValueCast) {
     // -----------------------------------------------------------
-    // Convert
+    // Guards
     // -----------------------------------------------------------
+    function IsArray(value) {
+        return typeof value === 'object' && globalThis.Array.isArray(value);
+    }
     function IsString(value) {
         return typeof value === 'string';
     }
@@ -107,6 +144,9 @@ var ValueCast;
     function IsValueFalse(value) {
         return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === 0n) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'));
     }
+    // -----------------------------------------------------------
+    // Convert
+    // -----------------------------------------------------------
     function TryConvertString(value) {
         return IsValueToString(value) ? value.toString() : value;
     }
@@ -127,10 +167,17 @@ var ValueCast;
     }
     function Array(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
-            return value;
-        if (!globalThis.Array.isArray(value))
-            return create_1.ValueCreate.Create(schema, references);
-        return value.map((val) => Visit(schema.items, references, val));
+            return clone_1.ValueClone.Clone(value);
+        const created = IsArray(value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
+        const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...globalThis.Array.from({ length: schema.minItems - created.length }, () => null)] : created;
+        const maximum = IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
+        const casted = maximum.map((value) => Visit(schema.items, references, value));
+        if (schema.uniqueItems !== true)
+            return casted;
+        const unique = [...new Set(casted)];
+        if (!check_1.ValueCheck.Check(schema, references, unique))
+            throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
+        return unique;
     }
     function Boolean(schema, references, value) {
         const conversion = TryConvertBoolean(value);
@@ -161,6 +208,9 @@ var ValueCast;
     function Literal(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
+    function Never(schema, references, value) {
+        throw new ValueCastNeverTypeError(schema);
+    }
     function Null(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
@@ -170,7 +220,7 @@ var ValueCast;
     }
     function Object(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
-            return value;
+            return clone_1.ValueClone.Clone(value);
         if (value === null || typeof value !== 'object')
             return create_1.ValueCreate.Create(schema, references);
         const required = new Set(schema.required || []);
@@ -187,7 +237,7 @@ var ValueCast;
     }
     function Record(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
-            return value;
+            return clone_1.ValueClone.Clone(value);
         if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value))
             return create_1.ValueCreate.Create(schema, references);
         const subschemaKey = globalThis.Object.keys(schema.patternProperties)[0];
@@ -199,18 +249,18 @@ var ValueCast;
         return result;
     }
     function Recursive(schema, references, value) {
-        throw new Error('ValueCast.Recursive: Cannot cast recursive schemas');
+        throw new ValueCastRecursiveTypeError(schema);
     }
     function Ref(schema, references, value) {
         const reference = references.find((reference) => reference.$id === schema.$ref);
         if (reference === undefined)
-            throw new Error(`ValueCast.Ref: Cannot find schema with $id '${schema.$ref}'.`);
+            throw new ValueCastReferenceTypeError(schema);
         return Visit(reference, references, value);
     }
     function Self(schema, references, value) {
         const reference = references.find((reference) => reference.$id === schema.$ref);
         if (reference === undefined)
-            throw new Error(`ValueCast.Self: Cannot find schema with $id '${schema.$ref}'.`);
+            throw new ValueCastReferenceTypeError(schema);
         return Visit(reference, references, value);
     }
     function String(schema, references, value) {
@@ -219,7 +269,7 @@ var ValueCast;
     }
     function Tuple(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
-            return value;
+            return clone_1.ValueClone.Clone(value);
         if (!globalThis.Array.isArray(value))
             return create_1.ValueCreate.Create(schema, references);
         if (schema.items === undefined)
@@ -261,6 +311,8 @@ var ValueCast;
                 return Integer(anySchema, anyReferences, value);
             case 'Literal':
                 return Literal(anySchema, anyReferences, value);
+            case 'Never':
+                return Never(anySchema, anyReferences, value);
             case 'Null':
                 return Null(anySchema, anyReferences, value);
             case 'Number':

package/value/check.js

@@ -93,6 +93,9 @@ var ValueCheck;
     function Literal(schema, references, value) {
         return value === schema.const;
     }
+    function Never(schema, references, value) {
+        return false;
+    }
     function Null(schema, references, value) {
         return value === null;
     }
@@ -275,6 +278,8 @@ var ValueCheck;
                 return Integer(anySchema, anyReferences, value);
             case 'Literal':
                 return Literal(anySchema, anyReferences, value);
+            case 'Never':
+                return Never(anySchema, anyReferences, value);
             case 'Null':
                 return Null(anySchema, anyReferences, value);
             case 'Number':

package/value/create.d.ts

@@ -3,6 +3,10 @@ export declare class ValueCreateUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare class ValueCreateNeverTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare namespace ValueCreate {
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
     function Visit<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>;

package/value/create.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = exports.ValueCreateUnknownTypeError = void 0;
+exports.ValueCreate = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
 const Types = require("../typebox");
 class ValueCreateUnknownTypeError extends Error {
     constructor(schema) {
@@ -36,6 +36,13 @@ class ValueCreateUnknownTypeError extends Error {
     }
 }
 exports.ValueCreateUnknownTypeError = ValueCreateUnknownTypeError;
+class ValueCreateNeverTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Never types cannot be created');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateNeverTypeError = ValueCreateNeverTypeError;
 var ValueCreate;
 (function (ValueCreate) {
     function Any(schema, references) {
@@ -125,6 +132,9 @@ var ValueCreate;
     function Literal(schema, references) {
         return schema.const;
     }
+    function Never(schema, references) {
+        throw new ValueCreateNeverTypeError(schema);
+    }
     function Null(schema, references) {
         return null;
     }
@@ -303,6 +313,8 @@ var ValueCreate;
                 return Integer(anySchema, anyReferences);
             case 'Literal':
                 return Literal(anySchema, anyReferences);
+            case 'Never':
+                return Never(anySchema, anyReferences);
             case 'Null':
                 return Null(anySchema, anyReferences);
             case 'Number':

package/value/delta.js

@@ -122,7 +122,6 @@ var ValueDelta;
             return yield* Value(path, current, next);
         }
         else {
-            console.log('left', current);
             throw new Error('ValueDelta: Cannot produce edits for value');
         }
     }

package/value/index.d.ts

@@ -1,2 +1,3 @@
 export { ValueError, ValueErrorType } from '../errors/index';
+export * from './pointer';
 export * from './value';

package/value/index.js

@@ -44,4 +44,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValueErrorType = void 0;
 var index_1 = require("../errors/index");
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
+__exportStar(require("./pointer"), exports);
 __exportStar(require("./value"), exports);

package/value/pointer.d.ts

@@ -1,11 +1,22 @@
-/** RFC6901 JsonPointer */
+export declare class ValuePointerRootSetError extends Error {
+    readonly value: unknown;
+    readonly path: string;
+    readonly update: unknown;
+    constructor(value: unknown, path: string, update: unknown);
+}
+export declare class ValuePointerRootDeleteError extends Error {
+    readonly value: unknown;
+    readonly path: string;
+    constructor(value: unknown, path: string);
+}
+/** ValuePointer performs mutable operations on values using RFC6901 Json Pointers */
 export declare namespace ValuePointer {
     /** Sets the value at the given pointer. If the value at the pointer does not exist it is created. */
-    function Set(value: any, pointer: string, update: any): void;
-    /** Deletes a value at the given pointer. */
-    function Delete(value: any, pointer: string): any[] | undefined;
-    /** True if a value exists at the given pointer */
-    function Has(value: any, pointer: string): boolean;
-    /** Gets the value at the given pointer */
-    function Get(value: any, pointer: string): any;
+    function Set(value: unknown, path: string, update: unknown): void;
+    /** Deletes a value at the given path. */
+    function Delete(value: any, path: string): any[] | undefined;
+    /** True if a value exists at the given path */
+    function Has(value: any, path: string): boolean;
+    /** Gets the value at the given path */
+    function Get(value: any, path: string): any;
 }

package/value/pointer.js

@@ -27,82 +27,122 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValuePointer = void 0;
-/** RFC6901 JsonPointer */
+exports.ValuePointer = exports.ValuePointerRootDeleteError = exports.ValuePointerRootSetError = void 0;
+class ValuePointerRootSetError extends Error {
+    constructor(value, path, update) {
+        super('ValuePointer: Cannot set root value');
+        this.value = value;
+        this.path = path;
+        this.update = update;
+    }
+}
+exports.ValuePointerRootSetError = ValuePointerRootSetError;
+class ValuePointerRootDeleteError extends Error {
+    constructor(value, path) {
+        super('ValuePointer: Cannot delete root value');
+        this.value = value;
+        this.path = path;
+    }
+}
+exports.ValuePointerRootDeleteError = ValuePointerRootDeleteError;
+/** ValuePointer performs mutable operations on values using RFC6901 Json Pointers */
 var ValuePointer;
 (function (ValuePointer) {
-    function Format(pointer) {
-        if (pointer === '/')
-            return [''];
-        const split = pointer.split('/');
-        const filter = split.filter((part) => part.length > 0);
-        return filter.map((part) => part.replace(/~0/g, `~`).replace(/~1/g, `/`));
+    /** Formats the path into navigable components */
+    function* Format(path) {
+        function clear(chars) {
+            while (chars.length > 0)
+                chars.shift();
+        }
+        const chars = [];
+        for (let i = 0; i < path.length; i++) {
+            const char = path.charAt(i);
+            if (char === '/') {
+                if (i !== 0) {
+                    yield chars.join('');
+                    clear(chars);
+                }
+            }
+            else if (char === '~' && path.charAt(i + 1) === '0' && (path.charAt(i + 2) === '/' || i !== path.length - 1)) {
+                chars.push('~');
+                i += 1;
+            }
+            else if (char === '~' && path.charAt(i + 1) === '1' && (path.charAt(i + 2) === '/' || i !== path.length - 1)) {
+                chars.push('/');
+                i += 1;
+            }
+            else {
+                chars.push(char);
+            }
+        }
+        yield chars.join('');
+        clear(chars);
     }
     /** Sets the value at the given pointer. If the value at the pointer does not exist it is created. */
-    function Set(value, pointer, update) {
-        if (pointer === '')
-            throw Error('Cannot set root value');
-        const path = Format(pointer);
+    function Set(value, path, update) {
+        if (path === '')
+            throw new ValuePointerRootSetError(value, path, update);
+        const pointer = [...Format(path)];
         let current = value;
-        while (path.length > 1) {
-            const next = path.shift();
+        while (pointer.length > 1) {
+            const next = pointer.shift();
             if (current[next] === undefined)
                 current[next] = {};
             current = current[next];
         }
-        current[path.shift()] = update;
+        current[pointer.shift()] = update;
     }
     ValuePointer.Set = Set;
-    /** Deletes a value at the given pointer. */
-    function Delete(value, pointer) {
-        if (pointer === '')
-            throw Error('Cannot delete root value');
+    /** Deletes a value at the given path. */
+    function Delete(value, path) {
+        if (path === '')
+            throw new ValuePointerRootDeleteError(value, path);
         let current = value;
-        const path = Format(pointer);
-        while (path.length > 1) {
-            const next = path.shift();
+        const pointer = [...Format(path)];
+        while (pointer.length > 1) {
+            const next = pointer.shift();
             if (current[next] === undefined)
                 return;
             current = current[next];
         }
-        if (Array.isArray(current)) {
-            const index = parseInt(path.shift());
+        if (globalThis.Array.isArray(current)) {
+            const index = parseInt(pointer.shift());
             return current.splice(index, 1);
         }
         else {
-            const key = path.shift();
+            const key = pointer.shift();
             delete current[key];
         }
     }
     ValuePointer.Delete = Delete;
-    /** True if a value exists at the given pointer */
-    function Has(value, pointer) {
-        if (pointer === '')
+    /** True if a value exists at the given path */
+    function Has(value, path) {
+        if (path === '')
             return true;
         let current = value;
-        const path = Format(pointer);
-        while (path.length > 1) {
-            const next = path.shift();
+        const pointer = [...Format(path)];
+        while (pointer.length > 1) {
+            const next = pointer.shift();
             if (current[next] === undefined)
                 return false;
             current = current[next];
         }
-        return current[path.shift()] !== undefined;
+        return current[pointer.shift()] !== undefined;
     }
     ValuePointer.Has = Has;
-    /** Gets the value at the given pointer */
-    function Get(value, pointer) {
-        if (pointer === '')
+    /** Gets the value at the given path */
+    function Get(value, path) {
+        if (path === '')
             return value;
         let current = value;
-        const path = Format(pointer);
-        while (path.length > 1) {
-            const next = path.shift();
+        const pointer = [...Format(path)];
+        while (pointer.length > 1) {
+            const next = pointer.shift();
             if (current[next] === undefined)
                 return undefined;
             current = current[next];
         }
-        return current[path.shift()];
+        return current[pointer.shift()];
     }
     ValuePointer.Get = Get;
 })(ValuePointer = exports.ValuePointer || (exports.ValuePointer = {}));

package/value/value.d.ts

@@ -2,7 +2,7 @@ import * as Types from '../typebox';
 import { ValueError } from '../errors/index';
 import { Edit } from './delta';
 export type { Edit } from './delta';
-/** The Value namespace provides type operations on values */
+/** Value performs immutable operations on values */
 export declare namespace Value {
     /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number and boolean values if a reasonable conversion is possible. */
     function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>;

package/value/value.js

@@ -35,7 +35,7 @@ const clone_1 = require("./clone");
 const create_1 = require("./create");
 const check_1 = require("./check");
 const delta_1 = require("./delta");
-/** The Value namespace provides type operations on values */
+/** Value performs immutable operations on values */
 var Value;
 (function (Value) {
     function Cast(...args) {