@sinclair/typebox 0.30.4 → 0.31.0-dev-1

package/value/create.js

@@ -27,58 +27,52 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Create = exports.ValueCreateRecursiveInstantiationError = exports.ValueCreateDereferenceError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNotTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
+exports.Create = exports.ValueCreateRecursiveInstantiationError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNotTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
+const guard_1 = require("./guard");
+const check_1 = require("./check");
+const deref_1 = require("./deref");
 const Types = require("../typebox");
-const ValueCheck = require("./check");
-const ValueGuard = require("./guard");
 // --------------------------------------------------------------------------
 // Errors
 // --------------------------------------------------------------------------
-class ValueCreateUnknownTypeError extends Error {
+class ValueCreateUnknownTypeError extends Types.TypeBoxError {
     constructor(schema) {
-        super('ValueCreate: Unknown type');
+        super('Unknown type');
         this.schema = schema;
     }
 }
 exports.ValueCreateUnknownTypeError = ValueCreateUnknownTypeError;
-class ValueCreateNeverTypeError extends Error {
+class ValueCreateNeverTypeError extends Types.TypeBoxError {
     constructor(schema) {
-        super('ValueCreate: Never types cannot be created');
+        super('Never types cannot be created');
         this.schema = schema;
     }
 }
 exports.ValueCreateNeverTypeError = ValueCreateNeverTypeError;
-class ValueCreateNotTypeError extends Error {
+class ValueCreateNotTypeError extends Types.TypeBoxError {
     constructor(schema) {
-        super('ValueCreate: Not types must have a default value');
+        super('Not types must have a default value');
         this.schema = schema;
     }
 }
 exports.ValueCreateNotTypeError = ValueCreateNotTypeError;
-class ValueCreateIntersectTypeError extends Error {
+class ValueCreateIntersectTypeError extends Types.TypeBoxError {
     constructor(schema) {
-        super('ValueCreate: Intersect produced invalid value. Consider using a default value.');
+        super('Intersect produced invalid value. Consider using a default value.');
         this.schema = schema;
     }
 }
 exports.ValueCreateIntersectTypeError = ValueCreateIntersectTypeError;
-class ValueCreateTempateLiteralTypeError extends Error {
+class ValueCreateTempateLiteralTypeError extends Types.TypeBoxError {
     constructor(schema) {
-        super('ValueCreate: Can only create template literal values from patterns that produce finite sequences. Consider using a default value.');
+        super('Can only create template literal values from patterns that produce finite sequences. Consider using a default value.');
         this.schema = schema;
     }
 }
 exports.ValueCreateTempateLiteralTypeError = ValueCreateTempateLiteralTypeError;
-class ValueCreateDereferenceError extends Error {
-    constructor(schema) {
-        super(`ValueCreate: Unable to dereference type with $id '${schema.$ref}'`);
-        this.schema = schema;
-    }
-}
-exports.ValueCreateDereferenceError = ValueCreateDereferenceError;
-class ValueCreateRecursiveInstantiationError extends Error {
+class ValueCreateRecursiveInstantiationError extends Types.TypeBoxError {
     constructor(schema, recursiveMaxDepth) {
-        super('ValueCreate: Value cannot be created as recursive type may produce value of infinite size. Consider using a default.');
+        super('Value cannot be created as recursive type may produce value of infinite size. Consider using a default.');
         this.schema = schema;
         this.recursiveMaxDepth = recursiveMaxDepth;
     }
@@ -88,7 +82,7 @@ exports.ValueCreateRecursiveInstantiationError = ValueCreateRecursiveInstantiati
 // Types
 // --------------------------------------------------------------------------
 function TAny(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -96,10 +90,10 @@ function TAny(schema, references) {
     }
 }
 function TArray(schema, references) {
-    if (schema.uniqueItems === true && !ValueGuard.HasPropertyKey(schema, 'default')) {
+    if (schema.uniqueItems === true && !(0, guard_1.HasPropertyKey)(schema, 'default')) {
         throw new Error('ValueCreate.Array: Array with the uniqueItems constraint requires a default value');
     }
-    else if ('contains' in schema && !ValueGuard.HasPropertyKey(schema, 'default')) {
+    else if ('contains' in schema && !(0, guard_1.HasPropertyKey)(schema, 'default')) {
         throw new Error('ValueCreate.Array: Array with the contains constraint requires a default value');
     }
     else if ('default' in schema) {
@@ -115,7 +109,7 @@ function TArray(schema, references) {
     }
 }
 function TAsyncIterator(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -123,7 +117,7 @@ function TAsyncIterator(schema, references) {
     }
 }
 function TBigInt(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -131,7 +125,7 @@ function TBigInt(schema, references) {
     }
 }
 function TBoolean(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -139,7 +133,7 @@ function TBoolean(schema, references) {
     }
 }
 function TConstructor(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -161,7 +155,7 @@ function TConstructor(schema, references) {
     }
 }
 function TDate(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else if (schema.minimumTimestamp !== undefined) {
@@ -172,7 +166,7 @@ function TDate(schema, references) {
     }
 }
 function TFunction(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -180,7 +174,7 @@ function TFunction(schema, references) {
     }
 }
 function TInteger(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else if (schema.minimum !== undefined) {
@@ -191,7 +185,7 @@ function TInteger(schema, references) {
     }
 }
 function TIntersect(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -202,13 +196,13 @@ function TIntersect(schema, references) {
             const next = Visit(schema, references);
             return typeof next === 'object' ? { ...acc, ...next } : next;
         }, {});
-        if (!ValueCheck.Check(schema, references, value))
+        if (!(0, check_1.Check)(schema, references, value))
             throw new ValueCreateIntersectTypeError(schema);
         return value;
     }
 }
 function TIterator(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -216,7 +210,7 @@ function TIterator(schema, references) {
     }
 }
 function TLiteral(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -227,7 +221,7 @@ function TNever(schema, references) {
     throw new ValueCreateNeverTypeError(schema);
 }
 function TNot(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -235,7 +229,7 @@ function TNot(schema, references) {
     }
 }
 function TNull(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -243,7 +237,7 @@ function TNull(schema, references) {
     }
 }
 function TNumber(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else if (schema.minimum !== undefined) {
@@ -254,7 +248,7 @@ function TNumber(schema, references) {
     }
 }
 function TObject(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -266,7 +260,7 @@ function TObject(schema, references) {
     }
 }
 function TPromise(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -275,7 +269,7 @@ function TPromise(schema, references) {
 }
 function TRecord(schema, references) {
     const [keyPattern, valueSchema] = Object.entries(schema.patternProperties)[0];
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else if (!(keyPattern === Types.PatternStringExact || keyPattern === Types.PatternNumberExact)) {
@@ -289,20 +283,16 @@ function TRecord(schema, references) {
     }
 }
 function TRef(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
-        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-        if (index === -1)
-            throw new ValueCreateDereferenceError(schema);
-        const target = references[index];
-        return Visit(target, references);
+        return Visit((0, deref_1.Deref)(schema, references), references);
     }
 }
 function TString(schema, references) {
     if (schema.pattern !== undefined) {
-        if (!ValueGuard.HasPropertyKey(schema, 'default')) {
+        if (!(0, guard_1.HasPropertyKey)(schema, 'default')) {
             throw new Error('ValueCreate.String: String types with patterns must specify a default value');
         }
         else {
@@ -310,7 +300,7 @@ function TString(schema, references) {
         }
     }
     else if (schema.format !== undefined) {
-        if (!ValueGuard.HasPropertyKey(schema, 'default')) {
+        if (!(0, guard_1.HasPropertyKey)(schema, 'default')) {
             throw new Error('ValueCreate.String: String types with formats must specify a default value');
         }
         else {
@@ -318,7 +308,7 @@ function TString(schema, references) {
         }
     }
     else {
-        if (ValueGuard.HasPropertyKey(schema, 'default')) {
+        if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
             return schema.default;
         }
         else if (schema.minLength !== undefined) {
@@ -332,7 +322,7 @@ function TString(schema, references) {
     }
 }
 function TSymbol(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else if ('value' in schema) {
@@ -343,7 +333,7 @@ function TSymbol(schema, references) {
     }
 }
 function TTemplateLiteral(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     const expression = Types.TemplateLiteralParser.ParseExact(schema.pattern);
@@ -355,19 +345,15 @@ function TTemplateLiteral(schema, references) {
 function TThis(schema, references) {
     if (recursiveDepth++ > recursiveMaxDepth)
         throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth);
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
-        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-        if (index === -1)
-            throw new ValueCreateDereferenceError(schema);
-        const target = references[index];
-        return Visit(target, references);
+        return Visit((0, deref_1.Deref)(schema, references), references);
     }
 }
 function TTuple(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     if (schema.items === undefined) {
@@ -378,7 +364,7 @@ function TTuple(schema, references) {
     }
 }
 function TUndefined(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -386,7 +372,7 @@ function TUndefined(schema, references) {
     }
 }
 function TUnion(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else if (schema.anyOf.length === 0) {
@@ -397,7 +383,7 @@ function TUnion(schema, references) {
     }
 }
 function TUint8Array(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else if (schema.minByteLength !== undefined) {
@@ -408,7 +394,7 @@ function TUint8Array(schema, references) {
     }
 }
 function TUnknown(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -416,7 +402,7 @@ function TUnknown(schema, references) {
     }
 }
 function TVoid(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
@@ -424,15 +410,15 @@ function TVoid(schema, references) {
     }
 }
 function TKind(schema, references) {
-    if (ValueGuard.HasPropertyKey(schema, 'default')) {
+    if ((0, guard_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
     else {
-        throw new Error('ValueCreate: User defined types must specify a default value');
+        throw new Error('User defined types must specify a default value');
     }
 }
 function Visit(schema, references) {
-    const references_ = ValueGuard.IsString(schema.$id) ? [...references, schema] : references;
+    const references_ = (0, guard_1.IsString)(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
     switch (schema_[Types.Kind]) {
         case 'Any':

package/value/delta.js

@@ -28,10 +28,10 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Patch = exports.Diff = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Edit = exports.Delete = exports.Update = exports.Insert = void 0;
+const guard_1 = require("./guard");
 const typebox_1 = require("../typebox");
 const pointer_1 = require("./pointer");
-const ValueGuard = require("./guard");
-const ValueClone = require("./clone");
+const clone_1 = require("./clone");
 exports.Insert = typebox_1.Type.Object({
     type: typebox_1.Type.Literal('insert'),
     path: typebox_1.Type.String(),
@@ -52,14 +52,14 @@ exports.Edit = typebox_1.Type.Union([exports.Insert, exports.Update, exports.Del
 // --------------------------------------------------------------------------
 class ValueDeltaObjectWithSymbolKeyError extends Error {
     constructor(key) {
-        super('ValueDelta: Cannot diff objects with symbol keys');
+        super('Cannot diff objects with symbol keys');
         this.key = key;
     }
 }
 exports.ValueDeltaObjectWithSymbolKeyError = ValueDeltaObjectWithSymbolKeyError;
 class ValueDeltaUnableToDiffUnknownValue extends Error {
     constructor(value) {
-        super('ValueDelta: Unable to create diff edits for unknown value');
+        super('Unable to create diff edits for unknown value');
         this.value = value;
     }
 }
@@ -80,38 +80,38 @@ function CreateDelete(path) {
 // Diffing Generators
 // --------------------------------------------------------------------------
 function* ObjectType(path, current, next) {
-    if (!ValueGuard.IsPlainObject(next))
+    if (!(0, guard_1.IsPlainObject)(next))
         return yield CreateUpdate(path, next);
     const currentKeys = [...Object.keys(current), ...Object.getOwnPropertySymbols(current)];
     const nextKeys = [...Object.keys(next), ...Object.getOwnPropertySymbols(next)];
     for (const key of currentKeys) {
-        if (ValueGuard.IsSymbol(key))
+        if ((0, guard_1.IsSymbol)(key))
             throw new ValueDeltaObjectWithSymbolKeyError(key);
-        if (ValueGuard.IsUndefined(next[key]) && nextKeys.includes(key))
+        if ((0, guard_1.IsUndefined)(next[key]) && nextKeys.includes(key))
             yield CreateUpdate(`${path}/${String(key)}`, undefined);
     }
     for (const key of nextKeys) {
-        if (ValueGuard.IsUndefined(current[key]) || ValueGuard.IsUndefined(next[key]))
+        if ((0, guard_1.IsUndefined)(current[key]) || (0, guard_1.IsUndefined)(next[key]))
             continue;
-        if (ValueGuard.IsSymbol(key))
+        if ((0, guard_1.IsSymbol)(key))
             throw new ValueDeltaObjectWithSymbolKeyError(key);
         yield* Visit(`${path}/${String(key)}`, current[key], next[key]);
     }
     for (const key of nextKeys) {
-        if (ValueGuard.IsSymbol(key))
+        if ((0, guard_1.IsSymbol)(key))
             throw new ValueDeltaObjectWithSymbolKeyError(key);
-        if (ValueGuard.IsUndefined(current[key]))
+        if ((0, guard_1.IsUndefined)(current[key]))
             yield CreateInsert(`${path}/${String(key)}`, next[key]);
     }
     for (const key of currentKeys.reverse()) {
-        if (ValueGuard.IsSymbol(key))
+        if ((0, guard_1.IsSymbol)(key))
             throw new ValueDeltaObjectWithSymbolKeyError(key);
-        if (ValueGuard.IsUndefined(next[key]) && !nextKeys.includes(key))
+        if ((0, guard_1.IsUndefined)(next[key]) && !nextKeys.includes(key))
             yield CreateDelete(`${path}/${String(key)}`);
     }
 }
 function* ArrayType(path, current, next) {
-    if (!ValueGuard.IsArray(next))
+    if (!(0, guard_1.IsArray)(next))
         return yield CreateUpdate(path, next);
     for (let i = 0; i < Math.min(current.length, next.length); i++) {
         yield* Visit(`${path}/${i}`, current[i], next[i]);
@@ -128,7 +128,7 @@ function* ArrayType(path, current, next) {
     }
 }
 function* TypedArrayType(path, current, next) {
-    if (!ValueGuard.IsTypedArray(next) || current.length !== next.length || Object.getPrototypeOf(current).constructor.name !== Object.getPrototypeOf(next).constructor.name)
+    if (!(0, guard_1.IsTypedArray)(next) || current.length !== next.length || Object.getPrototypeOf(current).constructor.name !== Object.getPrototypeOf(next).constructor.name)
         return yield CreateUpdate(path, next);
     for (let i = 0; i < Math.min(current.length, next.length); i++) {
         yield* Visit(`${path}/${i}`, current[i], next[i]);
@@ -140,13 +140,13 @@ function* ValueType(path, current, next) {
     yield CreateUpdate(path, next);
 }
 function* Visit(path, current, next) {
-    if (ValueGuard.IsPlainObject(current))
+    if ((0, guard_1.IsPlainObject)(current))
         return yield* ObjectType(path, current, next);
-    if (ValueGuard.IsArray(current))
+    if ((0, guard_1.IsArray)(current))
         return yield* ArrayType(path, current, next);
-    if (ValueGuard.IsTypedArray(current))
+    if ((0, guard_1.IsTypedArray)(current))
         return yield* TypedArrayType(path, current, next);
-    if (ValueGuard.IsValueType(current))
+    if ((0, guard_1.IsValueType)(current))
         return yield* ValueType(path, current, next);
     throw new ValueDeltaUnableToDiffUnknownValue(current);
 }
@@ -168,12 +168,12 @@ function IsIdentity(edits) {
 }
 function Patch(current, edits) {
     if (IsRootUpdate(edits)) {
-        return ValueClone.Clone(edits[0].value);
+        return (0, clone_1.Clone)(edits[0].value);
     }
     if (IsIdentity(edits)) {
-        return ValueClone.Clone(current);
+        return (0, clone_1.Clone)(current);
     }
-    const clone = ValueClone.Clone(current);
+    const clone = (0, clone_1.Clone)(current);
     for (const edit of edits) {
         switch (edit.type) {
             case 'insert': {

package/value/deref.d.ts

@@ -0,0 +1,7 @@
+import { TypeBoxError, TSchema, TRef, TThis } from '../typebox';
+export declare class TypeDereferenceError extends TypeBoxError {
+    readonly schema: TRef | TThis;
+    constructor(schema: TRef | TThis);
+}
+/** Dereferences a schema from the references array or throws if not found */
+export declare function Deref(schema: TRef | TThis, references: TSchema[]): TSchema;

package/value/deref.js

@@ -0,0 +1,46 @@
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/value
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deref = exports.TypeDereferenceError = void 0;
+const typebox_1 = require("../typebox");
+class TypeDereferenceError extends typebox_1.TypeBoxError {
+    constructor(schema) {
+        super(`Unable to dereference schema with $id '${schema.$id}'`);
+        this.schema = schema;
+    }
+}
+exports.TypeDereferenceError = TypeDereferenceError;
+/** Dereferences a schema from the references array or throws if not found */
+function Deref(schema, references) {
+    const index = references.findIndex((target) => target.$id === schema.$ref);
+    if (index === -1)
+        throw new TypeDereferenceError(schema);
+    return references[index];
+}
+exports.Deref = Deref;

package/value/equal.js

@@ -28,12 +28,12 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Equal = void 0;
-const ValueGuard = require("./guard");
+const guard_1 = require("./guard");
 // --------------------------------------------------------------------------
 // Equality Checks
 // --------------------------------------------------------------------------
 function ObjectType(left, right) {
-    if (!ValueGuard.IsPlainObject(right))
+    if (!(0, guard_1.IsPlainObject)(right))
         return false;
     const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)];
     const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)];
@@ -42,15 +42,15 @@ function ObjectType(left, right) {
     return leftKeys.every((key) => Equal(left[key], right[key]));
 }
 function DateType(left, right) {
-    return ValueGuard.IsDate(right) && left.getTime() === right.getTime();
+    return (0, guard_1.IsDate)(right) && left.getTime() === right.getTime();
 }
 function ArrayType(left, right) {
-    if (!ValueGuard.IsArray(right) || left.length !== right.length)
+    if (!(0, guard_1.IsArray)(right) || left.length !== right.length)
         return false;
     return left.every((value, index) => Equal(value, right[index]));
 }
 function TypedArrayType(left, right) {
-    if (!ValueGuard.IsTypedArray(right) || left.length !== right.length || Object.getPrototypeOf(left).constructor.name !== Object.getPrototypeOf(right).constructor.name)
+    if (!(0, guard_1.IsTypedArray)(right) || left.length !== right.length || Object.getPrototypeOf(left).constructor.name !== Object.getPrototypeOf(right).constructor.name)
         return false;
     return left.every((value, index) => Equal(value, right[index]));
 }
@@ -62,15 +62,15 @@ function ValueType(left, right) {
 // --------------------------------------------------------------------------
 /** Returns true if the left value deep-equals the right */
 function Equal(left, right) {
-    if (ValueGuard.IsPlainObject(left))
+    if ((0, guard_1.IsPlainObject)(left))
         return ObjectType(left, right);
-    if (ValueGuard.IsDate(left))
+    if ((0, guard_1.IsDate)(left))
         return DateType(left, right);
-    if (ValueGuard.IsTypedArray(left))
+    if ((0, guard_1.IsTypedArray)(left))
         return TypedArrayType(left, right);
-    if (ValueGuard.IsArray(left))
+    if ((0, guard_1.IsArray)(left))
         return ArrayType(left, right);
-    if (ValueGuard.IsValueType(left))
+    if ((0, guard_1.IsValueType)(left))
         return ValueType(left, right);
     throw new Error('ValueEquals: Unable to compare value');
 }

package/value/guard.js

@@ -61,7 +61,7 @@ function IsUint8Array(value) {
 exports.IsUint8Array = IsUint8Array;
 /** Returns true if this value is a Date */
 function IsDate(value) {
-    return value instanceof Date;
+    return value instanceof Date && Number.isFinite(value.getTime());
 }
 exports.IsDate = IsDate;
 // --------------------------------------------------------------------------