@sinclair/typebox 0.26.0-dev.1 → 0.26.0-dev.3

package/typebox.js

@@ -1,1875 +1,1881 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox
-
-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.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.KeyResolver = exports.ObjectMap = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.ReferenceRegistry = exports.TypeRegistry = exports.Modifier = exports.Hint = exports.Kind = void 0;
-// -------------------------------------------------------------------------------------
-// Symbols
-// -------------------------------------------------------------------------------------
-exports.Kind = Symbol.for('TypeBox.Kind');
-exports.Hint = Symbol.for('TypeBox.Hint');
-exports.Modifier = Symbol.for('TypeBox.Modifier');
-var TypeRegistry;
-(function (TypeRegistry) {
-    const types = new Map();
-    /** Clears all user defined types */
-    function Clear() {
-        return types.clear();
-    }
-    TypeRegistry.Clear = Clear;
-    /** Returns true if this registry contains this kind */
-    function Has(kind) {
-        return types.has(kind);
-    }
-    TypeRegistry.Has = Has;
-    /** Sets a validation function for a user defined type */
-    function Set(kind, func) {
-        types.set(kind, func);
-    }
-    TypeRegistry.Set = Set;
-    /** Gets a custom validation function for a user defined type */
-    function Get(kind) {
-        return types.get(kind);
-    }
-    TypeRegistry.Get = Get;
-})(TypeRegistry = exports.TypeRegistry || (exports.TypeRegistry = {}));
-// -------------------------------------------------------------------------------------
-// ReferenceRegistry
-// -------------------------------------------------------------------------------------
-var ReferenceRegistry;
-(function (ReferenceRegistry) {
-    const references = new Map();
-    /** Clears the reference registry */
-    function Clear() {
-        return references.clear();
-    }
-    ReferenceRegistry.Clear = Clear;
-    /** Returns true if this registry contains this schema */
-    function Has(schema) {
-        return references.has(schema.$id);
-    }
-    ReferenceRegistry.Has = Has;
-    /** Sets this schema on this registry if a $id exists */
-    function Set(schema) {
-        const $id = typeof schema === 'object' && schema !== null && typeof schema['$id'] === 'string' ? schema['$id'] : undefined;
-        if ($id !== undefined)
-            references.set($id, schema);
-    }
-    ReferenceRegistry.Set = Set;
-    /** Dereferences the schema one level deep */
-    function DerefOne(schema) {
-        if (TypeGuard.TRef(schema) || TypeGuard.TSelf(schema)) {
-            if (!references.has(schema.$ref))
-                throw Error(`ReferenceRegistry: Cannot deref schema with $id '${schema.$ref}'`);
-            return references.get(schema.$ref);
-        }
-        else {
-            return schema;
-        }
-    }
-    ReferenceRegistry.DerefOne = DerefOne;
-    /** Dereferences the schema recursively */
-    function Deref(schema) {
-        if (TypeGuard.TRef(schema)) {
-            return Deref(DerefOne(schema));
-        }
-        else {
-            return schema;
-        }
-    }
-    ReferenceRegistry.Deref = Deref;
-})(ReferenceRegistry = exports.ReferenceRegistry || (exports.ReferenceRegistry = {}));
-/** Provides functions to create user defined string formats */
-var FormatRegistry;
-(function (FormatRegistry) {
-    const formats = new Map();
-    /** Clears all user defined string formats */
-    function Clear() {
-        return formats.clear();
-    }
-    FormatRegistry.Clear = Clear;
-    /** Returns true if the user defined string format exists */
-    function Has(format) {
-        return formats.has(format);
-    }
-    FormatRegistry.Has = Has;
-    /** Sets a validation function for a user defined string format */
-    function Set(format, func) {
-        formats.set(format, func);
-    }
-    FormatRegistry.Set = Set;
-    /** Gets a validation function for a user defined string format */
-    function Get(format) {
-        return formats.get(format);
-    }
-    FormatRegistry.Get = Get;
-})(FormatRegistry = exports.FormatRegistry || (exports.FormatRegistry = {}));
-// -------------------------------------------------------------------------------------
-// TypeGuard
-// -------------------------------------------------------------------------------------
-class TypeGuardUnknownTypeError extends Error {
-    constructor(schema) {
-        super('TypeGuard: Unknown type');
-        this.schema = schema;
-    }
-}
-exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
-var TypeGuard;
-(function (TypeGuard) {
-    function IsObject(value) {
-        return typeof value === 'object' && value !== null && !Array.isArray(value);
-    }
-    function IsArray(value) {
-        return typeof value === 'object' && value !== null && Array.isArray(value);
-    }
-    function IsPattern(value) {
-        try {
-            new RegExp(value);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    function IsControlCharacterFree(value) {
-        if (typeof value !== 'string')
-            return false;
-        for (let i = 0; i < value.length; i++) {
-            const code = value.charCodeAt(i);
-            if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
-                return false;
-            }
-        }
-        return true;
-    }
-    function IsBigInt(value) {
-        return typeof value === 'bigint';
-    }
-    function IsString(value) {
-        return typeof value === 'string';
-    }
-    function IsNumber(value) {
-        return typeof value === 'number' && globalThis.Number.isFinite(value);
-    }
-    function IsBoolean(value) {
-        return typeof value === 'boolean';
-    }
-    function IsOptionalBigInt(value) {
-        return value === undefined || (value !== undefined && IsBigInt(value));
-    }
-    function IsOptionalNumber(value) {
-        return value === undefined || (value !== undefined && IsNumber(value));
-    }
-    function IsOptionalBoolean(value) {
-        return value === undefined || (value !== undefined && IsBoolean(value));
-    }
-    function IsOptionalString(value) {
-        return value === undefined || (value !== undefined && IsString(value));
-    }
-    function IsOptionalPattern(value) {
-        return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value) && IsPattern(value));
-    }
-    function IsOptionalFormat(value) {
-        return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value));
-    }
-    function IsOptionalSchema(value) {
-        return value === undefined || TSchema(value);
-    }
-    /** Returns true if the given schema is TAny */
-    function TAny(schema) {
-        return TKind(schema) && schema[exports.Kind] === 'Any' && IsOptionalString(schema.$id);
-    }
-    TypeGuard.TAny = TAny;
-    /** Returns true if the given schema is TArray */
-    function TArray(schema) {
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Array' &&
-            schema.type === 'array' &&
-            IsOptionalString(schema.$id) &&
-            TSchema(schema.items) &&
-            IsOptionalNumber(schema.minItems) &&
-            IsOptionalNumber(schema.maxItems) &&
-            IsOptionalBoolean(schema.uniqueItems));
-    }
-    TypeGuard.TArray = TArray;
-    /** Returns true if the given schema is TSymbol */
-    function TBigInt(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'BigInt' &&
-            schema.type === 'null' &&
-            schema.typeOf === 'BigInt' &&
-            IsOptionalString(schema.$id) &&
-            IsOptionalBigInt(schema.multipleOf) &&
-            IsOptionalBigInt(schema.minimum) &&
-            IsOptionalBigInt(schema.maximum) &&
-            IsOptionalBigInt(schema.exclusiveMinimum) &&
-            IsOptionalBigInt(schema.exclusiveMaximum));
-    }
-    TypeGuard.TBigInt = TBigInt;
-    /** Returns true if the given schema is TBoolean */
-    function TBoolean(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Boolean' &&
-            schema.type === 'boolean' &&
-            IsOptionalString(schema.$id));
-    }
-    TypeGuard.TBoolean = TBoolean;
-    /** Returns true if the given schema is TConstructor */
-    function TConstructor(schema) {
-        // prettier-ignore
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Constructor' &&
-            schema.type === 'object' &&
-            schema.instanceOf === 'Constructor' &&
-            IsOptionalString(schema.$id) &&
-            IsArray(schema.parameters) &&
-            TSchema(schema.returns))) {
-            return false;
-        }
-        for (const parameter of schema.parameters) {
-            if (!TSchema(parameter))
-                return false;
-        }
-        return true;
-    }
-    TypeGuard.TConstructor = TConstructor;
-    /** Returns true if the given schema is TDate */
-    function TDate(schema) {
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Date' &&
-            schema.type === 'object' &&
-            schema.instanceOf === 'Date' &&
-            IsOptionalString(schema.$id) &&
-            IsOptionalNumber(schema.minimumTimestamp) &&
-            IsOptionalNumber(schema.maximumTimestamp) &&
-            IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
-            IsOptionalNumber(schema.exclusiveMaximumTimestamp));
-    }
-    TypeGuard.TDate = TDate;
-    /** Returns true if the given schema is TFunction */
-    function TFunction(schema) {
-        // prettier-ignore
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Function' &&
-            schema.type === 'object' &&
-            schema.instanceOf === 'Function' &&
-            IsOptionalString(schema.$id) &&
-            IsArray(schema.parameters) &&
-            TSchema(schema.returns))) {
-            return false;
-        }
-        for (const parameter of schema.parameters) {
-            if (!TSchema(parameter))
-                return false;
-        }
-        return true;
-    }
-    TypeGuard.TFunction = TFunction;
-    /** Returns true if the given schema is TInteger */
-    function TInteger(schema) {
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Integer' &&
-            schema.type === 'integer' &&
-            IsOptionalString(schema.$id) &&
-            IsOptionalNumber(schema.multipleOf) &&
-            IsOptionalNumber(schema.minimum) &&
-            IsOptionalNumber(schema.maximum) &&
-            IsOptionalNumber(schema.exclusiveMinimum) &&
-            IsOptionalNumber(schema.exclusiveMaximum));
-    }
-    TypeGuard.TInteger = TInteger;
-    /** Returns true if the given schema is TIntersect */
-    function TIntersect(schema) {
-        // prettier-ignore
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Intersect' &&
-            IsArray(schema.allOf) &&
-            IsOptionalString(schema.type) &&
-            (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
-            IsOptionalString(schema.$id))) {
-            return false;
-        }
-        if ('type' in schema && schema.type !== 'object') {
-            return false;
-        }
-        for (const inner of schema.allOf) {
-            if (!TSchema(inner))
-                return false;
-        }
-        return true;
-    }
-    TypeGuard.TIntersect = TIntersect;
-    /** Returns true if the given schema is TKind */
-    function TKind(schema) {
-        return IsObject(schema) && exports.Kind in schema && typeof schema[exports.Kind] === 'string'; // TS 4.1.5: any required for symbol indexer
-    }
-    TypeGuard.TKind = TKind;
-    /** Returns true if the given schema is TLiteral */
-    function TLiteral(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Literal' &&
-            IsOptionalString(schema.$id) &&
-            (IsString(schema.const) ||
-                IsNumber(schema.const) ||
-                IsBoolean(schema.const) ||
-                IsBigInt(schema.const)));
-    }
-    TypeGuard.TLiteral = TLiteral;
-    /** Returns true if the given schema is TNever */
-    function TNever(schema) {
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Never' &&
-            IsArray(schema.allOf) &&
-            schema.allOf.length === 2 &&
-            IsObject(schema.allOf[0]) &&
-            IsString(schema.allOf[0].type) &&
-            schema.allOf[0].type === 'boolean' &&
-            schema.allOf[0].const === false &&
-            IsObject(schema.allOf[1]) &&
-            IsString(schema.allOf[1].type) &&
-            schema.allOf[1].type === 'boolean' &&
-            schema.allOf[1].const === true);
-    }
-    TypeGuard.TNever = TNever;
-    /** Returns true if the given schema is TNot */
-    function TNot(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Not' &&
-            IsArray(schema.allOf) &&
-            schema.allOf.length === 2 &&
-            IsObject(schema.allOf[0]) &&
-            TSchema(schema.allOf[0].not) &&
-            TSchema(schema.allOf[1]));
-    }
-    TypeGuard.TNot = TNot;
-    /** Returns true if the given schema is TNull */
-    function TNull(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Null' &&
-            schema.type === 'null' &&
-            IsOptionalString(schema.$id));
-    }
-    TypeGuard.TNull = TNull;
-    /** Returns true if the given schema is TNumber */
-    function TNumber(schema) {
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Number' &&
-            schema.type === 'number' &&
-            IsOptionalString(schema.$id) &&
-            IsOptionalNumber(schema.multipleOf) &&
-            IsOptionalNumber(schema.minimum) &&
-            IsOptionalNumber(schema.maximum) &&
-            IsOptionalNumber(schema.exclusiveMinimum) &&
-            IsOptionalNumber(schema.exclusiveMaximum));
-    }
-    TypeGuard.TNumber = TNumber;
-    /** Returns true if the given schema is TObject */
-    function TObject(schema) {
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Object' &&
-            schema.type === 'object' &&
-            IsOptionalString(schema.$id) &&
-            IsObject(schema.properties) &&
-            (IsOptionalBoolean(schema.additionalProperties) || IsOptionalSchema(schema.additionalProperties)) &&
-            IsOptionalNumber(schema.minProperties) &&
-            IsOptionalNumber(schema.maxProperties))) {
-            return false;
-        }
-        for (const [key, value] of Object.entries(schema.properties)) {
-            if (!IsControlCharacterFree(key))
-                return false;
-            if (!TSchema(value))
-                return false;
-        }
-        return true;
-    }
-    TypeGuard.TObject = TObject;
-    /** Returns true if the given schema is TPromise */
-    function TPromise(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Promise' &&
-            schema.type === 'object' &&
-            schema.instanceOf === 'Promise' &&
-            IsOptionalString(schema.$id) &&
-            TSchema(schema.item));
-    }
-    TypeGuard.TPromise = TPromise;
-    /** Returns true if the given schema is TRecord */
-    function TRecord(schema) {
-        // prettier-ignore
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Record' &&
-            schema.type === 'object' &&
-            IsOptionalString(schema.$id) &&
-            schema.additionalProperties === false &&
-            IsObject(schema.patternProperties))) {
-            return false;
-        }
-        const keys = Object.keys(schema.patternProperties);
-        if (keys.length !== 1) {
-            return false;
-        }
-        if (!IsPattern(keys[0])) {
-            return false;
-        }
-        if (!TSchema(schema.patternProperties[keys[0]])) {
-            return false;
-        }
-        return true;
-    }
-    TypeGuard.TRecord = TRecord;
-    /** Returns true if the given schema is TSelf */
-    function TSelf(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Self' &&
-            IsOptionalString(schema.$id) &&
-            IsString(schema.$ref));
-    }
-    TypeGuard.TSelf = TSelf;
-    /** Returns true if the given schema is TRef */
-    function TRef(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Ref' &&
-            IsOptionalString(schema.$id) &&
-            IsString(schema.$ref));
-    }
-    TypeGuard.TRef = TRef;
-    /** Returns true if the given schema is TString */
-    function TString(schema) {
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'String' &&
-            schema.type === 'string' &&
-            IsOptionalString(schema.$id) &&
-            IsOptionalNumber(schema.minLength) &&
-            IsOptionalNumber(schema.maxLength) &&
-            IsOptionalPattern(schema.pattern) &&
-            IsOptionalFormat(schema.format));
-    }
-    TypeGuard.TString = TString;
-    /** Returns true if the given schema is TSymbol */
-    function TSymbol(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Symbol' &&
-            schema.type === 'null' &&
-            schema.typeOf === 'Symbol' &&
-            IsOptionalString(schema.$id));
-    }
-    TypeGuard.TSymbol = TSymbol;
-    /** Returns true if the given schema is TTuple */
-    function TTuple(schema) {
-        // prettier-ignore
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Tuple' &&
-            schema.type === 'array' &&
-            IsOptionalString(schema.$id) &&
-            IsNumber(schema.minItems) &&
-            IsNumber(schema.maxItems) &&
-            schema.minItems === schema.maxItems)) {
-            return false;
-        }
-        if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
-            return true;
-        }
-        if (!IsArray(schema.items)) {
-            return false;
-        }
-        for (const inner of schema.items) {
-            if (!TSchema(inner))
-                return false;
-        }
-        return true;
-    }
-    TypeGuard.TTuple = TTuple;
-    /** Returns true if the given schema is TUndefined */
-    function TUndefined(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Undefined' &&
-            schema.type === 'null' &&
-            schema.typeOf === 'Undefined' &&
-            IsOptionalString(schema.$id));
-    }
-    TypeGuard.TUndefined = TUndefined;
-    /** Returns true if the given schema is TUnion */
-    function TUnion(schema) {
-        // prettier-ignore
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Union' &&
-            IsArray(schema.anyOf) &&
-            IsOptionalString(schema.$id))) {
-            return false;
-        }
-        for (const inner of schema.anyOf) {
-            if (!TSchema(inner))
-                return false;
-        }
-        return true;
-    }
-    TypeGuard.TUnion = TUnion;
-    /** Returns true if the given schema is TUnion<Literal<string>[]> */
-    function TUnionLiteral(schema) {
-        return TUnion(schema) && schema.anyOf.every((schema) => TLiteral(schema) && typeof schema.const === 'string');
-    }
-    TypeGuard.TUnionLiteral = TUnionLiteral;
-    /** Returns true if the given schema is TUint8Array */
-    function TUint8Array(schema) {
-        return TKind(schema) && schema[exports.Kind] === 'Uint8Array' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.instanceOf === 'Uint8Array' && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength);
-    }
-    TypeGuard.TUint8Array = TUint8Array;
-    /** Returns true if the given schema is TUnknown */
-    function TUnknown(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Unknown' &&
-            IsOptionalString(schema.$id));
-    }
-    TypeGuard.TUnknown = TUnknown;
-    /** Returns true if the given schema is TVoid */
-    function TVoid(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Void' &&
-            schema.type === 'null' &&
-            schema.typeOf === 'Void' &&
-            IsOptionalString(schema.$id));
-    }
-    TypeGuard.TVoid = TVoid;
-    /** Returns true if this schema has the ReadonlyOptional modifier */
-    function TReadonlyOptional(schema) {
-        return IsObject(schema) && schema[exports.Modifier] === 'ReadonlyOptional';
-    }
-    TypeGuard.TReadonlyOptional = TReadonlyOptional;
-    /** Returns true if this schema has the Readonly modifier */
-    function TReadonly(schema) {
-        return IsObject(schema) && schema[exports.Modifier] === 'Readonly';
-    }
-    TypeGuard.TReadonly = TReadonly;
-    /** Returns true if this schema has the Optional modifier */
-    function TOptional(schema) {
-        return IsObject(schema) && schema[exports.Modifier] === 'Optional';
-    }
-    TypeGuard.TOptional = TOptional;
-    /** Returns true if the given schema is TSchema */
-    function TSchema(schema) {
-        return (typeof schema === 'object' &&
-            (TAny(schema) ||
-                TArray(schema) ||
-                TBoolean(schema) ||
-                TBigInt(schema) ||
-                TConstructor(schema) ||
-                TDate(schema) ||
-                TFunction(schema) ||
-                TInteger(schema) ||
-                TIntersect(schema) ||
-                TLiteral(schema) ||
-                TNever(schema) ||
-                TNot(schema) ||
-                TNull(schema) ||
-                TNumber(schema) ||
-                TObject(schema) ||
-                TPromise(schema) ||
-                TRecord(schema) ||
-                TSelf(schema) ||
-                TRef(schema) ||
-                TString(schema) ||
-                TSymbol(schema) ||
-                TTuple(schema) ||
-                TUndefined(schema) ||
-                TUnion(schema) ||
-                TUint8Array(schema) ||
-                TUnknown(schema) ||
-                TVoid(schema) ||
-                (TKind(schema) && TypeRegistry.Has(schema[exports.Kind]))));
-    }
-    TypeGuard.TSchema = TSchema;
-})(TypeGuard = exports.TypeGuard || (exports.TypeGuard = {}));
-// -------------------------------------------------------------------------------------
-// ExtendsUndefined
-// -------------------------------------------------------------------------------------
-var ExtendsUndefined;
-(function (ExtendsUndefined) {
-    /** Fast undefined check for properties of type undefined */
-    function Check(schema) {
-        if (schema[exports.Kind] === 'Undefined')
-            return true;
-        if (schema[exports.Kind] === 'Union') {
-            const union = schema;
-            return union.anyOf.some((schema) => Check(schema));
-        }
-        return false;
-    }
-    ExtendsUndefined.Check = Check;
-})(ExtendsUndefined = exports.ExtendsUndefined || (exports.ExtendsUndefined = {}));
-// -------------------------------------------------------------------------------------
-// TypeExtends
-// -------------------------------------------------------------------------------------
-var TypeExtendsResult;
-(function (TypeExtendsResult) {
-    TypeExtendsResult[TypeExtendsResult["Union"] = 0] = "Union";
-    TypeExtendsResult[TypeExtendsResult["True"] = 1] = "True";
-    TypeExtendsResult[TypeExtendsResult["False"] = 2] = "False";
-})(TypeExtendsResult = exports.TypeExtendsResult || (exports.TypeExtendsResult = {}));
-var TypeExtends;
-(function (TypeExtends) {
-    // -----------------------------------------------------------------------------------
-    // IntoBooleanResult
-    // -----------------------------------------------------------------------------------
-    function IntoBooleanResult(result) {
-        return result === TypeExtendsResult.False ? TypeExtendsResult.False : TypeExtendsResult.True;
-    }
-    // -----------------------------------------------------------------------------------
-    // Any
-    // -----------------------------------------------------------------------------------
-    function AnyRight(left, right) {
-        return TypeExtendsResult.True;
-    }
-    function Any(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema)))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TUnion(right))
-            return TypeExtendsResult.Union;
-        if (TypeGuard.TUnknown(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TAny(right))
-            return TypeExtendsResult.True;
-        return TypeExtendsResult.Union;
-    }
-    // -----------------------------------------------------------------------------------
-    // Array
-    // -----------------------------------------------------------------------------------
-    function ArrayRight(left, right) {
-        if (TypeGuard.TUnknown(left))
-            return TypeExtendsResult.False;
-        if (TypeGuard.TAny(left))
-            return TypeExtendsResult.Union;
-        if (TypeGuard.TNever(left))
-            return TypeExtendsResult.True;
-        return TypeExtendsResult.False;
-    }
-    function Array(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right) && IsObjectArrayLike(right))
-            return TypeExtendsResult.True;
-        if (!TypeGuard.TArray(right))
-            return TypeExtendsResult.False;
-        return IntoBooleanResult(Visit(left.items, right.items));
-    }
-    // -----------------------------------------------------------------------------------
-    // BigInt
-    // -----------------------------------------------------------------------------------
-    function BigInt(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
-        return TypeGuard.TBigInt(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Boolean
-    // -----------------------------------------------------------------------------------
-    function BooleanRight(left, right) {
-        if (TypeGuard.TLiteral(left) && typeof left.const === 'boolean')
-            return TypeExtendsResult.True;
-        return TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    function Boolean(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
-        return TypeGuard.TBoolean(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Constructor
-    // -----------------------------------------------------------------------------------
-    function Constructor(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (!TypeGuard.TConstructor(right))
-            return TypeExtendsResult.False;
-        if (left.parameters.length > right.parameters.length)
-            return TypeExtendsResult.False;
-        if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
-            return TypeExtendsResult.False;
-        }
-        return IntoBooleanResult(Visit(left.returns, right.returns));
-    }
-    // -----------------------------------------------------------------------------------
-    // Date
-    // -----------------------------------------------------------------------------------
-    function Date(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
-        return TypeGuard.TDate(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Function
-    // -----------------------------------------------------------------------------------
-    function Function(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (!TypeGuard.TFunction(right))
-            return TypeExtendsResult.False;
-        if (left.parameters.length > right.parameters.length)
-            return TypeExtendsResult.False;
-        if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
-            return TypeExtendsResult.False;
-        }
-        return IntoBooleanResult(Visit(left.returns, right.returns));
-    }
-    // -----------------------------------------------------------------------------------
-    // Integer
-    // -----------------------------------------------------------------------------------
-    function IntegerRight(left, right) {
-        if (TypeGuard.TLiteral(left) && typeof left.const === 'number')
-            return TypeExtendsResult.True;
-        return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    function Integer(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
-        return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Intersect
-    // -----------------------------------------------------------------------------------
-    function IntersectRight(left, right) {
-        return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    function Intersect(left, right) {
-        return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Literal
-    // -----------------------------------------------------------------------------------
-    function IsLiteralString(schema) {
-        return typeof schema.const === 'string';
-    }
-    function IsLiteralNumber(schema) {
-        return typeof schema.const === 'number';
-    }
-    function IsLiteralBoolean(schema) {
-        return typeof schema.const === 'boolean';
-    }
-    function Literal(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
-        if (TypeGuard.TString(right))
-            return StringRight(left, right);
-        if (TypeGuard.TNumber(right))
-            return NumberRight(left, right);
-        if (TypeGuard.TInteger(right))
-            return IntegerRight(left, right);
-        if (TypeGuard.TBoolean(right))
-            return BooleanRight(left, right);
-        return TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Never
-    // -----------------------------------------------------------------------------------
-    function NeverRight(left, right) {
-        return TypeExtendsResult.False;
-    }
-    function Never(left, right) {
-        return TypeExtendsResult.True;
-    }
-    // -----------------------------------------------------------------------------------
-    // Null
-    // -----------------------------------------------------------------------------------
-    function Null(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
-        return TypeGuard.TNull(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Number
-    // -----------------------------------------------------------------------------------
-    function NumberRight(left, right) {
-        if (TypeGuard.TLiteral(left) && IsLiteralNumber(left))
-            return TypeExtendsResult.True;
-        return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    function Number(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
-        return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Object
-    // -----------------------------------------------------------------------------------
-    function IsObjectPropertyCount(schema, count) {
-        return globalThis.Object.keys(schema.properties).length === count;
-    }
-    function IsObjectStringLike(schema) {
-        return IsObjectArrayLike(schema);
-    }
-    function IsObjectSymbolLike(schema) {
-        // prettier-ignore
-        return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'description' in schema.properties && TypeGuard.TUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && ((TypeGuard.TString(schema.properties.description.anyOf[0]) &&
-            TypeGuard.TUndefined(schema.properties.description.anyOf[1])) || (TypeGuard.TString(schema.properties.description.anyOf[1]) &&
-            TypeGuard.TUndefined(schema.properties.description.anyOf[0]))));
-    }
-    function IsObjectNumberLike(schema) {
-        return IsObjectPropertyCount(schema, 0);
-    }
-    function IsObjectBooleanLike(schema) {
-        return IsObjectPropertyCount(schema, 0);
-    }
-    function IsObjectBigIntLike(schema) {
-        return IsObjectPropertyCount(schema, 0);
-    }
-    function IsObjectDateLike(schema) {
-        return IsObjectPropertyCount(schema, 0);
-    }
-    function IsObjectUint8ArrayLike(schema) {
-        return IsObjectArrayLike(schema);
-    }
-    function IsObjectFunctionLike(schema) {
-        const length = exports.Type.Number();
-        return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === TypeExtendsResult.True);
-    }
-    function IsObjectConstructorLike(schema) {
-        return IsObjectPropertyCount(schema, 0);
-    }
-    function IsObjectArrayLike(schema) {
-        const length = exports.Type.Number();
-        return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === TypeExtendsResult.True);
-    }
-    function IsObjectPromiseLike(schema) {
-        const then = exports.Type.Function([exports.Type.Any()], exports.Type.Any());
-        return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'then' in schema.properties && IntoBooleanResult(Visit(schema.properties['then'], then)) === TypeExtendsResult.True);
-    }
-    // -----------------------------------------------------------------------------------
-    // Property
-    // -----------------------------------------------------------------------------------
-    function Property(left, right) {
-        if (Visit(left, right) === TypeExtendsResult.False)
-            return TypeExtendsResult.False;
-        if (TypeGuard.TOptional(left) && !TypeGuard.TOptional(right))
-            return TypeExtendsResult.False;
-        return TypeExtendsResult.True;
-    }
-    function ObjectRight(left, right) {
-        if (TypeGuard.TUnknown(left))
-            return TypeExtendsResult.False;
-        if (TypeGuard.TAny(left))
-            return TypeExtendsResult.Union;
-        if (TypeGuard.TNever(left))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TLiteral(left) && IsLiteralString(left) && IsObjectStringLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TLiteral(left) && IsLiteralNumber(left) && IsObjectNumberLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TLiteral(left) && IsLiteralBoolean(left) && IsObjectBooleanLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TBigInt(left) && IsObjectBigIntLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TString(left) && IsObjectStringLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TNumber(left) && IsObjectNumberLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TInteger(left) && IsObjectNumberLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TBoolean(left) && IsObjectBooleanLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TDate(left) && IsObjectDateLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TConstructor(left) && IsObjectConstructorLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TFunction(left) && IsObjectFunctionLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left))) {
-            // When expressing a Record with literal key values, the Record is converted into a Object with
-            // the Hint assigned as `Record`. This is used to invert the extends logic.
-            return right[exports.Hint] === 'Record' ? TypeExtendsResult.True : TypeExtendsResult.False;
-        }
-        if (TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left))) {
-            return IsObjectPropertyCount(right, 0) ? TypeExtendsResult.True : TypeExtendsResult.False;
-        }
-        return TypeExtendsResult.False;
-    }
-    function Object(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
-        if (!TypeGuard.TObject(right))
-            return TypeExtendsResult.False;
-        for (const key of globalThis.Object.keys(right.properties)) {
-            if (!(key in left.properties))
-                return TypeExtendsResult.False;
-            if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
-                return TypeExtendsResult.False;
-            }
-        }
-        return TypeExtendsResult.True;
-    }
-    // -----------------------------------------------------------------------------------
-    // Promise
-    // -----------------------------------------------------------------------------------
-    function Promise(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right) && IsObjectPromiseLike(right))
-            return TypeExtendsResult.True;
-        if (!TypeGuard.TPromise(right))
-            return TypeExtendsResult.False;
-        return IntoBooleanResult(Visit(left.item, right.item));
-    }
-    // -----------------------------------------------------------------------------------
-    // Record
-    // -----------------------------------------------------------------------------------
-    function RecordKey(schema) {
-        if ('^(0|[1-9][0-9]*)$' in schema.patternProperties)
-            return exports.Type.Number();
-        if ('^.*$' in schema.patternProperties)
-            return exports.Type.String();
-        throw Error('TypeExtends: Cannot get record key');
-    }
-    function RecordValue(schema) {
-        if ('^(0|[1-9][0-9]*)$' in schema.patternProperties)
-            return schema.patternProperties['^(0|[1-9][0-9]*)$'];
-        if ('^.*$' in schema.patternProperties)
-            return schema.patternProperties['^.*$'];
-        throw Error('TypeExtends: Cannot get record value');
-    }
-    function RecordRight(left, right) {
-        const Key = RecordKey(right);
-        const Value = RecordValue(right);
-        if (TypeGuard.TLiteral(left) && IsLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True)
-            return TypeExtendsResult.True;
-        if (TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key))
-            return Visit(left, Value);
-        if (TypeGuard.TString(left) && TypeGuard.TNumber(Key))
-            return Visit(left, Value);
-        if (TypeGuard.TArray(left) && TypeGuard.TNumber(Key))
-            return Visit(left, Value);
-        if (TypeGuard.TObject(left)) {
-            for (const key of globalThis.Object.keys(left.properties)) {
-                if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
-                    return TypeExtendsResult.False;
-                }
-            }
-            return TypeExtendsResult.True;
-        }
-        return TypeExtendsResult.False;
-    }
-    function Record(left, right) {
-        const Value = RecordValue(left);
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (!TypeGuard.TRecord(right))
-            return TypeExtendsResult.False;
-        return Visit(Value, RecordValue(right));
-    }
-    // -----------------------------------------------------------------------------------
-    // String
-    // -----------------------------------------------------------------------------------
-    function StringRight(left, right) {
-        if (TypeGuard.TLiteral(left) && typeof left.const === 'string')
-            return TypeExtendsResult.True;
-        return TypeGuard.TString(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    function String(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
-        return TypeGuard.TString(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Symbol
-    // -----------------------------------------------------------------------------------
-    function Symbol(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
-        return TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Tuple
-    // -----------------------------------------------------------------------------------
-    function TupleRight(left, right) {
-        if (TypeGuard.TUnknown(left))
-            return TypeExtendsResult.False;
-        if (TypeGuard.TAny(left))
-            return TypeExtendsResult.Union;
-        if (TypeGuard.TNever(left))
-            return TypeExtendsResult.True;
-        return TypeExtendsResult.False;
-    }
-    function IsArrayOfTuple(left, right) {
-        return TypeGuard.TArray(right) && left.items !== undefined && left.items.every((schema) => Visit(schema, right.items) === TypeExtendsResult.True);
-    }
-    function Tuple(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right) && IsObjectArrayLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TArray(right) && IsArrayOfTuple(left, right))
-            return TypeExtendsResult.True;
-        if (!TypeGuard.TTuple(right))
-            return TypeExtendsResult.False;
-        if ((left.items === undefined && right.items !== undefined) || (left.items !== undefined && right.items === undefined))
-            return TypeExtendsResult.False;
-        if (left.items === undefined && right.items === undefined)
-            return TypeExtendsResult.True;
-        return left.items.every((schema, index) => Visit(schema, right.items[index]) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Uint8Array
-    // -----------------------------------------------------------------------------------
-    function Uint8Array(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
-        return TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Undefined
-    // -----------------------------------------------------------------------------------
-    function Undefined(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
-        if (TypeGuard.TVoid(right))
-            return VoidRight(left, right);
-        return TypeGuard.TUndefined(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Union
-    // -----------------------------------------------------------------------------------
-    function UnionRight(left, right) {
-        return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    function Union(left, right) {
-        return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Unknown
-    // -----------------------------------------------------------------------------------
-    function UnknownRight(left, right) {
-        return TypeExtendsResult.True;
-    }
-    function Unknown(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TString(right))
-            return StringRight(left, right);
-        if (TypeGuard.TNumber(right))
-            return NumberRight(left, right);
-        if (TypeGuard.TInteger(right))
-            return IntegerRight(left, right);
-        if (TypeGuard.TBoolean(right))
-            return BooleanRight(left, right);
-        if (TypeGuard.TArray(right))
-            return ArrayRight(left, right);
-        if (TypeGuard.TTuple(right))
-            return TupleRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        return TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    // -----------------------------------------------------------------------------------
-    // Void
-    // -----------------------------------------------------------------------------------
-    function VoidRight(left, right) {
-        if (TypeGuard.TUndefined(left))
-            return TypeExtendsResult.True;
-        return TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    function Void(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
-        if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
-        return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
-    }
-    function Visit(left, right) {
-        const right_ = ReferenceRegistry.Deref(right);
-        const left_ = ReferenceRegistry.Deref(left);
-        if (TypeGuard.TAny(left_))
-            return Any(left_, right_);
-        if (TypeGuard.TArray(left_))
-            return Array(left_, right_);
-        if (TypeGuard.TBigInt(left_))
-            return BigInt(left_, right_);
-        if (TypeGuard.TBoolean(left_))
-            return Boolean(left_, right_);
-        if (TypeGuard.TConstructor(left_))
-            return Constructor(left_, right_);
-        if (TypeGuard.TDate(left_))
-            return Date(left_, right_);
-        if (TypeGuard.TFunction(left_))
-            return Function(left_, right_);
-        if (TypeGuard.TInteger(left_))
-            return Integer(left_, right_);
-        if (TypeGuard.TIntersect(left_))
-            return Intersect(left_, right_);
-        if (TypeGuard.TLiteral(left_))
-            return Literal(left_, right_);
-        if (TypeGuard.TNever(left_))
-            return Never(left_, right_);
-        if (TypeGuard.TNull(left_))
-            return Null(left_, right_);
-        if (TypeGuard.TNumber(left_))
-            return Number(left_, right_);
-        if (TypeGuard.TRecord(left_))
-            return Record(left_, right_);
-        if (TypeGuard.TString(left_))
-            return String(left_, right_);
-        if (TypeGuard.TSymbol(left_))
-            return Symbol(left_, right_);
-        if (TypeGuard.TObject(left_))
-            return Object(left_, right_);
-        if (TypeGuard.TTuple(left_))
-            return Tuple(left_, right_);
-        if (TypeGuard.TPromise(left_))
-            return Promise(left_, right_);
-        if (TypeGuard.TUint8Array(left_))
-            return Uint8Array(left_, right_);
-        if (TypeGuard.TUndefined(left_))
-            return Undefined(left_, right_);
-        if (TypeGuard.TUnion(left_))
-            return Union(left_, right_);
-        if (TypeGuard.TUnknown(left_))
-            return Unknown(left_, right_);
-        if (TypeGuard.TVoid(left_))
-            return Void(left_, right_);
-        throw Error(`TypeExtends: Unknown left operand '${left[exports.Kind]}'`);
-    }
-    function Extends(left, right) {
-        return Visit(left, right);
-    }
-    TypeExtends.Extends = Extends;
-})(TypeExtends = exports.TypeExtends || (exports.TypeExtends = {}));
-// -------------------------------------------------------------------------------------
-// TypeClone
-// -------------------------------------------------------------------------------------
-/** Specialized Clone for Types. */
-var TypeClone;
-(function (TypeClone) {
-    function IsObject(value) {
-        return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value);
-    }
-    function IsArray(value) {
-        return globalThis.Array.isArray(value);
-    }
-    function Array(value) {
-        return value.map((value) => Visit(value));
-    }
-    function Object(value) {
-        const clone = globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), globalThis.Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {}));
-        return clone;
-    }
-    function Visit(value) {
-        if (IsObject(value))
-            delete value['$id'];
-        if (IsObject(value))
-            return Object({ ...value });
-        if (IsArray(value))
-            return Array([...value]);
-        return value;
-    }
-    function Clone(schema, options) {
-        return { ...Visit({ ...schema }), ...options };
-    }
-    TypeClone.Clone = Clone;
-})(TypeClone = exports.TypeClone || (exports.TypeClone = {}));
-// -------------------------------------------------------------------------------------
-// ObjectMap
-// -------------------------------------------------------------------------------------
-var ObjectMap;
-(function (ObjectMap) {
-    function Intersect(schema, callback) {
-        return exports.Type.Intersect(schema.allOf.map((inner) => Visit(ReferenceRegistry.Deref(inner), callback)), { ...schema });
-    }
-    function Union(schema, callback) {
-        return exports.Type.Union(schema.anyOf.map((inner) => Visit(ReferenceRegistry.Deref(inner), callback)), { ...schema });
-    }
-    function Object(schema, callback) {
-        return callback(schema);
-    }
-    function Visit(schema, callback) {
-        if (TypeGuard.TIntersect(schema))
-            return Intersect(schema, callback);
-        if (TypeGuard.TUnion(schema))
-            return Union(schema, callback);
-        if (TypeGuard.TObject(schema))
-            return Object(schema, callback);
-        return schema;
-    }
-    function Map(schema, callback, options) {
-        return { ...Visit(TypeClone.Clone(schema, {}), callback), ...options };
-    }
-    ObjectMap.Map = Map;
-})(ObjectMap = exports.ObjectMap || (exports.ObjectMap = {}));
-// -------------------------------------------------------------------------------------
-// KeyResolver
-// -------------------------------------------------------------------------------------
-var KeyResolver;
-(function (KeyResolver) {
-    function IsKeyable(schema) {
-        return TypeGuard.TIntersect(schema) || TypeGuard.TUnion(schema) || TypeGuard.TObject(schema);
-    }
-    function Intersect(schema) {
-        return [...schema.allOf.filter((schema) => IsKeyable(schema)).reduce((set, schema) => Visit(schema).map((key) => set.add(key))[0], new Set())];
-    }
-    function Union(schema) {
-        const sets = schema.anyOf.filter((schema) => IsKeyable(schema)).map((inner) => Visit(inner));
-        return [...sets.reduce((set, outer) => outer.map((key) => (sets.every((inner) => inner.includes(key)) ? set.add(key) : set))[0], new Set())];
-    }
-    function Object(schema) {
-        return globalThis.Object.keys(schema.properties);
-    }
-    function Visit(schema) {
-        if (TypeGuard.TIntersect(schema))
-            return Intersect(schema);
-        if (TypeGuard.TUnion(schema))
-            return Union(schema);
-        if (TypeGuard.TObject(schema))
-            return Object(schema);
-        return [];
-    }
-    function Resolve(schema) {
-        return Visit(schema);
-    }
-    KeyResolver.Resolve = Resolve;
-})(KeyResolver = exports.KeyResolver || (exports.KeyResolver = {}));
-// -------------------------------------------------------------------------------------
-// TypeOrdinal: Used for auto $id generation
-// -------------------------------------------------------------------------------------
-let TypeOrdinal = 0;
-// -------------------------------------------------------------------------------------
-// TypeBuilder
-// -------------------------------------------------------------------------------------
-class TypeBuilder {
-    /** `[Utility]` Creates a schema without `static` and `params` types */
-    Create(schema) {
-        ReferenceRegistry.Set(schema);
-        return schema;
-    }
-    /** `[Utility]` Clones a schema or properties object */
-    Clone(schema, options = {}) {
-        const clone = TypeClone.Clone(schema, options);
-        ReferenceRegistry.Set(clone);
-        return clone;
-    }
-    /** `[Standard]` Omits compositing symbols from this schema */
-    Strict(schema) {
-        return JSON.parse(JSON.stringify(schema));
-    }
-}
-exports.TypeBuilder = TypeBuilder;
-// -------------------------------------------------------------------------------------
-// StandardTypeBuilder
-// -------------------------------------------------------------------------------------
-class StandardTypeBuilder extends TypeBuilder {
-    // ----------------------------------------------------------------------
-    // Modifiers
-    // ----------------------------------------------------------------------
-    /** `[Modifier]` Creates a Optional property */
-    Optional(schema) {
-        return { [exports.Modifier]: 'Optional', ...this.Clone(schema, {}) };
-    }
-    /** `[Modifier]` Creates a ReadonlyOptional property */
-    ReadonlyOptional(schema) {
-        return { [exports.Modifier]: 'ReadonlyOptional', ...this.Clone(schema, {}) };
-    }
-    /** `[Modifier]` Creates a Readonly object or property */
-    Readonly(schema) {
-        return { [exports.Modifier]: 'Readonly', ...schema };
-    }
-    // ----------------------------------------------------------------------
-    // Types
-    // ----------------------------------------------------------------------
-    /** `[Standard]` Creates an Any type */
-    Any(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Any' });
-    }
-    /** `[Standard]` Creates an Array type */
-    Array(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items });
-    }
-    /** `[Standard]` Creates a Boolean type */
-    Boolean(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
-    }
-    /** `[Standard]` Creates a Composite object type that will Union any overlapping properties of the given Object array */
-    Composite(schemas, options = {}) {
-        const optional = new Set();
-        for (const schema of schemas) {
-            for (const [key, property] of globalThis.Object.entries(schema.properties)) {
-                if (TypeGuard.TOptional(property) || TypeGuard.TReadonlyOptional(property))
-                    optional.add(key);
-            }
-        }
-        const properties = {};
-        for (const object of schemas) {
-            for (const [key, property] of globalThis.Object.entries(object.properties)) {
-                const mapped = key in properties ? this.Union([properties[key], property]) : property;
-                properties[key] = optional.has(key) ? this.Optional(mapped) : mapped;
-            }
-        }
-        return this.Object(properties, options);
-    }
-    /** `[Standard]` Dereferences the given TRef to its target type */
-    Deref(schema) {
-        return ReferenceRegistry.Deref(schema);
-    }
-    /** `[Standard]` Creates a Enum type */
-    Enum(item, options = {}) {
-        // prettier-ignore
-        const values = globalThis.Object.keys(item).filter((key) => isNaN(key)).map((key) => item[key]);
-        const anyOf = values.map((value) => (typeof value === 'string' ? { [exports.Kind]: 'Literal', type: 'string', const: value } : { [exports.Kind]: 'Literal', type: 'number', const: value }));
-        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf });
-    }
-    /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
-    Extends(left, right, trueType, falseType, options = {}) {
-        switch (TypeExtends.Extends(ReferenceRegistry.Deref(left), ReferenceRegistry.Deref(right))) {
-            case TypeExtendsResult.Union:
-                return this.Union([this.Clone(trueType, options), this.Clone(falseType, options)]);
-            case TypeExtendsResult.True:
-                return this.Clone(trueType, options);
-            case TypeExtendsResult.False:
-                return this.Clone(falseType, options);
-        }
-    }
-    /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
-    Exclude(left, right, options = {}) {
-        if (TypeGuard.TUnion(left)) {
-            const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) === TypeExtendsResult.False);
-            return (narrowed.length === 1 ? this.Clone(narrowed[0], options) : this.Union(narrowed, options));
-        }
-        else {
-            return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : this.Clone(left, options));
-        }
-    }
-    /** `[Standard]` Extracts from left left any type that is assignable to the right */
-    Extract(left, right, options = {}) {
-        if (TypeGuard.TUnion(left)) {
-            const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False);
-            return (narrowed.length === 1 ? this.Clone(narrowed[0], options) : this.Union(narrowed, options));
-        }
-        else {
-            return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Clone(left, options) : this.Never(options));
-        }
-    }
-    /** `[Standard]` Creates an Integer type */
-    Integer(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Integer', type: 'integer' });
-    }
-    Intersect(allOf, options = {}) {
-        if (allOf.length === 0)
-            return exports.Type.Never();
-        if (allOf.length === 1)
-            return this.Clone(allOf[0], options);
-        const objects = allOf.every((schema) => TypeGuard.TObject(schema));
-        const cloned = allOf.map((schema) => this.Clone(schema, {}));
-        if (options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects) {
-            return this.Create({ ...options, [exports.Kind]: 'Intersect', type: 'object', allOf: cloned });
-        }
-        else {
-            return this.Create({ ...options, [exports.Kind]: 'Intersect', allOf: cloned });
-        }
-    }
-    /** `[Standard]` Creates a KeyOf type */
-    KeyOf(schema, options = {}) {
-        const keys = KeyResolver.Resolve(ReferenceRegistry.Deref(schema));
-        // prettier-ignore
-        const keyof = keys.length === 0 ? this.Never(options) : this.Union(keys.map((key) => this.Literal(key)), options);
-        return keyof;
-    }
-    /** `[Standard]` Creates a Literal type */
-    Literal(value, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Literal', const: value, type: typeof value });
-    }
-    /** `[Standard]` Creates a Never type */
-    Never(options = {}) {
-        // prettier-ignore
-        return this.Create({ ...options, [exports.Kind]: 'Never', allOf: [
-                { type: 'boolean', const: false },
-                { type: 'boolean', const: true },
-            ] });
-    }
-    /** `[Standard]` Creates a Not type. The first argument is the disallowed type, the second is the allowed. */
-    Not(not, schema, options) {
-        return this.Create({ ...options, [exports.Kind]: 'Not', allOf: [{ not }, schema] });
-    }
-    /** `[Standard]` Creates a Null type */
-    Null(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Null', type: 'null' });
-    }
-    /** `[Standard]` Creates a Number type */
-    Number(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Number', type: 'number' });
-    }
-    /** `[Standard]` Creates an Object type */
-    Object(properties, options = {}) {
-        const keys = globalThis.Object.keys(properties);
-        const optional = keys.filter((key) => TypeGuard.TOptional(properties[key]) || TypeGuard.TReadonlyOptional(properties[key]));
-        const required = keys.filter((name) => !optional.includes(name));
-        if (required.length > 0) {
-            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties: this.Clone(properties, {}), required });
-        }
-        else {
-            return this.Create({ ...options, [exports.Kind]: 'Object', type: 'object', properties: this.Clone(properties, {}) });
-        }
-    }
-    Omit(schema, unresolved, options = {}) {
-        const keys = TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema) => schema.const) : unresolved;
-        // prettier-ignore
-        return ObjectMap.Map(this.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
-            if (schema.required) {
-                schema.required = schema.required.filter((key) => !keys.includes(key));
-                if (schema.required.length === 0)
-                    delete schema.required;
-            }
-            for (const key of globalThis.Object.keys(schema.properties)) {
-                if (keys.includes(key))
-                    delete schema.properties[key];
-            }
-            return this.Create(schema);
-        }, options);
-    }
-    /** `[Standard]` Creates a mapped type where all properties are Optional */
-    Partial(schema, options = {}) {
-        function Apply(schema) {
-            // prettier-ignore
-            switch (schema[exports.Modifier]) {
-                case 'ReadonlyOptional':
-                    schema[exports.Modifier] = 'ReadonlyOptional';
-                    break;
-                case 'Readonly':
-                    schema[exports.Modifier] = 'ReadonlyOptional';
-                    break;
-                case 'Optional':
-                    schema[exports.Modifier] = 'Optional';
-                    break;
-                default:
-                    schema[exports.Modifier] = 'Optional';
-                    break;
-            }
-        }
-        // prettier-ignore
-        return ObjectMap.Map(this.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
-            delete schema.required;
-            globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]));
-            return schema;
-        }, options);
-    }
-    Pick(schema, unresolved, options = {}) {
-        const keys = TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema) => schema.const) : unresolved;
-        // prettier-ignore
-        return ObjectMap.Map(this.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
-            if (schema.required) {
-                schema.required = schema.required.filter((key) => keys.includes(key));
-                if (schema.required.length === 0)
-                    delete schema.required;
-            }
-            for (const key of globalThis.Object.keys(schema.properties)) {
-                if (!keys.includes(key))
-                    delete schema.properties[key];
-            }
-            return this.Create(schema);
-        }, options);
-    }
-    Record(key, schema, options = {}) {
-        if (TypeGuard.TLiteral(key)) {
-            if (typeof key.const === 'string' || typeof key.const === 'number') {
-                return this.Object({ [key.const]: schema }, options);
-            }
-            else
-                throw Error('TypeBuilder: Record key can only be derived from literals of number or string');
-        }
-        if (TypeGuard.TUnion(key)) {
-            if (key.anyOf.every((schema) => TypeGuard.TLiteral(schema) && (typeof schema.const === 'string' || typeof schema.const === 'number'))) {
-                const properties = key.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: this.Clone(schema, {}) }), {});
-                return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
-            }
-            else
-                throw Error('TypeBuilder: Record key can only be derived from union literal of number or string');
-        }
-        const pattern = ['Integer', 'Number'].includes(key[exports.Kind]) ? '^(0|[1-9][0-9]*)$' : key[exports.Kind] === 'String' && key.pattern ? key.pattern : '^.*$';
-        return this.Create({
-            ...options,
-            [exports.Kind]: 'Record',
-            type: 'object',
-            patternProperties: { [pattern]: schema },
-            additionalProperties: false,
-        });
-    }
-    /** `[Standard]` Creates a Recursive type */
-    Recursive(callback, options = {}) {
-        if (options.$id === undefined)
-            options.$id = `T${TypeOrdinal++}`;
-        const self = callback({ [exports.Kind]: 'Self', $ref: `${options.$id}` });
-        const reassign = self;
-        reassign.$id = options.$id; // required as $id is readonly
-        return this.Create({ ...options, ...self });
-    }
-    /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
-    Ref(schema, options = {}) {
-        if (schema.$id === undefined)
-            throw Error('TypeBuilder.Ref: Referenced schema must specify an $id');
-        return this.Create({ ...options, [exports.Kind]: 'Ref', $ref: schema.$id });
-    }
-    /** `[Standard]` Creates a mapped type where all properties are Required */
-    Required(schema, options = {}) {
-        function Apply(schema) {
-            // prettier-ignore
-            switch (schema[exports.Modifier]) {
-                case 'ReadonlyOptional':
-                    schema[exports.Modifier] = 'Readonly';
-                    break;
-                case 'Readonly':
-                    schema[exports.Modifier] = 'Readonly';
-                    break;
-                case 'Optional':
-                    delete schema[exports.Modifier];
-                    break;
-                default:
-                    delete schema[exports.Modifier];
-                    break;
-            }
-        }
-        // prettier-ignore
-        return ObjectMap.Map(this.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
-            schema.required = globalThis.Object.keys(schema.properties);
-            globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]));
-            return schema;
-        }, options);
-    }
-    /** `[Standard]` Creates a String type */
-    String(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'String', type: 'string' });
-    }
-    /** `[Standard]` Creates a Tuple type */
-    Tuple(items, options = {}) {
-        const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
-        // prettier-ignore
-        const schema = (items.length > 0 ?
-            { ...options, [exports.Kind]: 'Tuple', type: 'array', items, additionalItems, minItems, maxItems } :
-            { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
-        return this.Create(schema);
-    }
-    Union(anyOf, options = {}) {
-        if (anyOf.length === 0)
-            return this.Never(options);
-        if (anyOf.length === 1)
-            return this.Clone(anyOf[0], options);
-        const cloned = anyOf.map((schema) => this.Clone(schema, {}));
-        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: cloned });
-    }
-    /** `[Standard]` Creates an Unknown type */
-    Unknown(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Unknown' });
-    }
-    /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
-    Unsafe(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || 'Unsafe' });
-    }
-}
-exports.StandardTypeBuilder = StandardTypeBuilder;
-// -------------------------------------------------------------------------------------
-// TypeBuilder
-// -------------------------------------------------------------------------------------
-class ExtendedTypeBuilder extends StandardTypeBuilder {
-    /** `[Extended]` Creates a BigInt type */
-    BigInt(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'BigInt', type: 'null', typeOf: 'BigInt' });
-    }
-    /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters(schema, options = {}) {
-        return this.Tuple([...schema.parameters], { ...options });
-    }
-    Constructor(parameters, returns, options = {}) {
-        if (parameters[exports.Kind] === 'Tuple') {
-            const inner = parameters.items === undefined ? [] : parameters.items;
-            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: inner, returns });
-        }
-        else if (globalThis.Array.isArray(parameters)) {
-            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters, returns });
-        }
-        else {
-            throw new Error('TypeBuilder.Constructor: Invalid parameters');
-        }
-    }
-    /** `[Extended]` Creates a Date type */
-    Date(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Date', type: 'object', instanceOf: 'Date' });
-    }
-    Function(parameters, returns, options = {}) {
-        if (parameters[exports.Kind] === 'Tuple') {
-            const inner = parameters.items === undefined ? [] : parameters.items;
-            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: inner, returns });
-        }
-        else if (globalThis.Array.isArray(parameters)) {
-            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters, returns });
-        }
-        else {
-            throw new Error('TypeBuilder.Function: Invalid parameters');
-        }
-    }
-    /** `[Extended]` Extracts the InstanceType from the given Constructor */
-    InstanceType(schema, options = {}) {
-        return this.Clone(schema.returns, options);
-    }
-    /** `[Extended]` Extracts the Parameters from the given Function type */
-    Parameters(schema, options = {}) {
-        return this.Tuple(schema.parameters, { ...options });
-    }
-    /** `[Extended]` Creates a Promise type */
-    Promise(item, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'object', instanceOf: 'Promise', item });
-    }
-    /** `[Extended]` Creates a regular expression type */
-    RegEx(regex, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'String', type: 'string', pattern: regex.source });
-    }
-    /** `[Extended]` Extracts the ReturnType from the given Function */
-    ReturnType(schema, options = {}) {
-        return this.Clone(schema.returns, options);
-    }
-    /** `[Extended]` Creates a Symbol type */
-    Symbol(options) {
-        return this.Create({ ...options, [exports.Kind]: 'Symbol', type: 'null', typeOf: 'Symbol' });
-    }
-    /** `[Extended]` Creates a Undefined type */
-    Undefined(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Undefined', type: 'null', typeOf: 'Undefined' });
-    }
-    /** `[Extended]` Creates a Uint8Array type */
-    Uint8Array(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Uint8Array', type: 'object', instanceOf: 'Uint8Array' });
-    }
-    /** `[Extended]` Creates a Void type */
-    Void(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Void', type: 'null', typeOf: 'Void' });
-    }
-}
-exports.ExtendedTypeBuilder = ExtendedTypeBuilder;
-/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
-exports.StandardType = new StandardTypeBuilder();
-/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
-exports.Type = new ExtendedTypeBuilder();
+"use strict";
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox
+
+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.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.KeyResolver = exports.ObjectMap = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.ReferenceRegistry = exports.TypeRegistry = exports.Kind = exports.Hint = exports.Modifier = exports.Recursive = void 0;
+// --------------------------------------------------------------------------
+// Compositing Symbols
+// --------------------------------------------------------------------------
+exports.Recursive = Symbol.for('TypeBox.Recursive');
+exports.Modifier = Symbol.for('TypeBox.Modifier');
+exports.Hint = Symbol.for('TypeBox.Hint');
+exports.Kind = Symbol.for('TypeBox.Kind');
+var TypeRegistry;
+(function (TypeRegistry) {
+    const types = new Map();
+    /** Clears all user defined types */
+    function Clear() {
+        return types.clear();
+    }
+    TypeRegistry.Clear = Clear;
+    /** Returns true if this registry contains this kind */
+    function Has(kind) {
+        return types.has(kind);
+    }
+    TypeRegistry.Has = Has;
+    /** Sets a validation function for a user defined type */
+    function Set(kind, func) {
+        types.set(kind, func);
+    }
+    TypeRegistry.Set = Set;
+    /** Gets a custom validation function for a user defined type */
+    function Get(kind) {
+        return types.get(kind);
+    }
+    TypeRegistry.Get = Get;
+})(TypeRegistry = exports.TypeRegistry || (exports.TypeRegistry = {}));
+// --------------------------------------------------------------------------
+// ReferenceRegistry
+// --------------------------------------------------------------------------
+var ReferenceRegistry;
+(function (ReferenceRegistry) {
+    const references = new Map();
+    /** Clears the reference registry */
+    function Clear() {
+        return references.clear();
+    }
+    ReferenceRegistry.Clear = Clear;
+    /** Returns true if this registry contains this schema */
+    function Has(schema) {
+        return references.has(schema.$id);
+    }
+    ReferenceRegistry.Has = Has;
+    /** Sets this schema on this registry if a $id exists */
+    function Set(schema) {
+        const $id = typeof schema === 'object' && schema !== null && typeof schema['$id'] === 'string' ? schema['$id'] : undefined;
+        if ($id !== undefined)
+            references.set($id, schema);
+    }
+    ReferenceRegistry.Set = Set;
+    /** Dereferences the schema one level deep */
+    function DerefOne(schema) {
+        if (TypeGuard.TRef(schema) || TypeGuard.TSelf(schema)) {
+            if (!references.has(schema.$ref))
+                throw Error(`ReferenceRegistry: Cannot deref schema with $id '${schema.$ref}'`);
+            return references.get(schema.$ref);
+        }
+        else {
+            return schema;
+        }
+    }
+    ReferenceRegistry.DerefOne = DerefOne;
+    /** Dereferences the schema recursively */
+    function Deref(schema) {
+        if (TypeGuard.TRef(schema)) {
+            return Deref(DerefOne(schema));
+        }
+        else {
+            return schema;
+        }
+    }
+    ReferenceRegistry.Deref = Deref;
+})(ReferenceRegistry = exports.ReferenceRegistry || (exports.ReferenceRegistry = {}));
+/** Provides functions to create user defined string formats */
+var FormatRegistry;
+(function (FormatRegistry) {
+    const formats = new Map();
+    /** Clears all user defined string formats */
+    function Clear() {
+        return formats.clear();
+    }
+    FormatRegistry.Clear = Clear;
+    /** Returns true if the user defined string format exists */
+    function Has(format) {
+        return formats.has(format);
+    }
+    FormatRegistry.Has = Has;
+    /** Sets a validation function for a user defined string format */
+    function Set(format, func) {
+        formats.set(format, func);
+    }
+    FormatRegistry.Set = Set;
+    /** Gets a validation function for a user defined string format */
+    function Get(format) {
+        return formats.get(format);
+    }
+    FormatRegistry.Get = Get;
+})(FormatRegistry = exports.FormatRegistry || (exports.FormatRegistry = {}));
+// --------------------------------------------------------------------------
+// TypeGuard
+// --------------------------------------------------------------------------
+class TypeGuardUnknownTypeError extends Error {
+    constructor(schema) {
+        super('TypeGuard: Unknown type');
+        this.schema = schema;
+    }
+}
+exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
+var TypeGuard;
+(function (TypeGuard) {
+    function IsObject(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+    function IsArray(value) {
+        return typeof value === 'object' && value !== null && Array.isArray(value);
+    }
+    function IsPattern(value) {
+        try {
+            new RegExp(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    function IsControlCharacterFree(value) {
+        if (typeof value !== 'string')
+            return false;
+        for (let i = 0; i < value.length; i++) {
+            const code = value.charCodeAt(i);
+            if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    function IsNumber(value) {
+        return typeof value === 'number' && globalThis.Number.isFinite(value);
+    }
+    function IsBoolean(value) {
+        return typeof value === 'boolean';
+    }
+    function IsOptionalBigInt(value) {
+        return value === undefined || (value !== undefined && IsBigInt(value));
+    }
+    function IsOptionalNumber(value) {
+        return value === undefined || (value !== undefined && IsNumber(value));
+    }
+    function IsOptionalBoolean(value) {
+        return value === undefined || (value !== undefined && IsBoolean(value));
+    }
+    function IsOptionalString(value) {
+        return value === undefined || (value !== undefined && IsString(value));
+    }
+    function IsOptionalPattern(value) {
+        return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value) && IsPattern(value));
+    }
+    function IsOptionalFormat(value) {
+        return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value));
+    }
+    function IsOptionalSchema(value) {
+        return value === undefined || TSchema(value);
+    }
+    /** Returns true if the given schema is TAny */
+    function TAny(schema) {
+        return TKind(schema) && schema[exports.Kind] === 'Any' && IsOptionalString(schema.$id);
+    }
+    TypeGuard.TAny = TAny;
+    /** Returns true if the given schema is TArray */
+    function TArray(schema) {
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Array' &&
+            schema.type === 'array' &&
+            IsOptionalString(schema.$id) &&
+            TSchema(schema.items) &&
+            IsOptionalNumber(schema.minItems) &&
+            IsOptionalNumber(schema.maxItems) &&
+            IsOptionalBoolean(schema.uniqueItems));
+    }
+    TypeGuard.TArray = TArray;
+    /** Returns true if the given schema is TSymbol */
+    function TBigInt(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'BigInt' &&
+            schema.type === 'null' &&
+            schema.typeOf === 'BigInt' &&
+            IsOptionalString(schema.$id) &&
+            IsOptionalBigInt(schema.multipleOf) &&
+            IsOptionalBigInt(schema.minimum) &&
+            IsOptionalBigInt(schema.maximum) &&
+            IsOptionalBigInt(schema.exclusiveMinimum) &&
+            IsOptionalBigInt(schema.exclusiveMaximum));
+    }
+    TypeGuard.TBigInt = TBigInt;
+    /** Returns true if the given schema is TBoolean */
+    function TBoolean(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Boolean' &&
+            schema.type === 'boolean' &&
+            IsOptionalString(schema.$id));
+    }
+    TypeGuard.TBoolean = TBoolean;
+    /** Returns true if the given schema is TConstructor */
+    function TConstructor(schema) {
+        // prettier-ignore
+        if (!(TKind(schema) &&
+            schema[exports.Kind] === 'Constructor' &&
+            schema.type === 'object' &&
+            schema.instanceOf === 'Constructor' &&
+            IsOptionalString(schema.$id) &&
+            IsArray(schema.parameters) &&
+            TSchema(schema.returns))) {
+            return false;
+        }
+        for (const parameter of schema.parameters) {
+            if (!TSchema(parameter))
+                return false;
+        }
+        return true;
+    }
+    TypeGuard.TConstructor = TConstructor;
+    /** Returns true if the given schema is TDate */
+    function TDate(schema) {
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Date' &&
+            schema.type === 'object' &&
+            schema.instanceOf === 'Date' &&
+            IsOptionalString(schema.$id) &&
+            IsOptionalNumber(schema.minimumTimestamp) &&
+            IsOptionalNumber(schema.maximumTimestamp) &&
+            IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
+            IsOptionalNumber(schema.exclusiveMaximumTimestamp));
+    }
+    TypeGuard.TDate = TDate;
+    /** Returns true if the given schema is TFunction */
+    function TFunction(schema) {
+        // prettier-ignore
+        if (!(TKind(schema) &&
+            schema[exports.Kind] === 'Function' &&
+            schema.type === 'object' &&
+            schema.instanceOf === 'Function' &&
+            IsOptionalString(schema.$id) &&
+            IsArray(schema.parameters) &&
+            TSchema(schema.returns))) {
+            return false;
+        }
+        for (const parameter of schema.parameters) {
+            if (!TSchema(parameter))
+                return false;
+        }
+        return true;
+    }
+    TypeGuard.TFunction = TFunction;
+    /** Returns true if the given schema is TInteger */
+    function TInteger(schema) {
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Integer' &&
+            schema.type === 'integer' &&
+            IsOptionalString(schema.$id) &&
+            IsOptionalNumber(schema.multipleOf) &&
+            IsOptionalNumber(schema.minimum) &&
+            IsOptionalNumber(schema.maximum) &&
+            IsOptionalNumber(schema.exclusiveMinimum) &&
+            IsOptionalNumber(schema.exclusiveMaximum));
+    }
+    TypeGuard.TInteger = TInteger;
+    /** Returns true if the given schema is TIntersect */
+    function TIntersect(schema) {
+        // prettier-ignore
+        if (!(TKind(schema) &&
+            schema[exports.Kind] === 'Intersect' &&
+            IsArray(schema.allOf) &&
+            IsOptionalString(schema.type) &&
+            (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
+            IsOptionalString(schema.$id))) {
+            return false;
+        }
+        if ('type' in schema && schema.type !== 'object') {
+            return false;
+        }
+        for (const inner of schema.allOf) {
+            if (!TSchema(inner))
+                return false;
+        }
+        return true;
+    }
+    TypeGuard.TIntersect = TIntersect;
+    /** Returns true if the given schema is TKind */
+    function TKind(schema) {
+        return IsObject(schema) && exports.Kind in schema && typeof schema[exports.Kind] === 'string'; // TS 4.1.5: any required for symbol indexer
+    }
+    TypeGuard.TKind = TKind;
+    /** Returns true if the given schema is TLiteral */
+    function TLiteral(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Literal' &&
+            IsOptionalString(schema.$id) &&
+            (IsString(schema.const) ||
+                IsNumber(schema.const) ||
+                IsBoolean(schema.const) ||
+                IsBigInt(schema.const)));
+    }
+    TypeGuard.TLiteral = TLiteral;
+    /** Returns true if the given schema is TNever */
+    function TNever(schema) {
+        return (TKind(schema) && schema[exports.Kind] === 'Never' && IsObject(schema.not) && globalThis.Object.getOwnPropertyNames(schema.not).length === 0
+        // IsArray(schema.allOf) &&
+        // schema.allOf.length === 2 &&
+        // IsObject(schema.allOf[0]) &&
+        // IsString(schema.allOf[0].type) &&
+        // schema.allOf[0].type === 'boolean' &&
+        // schema.allOf[0].const === false &&
+        // IsObject(schema.allOf[1]) &&
+        // IsString(schema.allOf[1].type) &&
+        // schema.allOf[1].type === 'boolean' &&
+        // schema.allOf[1].const === true
+        );
+    }
+    TypeGuard.TNever = TNever;
+    /** Returns true if the given schema is TNot */
+    function TNot(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Not' &&
+            IsArray(schema.allOf) &&
+            schema.allOf.length === 2 &&
+            IsObject(schema.allOf[0]) &&
+            TSchema(schema.allOf[0].not) &&
+            TSchema(schema.allOf[1]));
+    }
+    TypeGuard.TNot = TNot;
+    /** Returns true if the given schema is TNull */
+    function TNull(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Null' &&
+            schema.type === 'null' &&
+            IsOptionalString(schema.$id));
+    }
+    TypeGuard.TNull = TNull;
+    /** Returns true if the given schema is TNumber */
+    function TNumber(schema) {
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Number' &&
+            schema.type === 'number' &&
+            IsOptionalString(schema.$id) &&
+            IsOptionalNumber(schema.multipleOf) &&
+            IsOptionalNumber(schema.minimum) &&
+            IsOptionalNumber(schema.maximum) &&
+            IsOptionalNumber(schema.exclusiveMinimum) &&
+            IsOptionalNumber(schema.exclusiveMaximum));
+    }
+    TypeGuard.TNumber = TNumber;
+    /** Returns true if the given schema is TObject */
+    function TObject(schema) {
+        if (!(TKind(schema) &&
+            schema[exports.Kind] === 'Object' &&
+            schema.type === 'object' &&
+            IsOptionalString(schema.$id) &&
+            IsObject(schema.properties) &&
+            (IsOptionalBoolean(schema.additionalProperties) || IsOptionalSchema(schema.additionalProperties)) &&
+            IsOptionalNumber(schema.minProperties) &&
+            IsOptionalNumber(schema.maxProperties))) {
+            return false;
+        }
+        for (const [key, value] of Object.entries(schema.properties)) {
+            if (!IsControlCharacterFree(key))
+                return false;
+            if (!TSchema(value))
+                return false;
+        }
+        return true;
+    }
+    TypeGuard.TObject = TObject;
+    /** Returns true if the given schema is TPromise */
+    function TPromise(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Promise' &&
+            schema.type === 'object' &&
+            schema.instanceOf === 'Promise' &&
+            IsOptionalString(schema.$id) &&
+            TSchema(schema.item));
+    }
+    TypeGuard.TPromise = TPromise;
+    /** Returns true if the given schema is TRecord */
+    function TRecord(schema) {
+        // prettier-ignore
+        if (!(TKind(schema) &&
+            schema[exports.Kind] === 'Record' &&
+            schema.type === 'object' &&
+            IsOptionalString(schema.$id) &&
+            schema.additionalProperties === false &&
+            IsObject(schema.patternProperties))) {
+            return false;
+        }
+        const keys = Object.keys(schema.patternProperties);
+        if (keys.length !== 1) {
+            return false;
+        }
+        if (!IsPattern(keys[0])) {
+            return false;
+        }
+        if (!TSchema(schema.patternProperties[keys[0]])) {
+            return false;
+        }
+        return true;
+    }
+    TypeGuard.TRecord = TRecord;
+    /** Returns true if the given schema is TSelf */
+    function TSelf(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Self' &&
+            IsOptionalString(schema.$id) &&
+            IsString(schema.$ref));
+    }
+    TypeGuard.TSelf = TSelf;
+    /** Returns true if the given schema is TRef */
+    function TRef(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Ref' &&
+            IsOptionalString(schema.$id) &&
+            IsString(schema.$ref));
+    }
+    TypeGuard.TRef = TRef;
+    /** Returns true if the given schema is TString */
+    function TString(schema) {
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'String' &&
+            schema.type === 'string' &&
+            IsOptionalString(schema.$id) &&
+            IsOptionalNumber(schema.minLength) &&
+            IsOptionalNumber(schema.maxLength) &&
+            IsOptionalPattern(schema.pattern) &&
+            IsOptionalFormat(schema.format));
+    }
+    TypeGuard.TString = TString;
+    /** Returns true if the given schema is TSymbol */
+    function TSymbol(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Symbol' &&
+            schema.type === 'null' &&
+            schema.typeOf === 'Symbol' &&
+            IsOptionalString(schema.$id));
+    }
+    TypeGuard.TSymbol = TSymbol;
+    /** Returns true if the given schema is TTuple */
+    function TTuple(schema) {
+        // prettier-ignore
+        if (!(TKind(schema) &&
+            schema[exports.Kind] === 'Tuple' &&
+            schema.type === 'array' &&
+            IsOptionalString(schema.$id) &&
+            IsNumber(schema.minItems) &&
+            IsNumber(schema.maxItems) &&
+            schema.minItems === schema.maxItems)) {
+            return false;
+        }
+        if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
+            return true;
+        }
+        if (!IsArray(schema.items)) {
+            return false;
+        }
+        for (const inner of schema.items) {
+            if (!TSchema(inner))
+                return false;
+        }
+        return true;
+    }
+    TypeGuard.TTuple = TTuple;
+    /** Returns true if the given schema is TUndefined */
+    function TUndefined(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Undefined' &&
+            schema.type === 'null' &&
+            schema.typeOf === 'Undefined' &&
+            IsOptionalString(schema.$id));
+    }
+    TypeGuard.TUndefined = TUndefined;
+    /** Returns true if the given schema is TUnion */
+    function TUnion(schema) {
+        // prettier-ignore
+        if (!(TKind(schema) &&
+            schema[exports.Kind] === 'Union' &&
+            IsArray(schema.anyOf) &&
+            IsOptionalString(schema.$id))) {
+            return false;
+        }
+        for (const inner of schema.anyOf) {
+            if (!TSchema(inner))
+                return false;
+        }
+        return true;
+    }
+    TypeGuard.TUnion = TUnion;
+    /** Returns true if the given schema is TUnion<Literal<string>[]> */
+    function TUnionLiteral(schema) {
+        return TUnion(schema) && schema.anyOf.every((schema) => TLiteral(schema) && typeof schema.const === 'string');
+    }
+    TypeGuard.TUnionLiteral = TUnionLiteral;
+    /** Returns true if the given schema is TUint8Array */
+    function TUint8Array(schema) {
+        return TKind(schema) && schema[exports.Kind] === 'Uint8Array' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.instanceOf === 'Uint8Array' && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength);
+    }
+    TypeGuard.TUint8Array = TUint8Array;
+    /** Returns true if the given schema is TUnknown */
+    function TUnknown(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Unknown' &&
+            IsOptionalString(schema.$id));
+    }
+    TypeGuard.TUnknown = TUnknown;
+    /** Returns true if the given schema is TVoid */
+    function TVoid(schema) {
+        // prettier-ignore
+        return (TKind(schema) &&
+            schema[exports.Kind] === 'Void' &&
+            schema.type === 'null' &&
+            schema.typeOf === 'Void' &&
+            IsOptionalString(schema.$id));
+    }
+    TypeGuard.TVoid = TVoid;
+    /** Returns true if this schema has the ReadonlyOptional modifier */
+    function TReadonlyOptional(schema) {
+        return IsObject(schema) && schema[exports.Modifier] === 'ReadonlyOptional';
+    }
+    TypeGuard.TReadonlyOptional = TReadonlyOptional;
+    /** Returns true if this schema has the Readonly modifier */
+    function TReadonly(schema) {
+        return IsObject(schema) && schema[exports.Modifier] === 'Readonly';
+    }
+    TypeGuard.TReadonly = TReadonly;
+    /** Returns true if this schema has the Optional modifier */
+    function TOptional(schema) {
+        return IsObject(schema) && schema[exports.Modifier] === 'Optional';
+    }
+    TypeGuard.TOptional = TOptional;
+    /** Returns true if the given schema is TSchema */
+    function TSchema(schema) {
+        return (typeof schema === 'object' &&
+            (TAny(schema) ||
+                TArray(schema) ||
+                TBoolean(schema) ||
+                TBigInt(schema) ||
+                TConstructor(schema) ||
+                TDate(schema) ||
+                TFunction(schema) ||
+                TInteger(schema) ||
+                TIntersect(schema) ||
+                TLiteral(schema) ||
+                TNever(schema) ||
+                TNot(schema) ||
+                TNull(schema) ||
+                TNumber(schema) ||
+                TObject(schema) ||
+                TPromise(schema) ||
+                TRecord(schema) ||
+                TSelf(schema) ||
+                TRef(schema) ||
+                TString(schema) ||
+                TSymbol(schema) ||
+                TTuple(schema) ||
+                TUndefined(schema) ||
+                TUnion(schema) ||
+                TUint8Array(schema) ||
+                TUnknown(schema) ||
+                TVoid(schema) ||
+                (TKind(schema) && TypeRegistry.Has(schema[exports.Kind]))));
+    }
+    TypeGuard.TSchema = TSchema;
+})(TypeGuard = exports.TypeGuard || (exports.TypeGuard = {}));
+// --------------------------------------------------------------------------
+// ExtendsUndefined
+// --------------------------------------------------------------------------
+var ExtendsUndefined;
+(function (ExtendsUndefined) {
+    /** Fast undefined check for properties of type undefined */
+    function Check(schema) {
+        if (schema[exports.Kind] === 'Undefined')
+            return true;
+        if (schema[exports.Kind] === 'Union') {
+            const union = schema;
+            return union.anyOf.some((schema) => Check(schema));
+        }
+        return false;
+    }
+    ExtendsUndefined.Check = Check;
+})(ExtendsUndefined = exports.ExtendsUndefined || (exports.ExtendsUndefined = {}));
+// --------------------------------------------------------------------------
+// TypeExtends
+// --------------------------------------------------------------------------
+var TypeExtendsResult;
+(function (TypeExtendsResult) {
+    TypeExtendsResult[TypeExtendsResult["Union"] = 0] = "Union";
+    TypeExtendsResult[TypeExtendsResult["True"] = 1] = "True";
+    TypeExtendsResult[TypeExtendsResult["False"] = 2] = "False";
+})(TypeExtendsResult = exports.TypeExtendsResult || (exports.TypeExtendsResult = {}));
+var TypeExtends;
+(function (TypeExtends) {
+    // --------------------------------------------------------------------------
+    // IntoBooleanResult
+    // --------------------------------------------------------------------------
+    function IntoBooleanResult(result) {
+        return result === TypeExtendsResult.False ? TypeExtendsResult.False : TypeExtendsResult.True;
+    }
+    // --------------------------------------------------------------------------
+    // Any
+    // --------------------------------------------------------------------------
+    function AnyRight(left, right) {
+        return TypeExtendsResult.True;
+    }
+    function Any(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema)))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TUnion(right))
+            return TypeExtendsResult.Union;
+        if (TypeGuard.TUnknown(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TAny(right))
+            return TypeExtendsResult.True;
+        return TypeExtendsResult.Union;
+    }
+    // --------------------------------------------------------------------------
+    // Array
+    // --------------------------------------------------------------------------
+    function ArrayRight(left, right) {
+        if (TypeGuard.TUnknown(left))
+            return TypeExtendsResult.False;
+        if (TypeGuard.TAny(left))
+            return TypeExtendsResult.Union;
+        if (TypeGuard.TNever(left))
+            return TypeExtendsResult.True;
+        return TypeExtendsResult.False;
+    }
+    function Array(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right) && IsObjectArrayLike(right))
+            return TypeExtendsResult.True;
+        if (!TypeGuard.TArray(right))
+            return TypeExtendsResult.False;
+        return IntoBooleanResult(Visit(left.items, right.items));
+    }
+    // --------------------------------------------------------------------------
+    // BigInt
+    // --------------------------------------------------------------------------
+    function BigInt(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+            return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+            return RecordRight(left, right);
+        return TypeGuard.TBigInt(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Boolean
+    // --------------------------------------------------------------------------
+    function BooleanRight(left, right) {
+        if (TypeGuard.TLiteral(left) && typeof left.const === 'boolean')
+            return TypeExtendsResult.True;
+        return TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    function Boolean(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+            return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+            return RecordRight(left, right);
+        return TypeGuard.TBoolean(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Constructor
+    // --------------------------------------------------------------------------
+    function Constructor(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (!TypeGuard.TConstructor(right))
+            return TypeExtendsResult.False;
+        if (left.parameters.length > right.parameters.length)
+            return TypeExtendsResult.False;
+        if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
+            return TypeExtendsResult.False;
+        }
+        return IntoBooleanResult(Visit(left.returns, right.returns));
+    }
+    // --------------------------------------------------------------------------
+    // Date
+    // --------------------------------------------------------------------------
+    function Date(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+            return RecordRight(left, right);
+        return TypeGuard.TDate(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Function
+    // --------------------------------------------------------------------------
+    function Function(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (!TypeGuard.TFunction(right))
+            return TypeExtendsResult.False;
+        if (left.parameters.length > right.parameters.length)
+            return TypeExtendsResult.False;
+        if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
+            return TypeExtendsResult.False;
+        }
+        return IntoBooleanResult(Visit(left.returns, right.returns));
+    }
+    // --------------------------------------------------------------------------
+    // Integer
+    // --------------------------------------------------------------------------
+    function IntegerRight(left, right) {
+        if (TypeGuard.TLiteral(left) && typeof left.const === 'number')
+            return TypeExtendsResult.True;
+        return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    function Integer(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+            return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+            return RecordRight(left, right);
+        return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Intersect
+    // --------------------------------------------------------------------------
+    function IntersectRight(left, right) {
+        return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    function Intersect(left, right) {
+        return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Literal
+    // --------------------------------------------------------------------------
+    function IsLiteralString(schema) {
+        return typeof schema.const === 'string';
+    }
+    function IsLiteralNumber(schema) {
+        return typeof schema.const === 'number';
+    }
+    function IsLiteralBoolean(schema) {
+        return typeof schema.const === 'boolean';
+    }
+    function Literal(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+            return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+            return RecordRight(left, right);
+        if (TypeGuard.TString(right))
+            return StringRight(left, right);
+        if (TypeGuard.TNumber(right))
+            return NumberRight(left, right);
+        if (TypeGuard.TInteger(right))
+            return IntegerRight(left, right);
+        if (TypeGuard.TBoolean(right))
+            return BooleanRight(left, right);
+        return TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Never
+    // --------------------------------------------------------------------------
+    function NeverRight(left, right) {
+        return TypeExtendsResult.False;
+    }
+    function Never(left, right) {
+        return TypeExtendsResult.True;
+    }
+    // --------------------------------------------------------------------------
+    // Null
+    // --------------------------------------------------------------------------
+    function Null(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+            return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+            return RecordRight(left, right);
+        return TypeGuard.TNull(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Number
+    // --------------------------------------------------------------------------
+    function NumberRight(left, right) {
+        if (TypeGuard.TLiteral(left) && IsLiteralNumber(left))
+            return TypeExtendsResult.True;
+        return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    function Number(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+            return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+            return RecordRight(left, right);
+        return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Object
+    // --------------------------------------------------------------------------
+    function IsObjectPropertyCount(schema, count) {
+        return globalThis.Object.keys(schema.properties).length === count;
+    }
+    function IsObjectStringLike(schema) {
+        return IsObjectArrayLike(schema);
+    }
+    function IsObjectSymbolLike(schema) {
+        // prettier-ignore
+        return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'description' in schema.properties && TypeGuard.TUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && ((TypeGuard.TString(schema.properties.description.anyOf[0]) &&
+            TypeGuard.TUndefined(schema.properties.description.anyOf[1])) || (TypeGuard.TString(schema.properties.description.anyOf[1]) &&
+            TypeGuard.TUndefined(schema.properties.description.anyOf[0]))));
+    }
+    function IsObjectNumberLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+    }
+    function IsObjectBooleanLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+    }
+    function IsObjectBigIntLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+    }
+    function IsObjectDateLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+    }
+    function IsObjectUint8ArrayLike(schema) {
+        return IsObjectArrayLike(schema);
+    }
+    function IsObjectFunctionLike(schema) {
+        const length = exports.Type.Number();
+        return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === TypeExtendsResult.True);
+    }
+    function IsObjectConstructorLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+    }
+    function IsObjectArrayLike(schema) {
+        const length = exports.Type.Number();
+        return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === TypeExtendsResult.True);
+    }
+    function IsObjectPromiseLike(schema) {
+        const then = exports.Type.Function([exports.Type.Any()], exports.Type.Any());
+        return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'then' in schema.properties && IntoBooleanResult(Visit(schema.properties['then'], then)) === TypeExtendsResult.True);
+    }
+    // --------------------------------------------------------------------------
+    // Property
+    // --------------------------------------------------------------------------
+    function Property(left, right) {
+        if (Visit(left, right) === TypeExtendsResult.False)
+            return TypeExtendsResult.False;
+        if (TypeGuard.TOptional(left) && !TypeGuard.TOptional(right))
+            return TypeExtendsResult.False;
+        return TypeExtendsResult.True;
+    }
+    function ObjectRight(left, right) {
+        if (TypeGuard.TUnknown(left))
+            return TypeExtendsResult.False;
+        if (TypeGuard.TAny(left))
+            return TypeExtendsResult.Union;
+        if (TypeGuard.TNever(left))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TLiteral(left) && IsLiteralString(left) && IsObjectStringLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TLiteral(left) && IsLiteralNumber(left) && IsObjectNumberLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TLiteral(left) && IsLiteralBoolean(left) && IsObjectBooleanLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TBigInt(left) && IsObjectBigIntLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TString(left) && IsObjectStringLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TNumber(left) && IsObjectNumberLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TInteger(left) && IsObjectNumberLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TBoolean(left) && IsObjectBooleanLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TDate(left) && IsObjectDateLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TConstructor(left) && IsObjectConstructorLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TFunction(left) && IsObjectFunctionLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left))) {
+            // When expressing a Record with literal key values, the Record is converted into a Object with
+            // the Hint assigned as `Record`. This is used to invert the extends logic.
+            return right[exports.Hint] === 'Record' ? TypeExtendsResult.True : TypeExtendsResult.False;
+        }
+        if (TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left))) {
+            return IsObjectPropertyCount(right, 0) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        }
+        return TypeExtendsResult.False;
+    }
+    function Object(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TRecord(right))
+            return RecordRight(left, right);
+        if (!TypeGuard.TObject(right))
+            return TypeExtendsResult.False;
+        for (const key of globalThis.Object.keys(right.properties)) {
+            if (!(key in left.properties))
+                return TypeExtendsResult.False;
+            if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
+                return TypeExtendsResult.False;
+            }
+        }
+        return TypeExtendsResult.True;
+    }
+    // --------------------------------------------------------------------------
+    // Promise
+    // --------------------------------------------------------------------------
+    function Promise(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right) && IsObjectPromiseLike(right))
+            return TypeExtendsResult.True;
+        if (!TypeGuard.TPromise(right))
+            return TypeExtendsResult.False;
+        return IntoBooleanResult(Visit(left.item, right.item));
+    }
+    // --------------------------------------------------------------------------
+    // Record
+    // --------------------------------------------------------------------------
+    function RecordKey(schema) {
+        if ('^(0|[1-9][0-9]*)$' in schema.patternProperties)
+            return exports.Type.Number();
+        if ('^.*$' in schema.patternProperties)
+            return exports.Type.String();
+        throw Error('TypeExtends: Cannot get record key');
+    }
+    function RecordValue(schema) {
+        if ('^(0|[1-9][0-9]*)$' in schema.patternProperties)
+            return schema.patternProperties['^(0|[1-9][0-9]*)$'];
+        if ('^.*$' in schema.patternProperties)
+            return schema.patternProperties['^.*$'];
+        throw Error('TypeExtends: Cannot get record value');
+    }
+    function RecordRight(left, right) {
+        const Key = RecordKey(right);
+        const Value = RecordValue(right);
+        if (TypeGuard.TLiteral(left) && IsLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True)
+            return TypeExtendsResult.True;
+        if (TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key))
+            return Visit(left, Value);
+        if (TypeGuard.TString(left) && TypeGuard.TNumber(Key))
+            return Visit(left, Value);
+        if (TypeGuard.TArray(left) && TypeGuard.TNumber(Key))
+            return Visit(left, Value);
+        if (TypeGuard.TObject(left)) {
+            for (const key of globalThis.Object.keys(left.properties)) {
+                if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
+                    return TypeExtendsResult.False;
+                }
+            }
+            return TypeExtendsResult.True;
+        }
+        return TypeExtendsResult.False;
+    }
+    function Record(left, right) {
+        const Value = RecordValue(left);
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (!TypeGuard.TRecord(right))
+            return TypeExtendsResult.False;
+        return Visit(Value, RecordValue(right));
+    }
+    // --------------------------------------------------------------------------
+    // String
+    // --------------------------------------------------------------------------
+    function StringRight(left, right) {
+        if (TypeGuard.TLiteral(left) && typeof left.const === 'string')
+            return TypeExtendsResult.True;
+        return TypeGuard.TString(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    function String(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+            return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+            return RecordRight(left, right);
+        return TypeGuard.TString(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Symbol
+    // --------------------------------------------------------------------------
+    function Symbol(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+            return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+            return RecordRight(left, right);
+        return TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Tuple
+    // --------------------------------------------------------------------------
+    function TupleRight(left, right) {
+        if (TypeGuard.TUnknown(left))
+            return TypeExtendsResult.False;
+        if (TypeGuard.TAny(left))
+            return TypeExtendsResult.Union;
+        if (TypeGuard.TNever(left))
+            return TypeExtendsResult.True;
+        return TypeExtendsResult.False;
+    }
+    function IsArrayOfTuple(left, right) {
+        return TypeGuard.TArray(right) && left.items !== undefined && left.items.every((schema) => Visit(schema, right.items) === TypeExtendsResult.True);
+    }
+    function Tuple(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right) && IsObjectArrayLike(right))
+            return TypeExtendsResult.True;
+        if (TypeGuard.TArray(right) && IsArrayOfTuple(left, right))
+            return TypeExtendsResult.True;
+        if (!TypeGuard.TTuple(right))
+            return TypeExtendsResult.False;
+        if ((left.items === undefined && right.items !== undefined) || (left.items !== undefined && right.items === undefined))
+            return TypeExtendsResult.False;
+        if (left.items === undefined && right.items === undefined)
+            return TypeExtendsResult.True;
+        return left.items.every((schema, index) => Visit(schema, right.items[index]) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Uint8Array
+    // --------------------------------------------------------------------------
+    function Uint8Array(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+            return RecordRight(left, right);
+        return TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Undefined
+    // --------------------------------------------------------------------------
+    function Undefined(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TNever(right))
+            return NeverRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        if (TypeGuard.TRecord(right))
+            return RecordRight(left, right);
+        if (TypeGuard.TVoid(right))
+            return VoidRight(left, right);
+        return TypeGuard.TUndefined(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Union
+    // --------------------------------------------------------------------------
+    function UnionRight(left, right) {
+        return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    function Union(left, right) {
+        return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Unknown
+    // --------------------------------------------------------------------------
+    function UnknownRight(left, right) {
+        return TypeExtendsResult.True;
+    }
+    function Unknown(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TString(right))
+            return StringRight(left, right);
+        if (TypeGuard.TNumber(right))
+            return NumberRight(left, right);
+        if (TypeGuard.TInteger(right))
+            return IntegerRight(left, right);
+        if (TypeGuard.TBoolean(right))
+            return BooleanRight(left, right);
+        if (TypeGuard.TArray(right))
+            return ArrayRight(left, right);
+        if (TypeGuard.TTuple(right))
+            return TupleRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        return TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    // --------------------------------------------------------------------------
+    // Void
+    // --------------------------------------------------------------------------
+    function VoidRight(left, right) {
+        if (TypeGuard.TUndefined(left))
+            return TypeExtendsResult.True;
+        return TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    function Void(left, right) {
+        if (TypeGuard.TIntersect(right))
+            return IntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return UnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return UnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return AnyRight(left, right);
+        if (TypeGuard.TObject(right))
+            return ObjectRight(left, right);
+        return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+    }
+    function Visit(left, right) {
+        const right_ = ReferenceRegistry.Deref(right);
+        const left_ = ReferenceRegistry.Deref(left);
+        if (TypeGuard.TAny(left_))
+            return Any(left_, right_);
+        if (TypeGuard.TArray(left_))
+            return Array(left_, right_);
+        if (TypeGuard.TBigInt(left_))
+            return BigInt(left_, right_);
+        if (TypeGuard.TBoolean(left_))
+            return Boolean(left_, right_);
+        if (TypeGuard.TConstructor(left_))
+            return Constructor(left_, right_);
+        if (TypeGuard.TDate(left_))
+            return Date(left_, right_);
+        if (TypeGuard.TFunction(left_))
+            return Function(left_, right_);
+        if (TypeGuard.TInteger(left_))
+            return Integer(left_, right_);
+        if (TypeGuard.TIntersect(left_))
+            return Intersect(left_, right_);
+        if (TypeGuard.TLiteral(left_))
+            return Literal(left_, right_);
+        if (TypeGuard.TNever(left_))
+            return Never(left_, right_);
+        if (TypeGuard.TNull(left_))
+            return Null(left_, right_);
+        if (TypeGuard.TNumber(left_))
+            return Number(left_, right_);
+        if (TypeGuard.TRecord(left_))
+            return Record(left_, right_);
+        if (TypeGuard.TString(left_))
+            return String(left_, right_);
+        if (TypeGuard.TSymbol(left_))
+            return Symbol(left_, right_);
+        if (TypeGuard.TObject(left_))
+            return Object(left_, right_);
+        if (TypeGuard.TTuple(left_))
+            return Tuple(left_, right_);
+        if (TypeGuard.TPromise(left_))
+            return Promise(left_, right_);
+        if (TypeGuard.TUint8Array(left_))
+            return Uint8Array(left_, right_);
+        if (TypeGuard.TUndefined(left_))
+            return Undefined(left_, right_);
+        if (TypeGuard.TUnion(left_))
+            return Union(left_, right_);
+        if (TypeGuard.TUnknown(left_))
+            return Unknown(left_, right_);
+        if (TypeGuard.TVoid(left_))
+            return Void(left_, right_);
+        throw Error(`TypeExtends: Unknown left type operand '${left[exports.Kind]}'`);
+    }
+    function Extends(left, right) {
+        return Visit(left, right);
+    }
+    TypeExtends.Extends = Extends;
+})(TypeExtends = exports.TypeExtends || (exports.TypeExtends = {}));
+// --------------------------------------------------------------------------
+// TypeClone
+// --------------------------------------------------------------------------
+/** Specialized Clone for Types. Clones and removes non self-referential identifiers */
+var TypeClone;
+(function (TypeClone) {
+    function IsRecursive(value) {
+        return typeof value[exports.Recursive] === 'string';
+    }
+    function IsObject(value) {
+        return typeof value === 'object' && value !== null && !globalThis.Array.isArray(value);
+    }
+    function IsArray(value) {
+        return globalThis.Array.isArray(value);
+    }
+    function Array(value) {
+        return value.map((value) => Visit(value));
+    }
+    function Object(value) {
+        const clone = globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), globalThis.Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {}));
+        return clone;
+    }
+    function Visit(value) {
+        const clone = IsObject(value) ? { ...value } : IsArray(value) ? [...value] : value;
+        if (IsObject(clone) && !IsRecursive(clone))
+            delete clone['$id'];
+        if (IsObject(clone))
+            return Object(clone);
+        if (IsArray(clone))
+            return Array(clone);
+        return clone;
+    }
+    /** Clones a type. This function will omit non-self referential identifiers on the cloned type. */
+    function Clone(schema, options) {
+        return { ...Visit({ ...schema }), ...options };
+    }
+    TypeClone.Clone = Clone;
+})(TypeClone = exports.TypeClone || (exports.TypeClone = {}));
+// --------------------------------------------------------------------------
+// ObjectMap
+// --------------------------------------------------------------------------
+var ObjectMap;
+(function (ObjectMap) {
+    function Intersect(schema, callback) {
+        return exports.Type.Intersect(schema.allOf.map((inner) => Visit(ReferenceRegistry.Deref(inner), callback)), { ...schema });
+    }
+    function Union(schema, callback) {
+        return exports.Type.Union(schema.anyOf.map((inner) => Visit(ReferenceRegistry.Deref(inner), callback)), { ...schema });
+    }
+    function Object(schema, callback) {
+        return callback(schema);
+    }
+    function Visit(schema, callback) {
+        if (TypeGuard.TIntersect(schema))
+            return Intersect(schema, callback);
+        if (TypeGuard.TUnion(schema))
+            return Union(schema, callback);
+        if (TypeGuard.TObject(schema))
+            return Object(schema, callback);
+        return schema;
+    }
+    function Map(schema, callback, options) {
+        return { ...Visit(TypeClone.Clone(schema, {}), callback), ...options };
+    }
+    ObjectMap.Map = Map;
+})(ObjectMap = exports.ObjectMap || (exports.ObjectMap = {}));
+// --------------------------------------------------------------------------
+// KeyResolver
+// --------------------------------------------------------------------------
+var KeyResolver;
+(function (KeyResolver) {
+    function IsKeyable(schema) {
+        return TypeGuard.TIntersect(schema) || TypeGuard.TUnion(schema) || (TypeGuard.TObject(schema) && globalThis.Object.getOwnPropertyNames(schema.properties).length > 0);
+    }
+    function Intersect(schema) {
+        return [...schema.allOf.filter((schema) => IsKeyable(schema)).reduce((set, schema) => Visit(schema).map((key) => set.add(key))[0], new Set())];
+    }
+    function Union(schema) {
+        const sets = schema.anyOf.filter((schema) => IsKeyable(schema)).map((inner) => Visit(inner));
+        return [...sets.reduce((set, outer) => outer.map((key) => (sets.every((inner) => inner.includes(key)) ? set.add(key) : set))[0], new Set())];
+    }
+    function Object(schema) {
+        return globalThis.Object.keys(schema.properties);
+    }
+    function Visit(schema) {
+        if (TypeGuard.TIntersect(schema))
+            return Intersect(schema);
+        if (TypeGuard.TUnion(schema))
+            return Union(schema);
+        if (TypeGuard.TObject(schema))
+            return Object(schema);
+        return [];
+    }
+    function Resolve(schema) {
+        return Visit(schema);
+    }
+    KeyResolver.Resolve = Resolve;
+})(KeyResolver = exports.KeyResolver || (exports.KeyResolver = {}));
+// --------------------------------------------------------------------------
+// TypeOrdinal: Used for auto $id generation
+// --------------------------------------------------------------------------
+let TypeOrdinal = 0;
+// --------------------------------------------------------------------------
+// TypeBuilder
+// --------------------------------------------------------------------------
+class TypeBuilder {
+    /** `[Utility]` Creates a schema without `static` and `params` types */
+    Create(schema) {
+        ReferenceRegistry.Set(schema);
+        return schema;
+    }
+    /** `[Standard]` Omits compositing symbols from this schema */
+    Strict(schema) {
+        return JSON.parse(JSON.stringify(schema));
+    }
+}
+exports.TypeBuilder = TypeBuilder;
+// --------------------------------------------------------------------------
+// StandardTypeBuilder
+// --------------------------------------------------------------------------
+class StandardTypeBuilder extends TypeBuilder {
+    // ------------------------------------------------------------------------
+    // Modifiers
+    // ------------------------------------------------------------------------
+    /** `[Modifier]` Creates a Optional property */
+    Optional(schema) {
+        return { [exports.Modifier]: 'Optional', ...TypeClone.Clone(schema, {}) };
+    }
+    /** `[Modifier]` Creates a ReadonlyOptional property */
+    ReadonlyOptional(schema) {
+        return { [exports.Modifier]: 'ReadonlyOptional', ...TypeClone.Clone(schema, {}) };
+    }
+    /** `[Modifier]` Creates a Readonly object or property */
+    Readonly(schema) {
+        return { [exports.Modifier]: 'Readonly', ...schema };
+    }
+    // ------------------------------------------------------------------------
+    // Types
+    // ------------------------------------------------------------------------
+    /** `[Standard]` Creates an Any type */
+    Any(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Any' });
+    }
+    /** `[Standard]` Creates an Array type */
+    Array(items, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items: TypeClone.Clone(items, {}) });
+    }
+    /** `[Standard]` Creates a Boolean type */
+    Boolean(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
+    }
+    /** `[Standard]` Creates a Composite object type that will Union any overlapping properties of the given Object array */
+    Composite(schemas, options = {}) {
+        const optional = new Set();
+        for (const schema of schemas) {
+            for (const [key, property] of globalThis.Object.entries(schema.properties)) {
+                if (TypeGuard.TOptional(property) || TypeGuard.TReadonlyOptional(property))
+                    optional.add(key);
+            }
+        }
+        const properties = {};
+        for (const object of schemas) {
+            for (const [key, property] of globalThis.Object.entries(object.properties)) {
+                const mapped = key in properties ? this.Union([properties[key], property]) : TypeClone.Clone(property, {});
+                properties[key] = optional.has(key) ? this.Optional(mapped) : mapped;
+            }
+        }
+        return this.Object(properties, options);
+    }
+    /** `[Standard]` Dereferences the given TRef to its target type */
+    Deref(schema) {
+        return ReferenceRegistry.Deref(schema);
+    }
+    /** `[Standard]` Creates a Enum type */
+    Enum(item, options = {}) {
+        // prettier-ignore
+        const values = globalThis.Object.keys(item).filter((key) => isNaN(key)).map((key) => item[key]);
+        const anyOf = values.map((value) => (typeof value === 'string' ? { [exports.Kind]: 'Literal', type: 'string', const: value } : { [exports.Kind]: 'Literal', type: 'number', const: value }));
+        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf });
+    }
+    /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
+    Extends(left, right, trueType, falseType, options = {}) {
+        switch (TypeExtends.Extends(ReferenceRegistry.Deref(left), ReferenceRegistry.Deref(right))) {
+            case TypeExtendsResult.Union:
+                return this.Union([TypeClone.Clone(trueType, options), TypeClone.Clone(falseType, options)]);
+            case TypeExtendsResult.True:
+                return TypeClone.Clone(trueType, options);
+            case TypeExtendsResult.False:
+                return TypeClone.Clone(falseType, options);
+        }
+    }
+    /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
+    Exclude(left, right, options = {}) {
+        if (TypeGuard.TUnion(left)) {
+            const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) === TypeExtendsResult.False);
+            return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options));
+        }
+        else {
+            return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(left, options));
+        }
+    }
+    /** `[Standard]` Extracts from left left any type that is assignable to the right */
+    Extract(left, right, options = {}) {
+        if (TypeGuard.TUnion(left)) {
+            const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False);
+            return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options));
+        }
+        else {
+            return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? TypeClone.Clone(left, options) : this.Never(options));
+        }
+    }
+    /** `[Standard]` Creates an Integer type */
+    Integer(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Integer', type: 'integer' });
+    }
+    Intersect(allOf, options = {}) {
+        if (allOf.length === 0)
+            return exports.Type.Never();
+        if (allOf.length === 1)
+            return TypeClone.Clone(allOf[0], options);
+        const objects = allOf.every((schema) => TypeGuard.TObject(schema));
+        const cloned = allOf.map((schema) => TypeClone.Clone(schema, {}));
+        const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Clone(options.unevaluatedProperties, {}) } : {};
+        if (options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects) {
+            return this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: 'Intersect', type: 'object', allOf: cloned });
+        }
+        else {
+            return this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: 'Intersect', allOf: cloned });
+        }
+    }
+    /** `[Standard]` Creates a KeyOf type */
+    KeyOf(schema, options = {}) {
+        const keys = KeyResolver.Resolve(ReferenceRegistry.Deref(schema));
+        // prettier-ignore
+        const keyof = keys.length === 0 ? this.Never(options) : this.Union(keys.map((key) => this.Literal(key)), options);
+        return keyof;
+    }
+    /** `[Standard]` Creates a Literal type */
+    Literal(value, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Literal', const: value, type: typeof value });
+    }
+    /** `[Standard]` Creates a Never type */
+    Never(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Never', not: {} });
+    }
+    /** `[Standard]` Creates a Not type. The first argument is the disallowed type, the second is the allowed. */
+    Not(not, schema, options) {
+        return this.Create({ ...options, [exports.Kind]: 'Not', allOf: [{ not: TypeClone.Clone(not, {}) }, TypeClone.Clone(schema, {})] });
+    }
+    /** `[Standard]` Creates a Null type */
+    Null(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Null', type: 'null' });
+    }
+    /** `[Standard]` Creates a Number type */
+    Number(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Number', type: 'number' });
+    }
+    /** `[Standard]` Creates an Object type */
+    Object(properties, options = {}) {
+        const keys = globalThis.Object.keys(properties);
+        const optional = keys.filter((key) => TypeGuard.TOptional(properties[key]) || TypeGuard.TReadonlyOptional(properties[key]));
+        const required = keys.filter((name) => !optional.includes(name));
+        const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties, {}) } : {};
+        const clonedProperties = globalThis.Object.getOwnPropertyNames(properties).reduce((acc, key) => {
+            return { ...acc, [key]: TypeClone.Clone(properties[key], {}) };
+        }, {});
+        if (required.length > 0) {
+            return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties, required });
+        }
+        else {
+            return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties });
+        }
+    }
+    Omit(schema, unresolved, options = {}) {
+        const keys = TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema) => schema.const) : unresolved;
+        // prettier-ignore
+        return ObjectMap.Map(TypeClone.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
+            if (schema.required) {
+                schema.required = schema.required.filter((key) => !keys.includes(key));
+                if (schema.required.length === 0)
+                    delete schema.required;
+            }
+            for (const key of globalThis.Object.keys(schema.properties)) {
+                if (keys.includes(key))
+                    delete schema.properties[key];
+            }
+            return this.Create(schema);
+        }, options);
+    }
+    /** `[Standard]` Creates a mapped type where all properties are Optional */
+    Partial(schema, options = {}) {
+        function Apply(schema) {
+            // prettier-ignore
+            switch (schema[exports.Modifier]) {
+                case 'ReadonlyOptional':
+                    schema[exports.Modifier] = 'ReadonlyOptional';
+                    break;
+                case 'Readonly':
+                    schema[exports.Modifier] = 'ReadonlyOptional';
+                    break;
+                case 'Optional':
+                    schema[exports.Modifier] = 'Optional';
+                    break;
+                default:
+                    schema[exports.Modifier] = 'Optional';
+                    break;
+            }
+        }
+        // prettier-ignore
+        return ObjectMap.Map(TypeClone.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
+            delete schema.required;
+            globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]));
+            return schema;
+        }, options);
+    }
+    Pick(schema, unresolved, options = {}) {
+        const keys = TypeGuard.TUnionLiteral(unresolved) ? unresolved.anyOf.map((schema) => schema.const) : unresolved;
+        // prettier-ignore
+        return ObjectMap.Map(TypeClone.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
+            if (schema.required) {
+                schema.required = schema.required.filter((key) => keys.includes(key));
+                if (schema.required.length === 0)
+                    delete schema.required;
+            }
+            for (const key of globalThis.Object.keys(schema.properties)) {
+                if (!keys.includes(key))
+                    delete schema.properties[key];
+            }
+            return this.Create(schema);
+        }, options);
+    }
+    Record(key, schema, options = {}) {
+        if (TypeGuard.TLiteral(key)) {
+            if (typeof key.const === 'string' || typeof key.const === 'number') {
+                return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options);
+            }
+            else
+                throw Error('TypeBuilder: Record key can only be derived from literals of number or string');
+        }
+        if (TypeGuard.TUnion(key)) {
+            if (key.anyOf.every((schema) => TypeGuard.TLiteral(schema) && (typeof schema.const === 'string' || typeof schema.const === 'number'))) {
+                const properties = key.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
+                return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
+            }
+            else
+                throw Error('TypeBuilder: Record key can only be derived from union literal of number or string');
+        }
+        const pattern = ['Integer', 'Number'].includes(key[exports.Kind]) ? '^(0|[1-9][0-9]*)$' : key[exports.Kind] === 'String' && key.pattern ? key.pattern : '^.*$';
+        return this.Create({
+            ...options,
+            [exports.Kind]: 'Record',
+            type: 'object',
+            patternProperties: { [pattern]: TypeClone.Clone(schema, {}) },
+            additionalProperties: false,
+        });
+    }
+    /** `[Standard]` Creates a Recursive type */
+    Recursive(callback, options = {}) {
+        if (options.$id === undefined)
+            options.$id = `T${TypeOrdinal++}`;
+        const self = callback({ [exports.Kind]: 'Self', $ref: `${options.$id}` });
+        const reassign = self;
+        reassign.$id = options.$id; // required as $id is readonly
+        return this.Create({ ...options, ...self, [exports.Recursive]: reassign.$id });
+    }
+    /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
+    Ref(schema, options = {}) {
+        if (schema.$id === undefined)
+            throw Error('StandardTypeBuilder.Ref: Target type must specify an $id');
+        return this.Create({ ...options, [exports.Kind]: 'Ref', $ref: schema.$id });
+    }
+    /** `[Standard]` Creates a mapped type where all properties are Required */
+    Required(schema, options = {}) {
+        function Apply(schema) {
+            // prettier-ignore
+            switch (schema[exports.Modifier]) {
+                case 'ReadonlyOptional':
+                    schema[exports.Modifier] = 'Readonly';
+                    break;
+                case 'Readonly':
+                    schema[exports.Modifier] = 'Readonly';
+                    break;
+                case 'Optional':
+                    delete schema[exports.Modifier];
+                    break;
+                default:
+                    delete schema[exports.Modifier];
+                    break;
+            }
+        }
+        // prettier-ignore
+        return ObjectMap.Map(TypeClone.Clone(ReferenceRegistry.Deref(schema), {}), (schema) => {
+            schema.required = globalThis.Object.keys(schema.properties);
+            globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]));
+            return schema;
+        }, options);
+    }
+    /** `[Standard]` Creates a String type */
+    String(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'String', type: 'string' });
+    }
+    /** `[Standard]` Creates a Tuple type */
+    Tuple(items, options = {}) {
+        const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+        const clonedItems = items.map((item) => TypeClone.Clone(item, {}));
+        // prettier-ignore
+        const schema = (items.length > 0 ?
+            { ...options, [exports.Kind]: 'Tuple', type: 'array', items: clonedItems, additionalItems, minItems, maxItems } :
+            { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
+        return this.Create(schema);
+    }
+    Union(anyOf, options = {}) {
+        if (anyOf.length === 0)
+            return this.Never(options);
+        if (anyOf.length === 1)
+            return TypeClone.Clone(anyOf[0], options);
+        const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema, {}));
+        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: clonedAnyOf });
+    }
+    /** `[Standard]` Creates an Unknown type */
+    Unknown(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Unknown' });
+    }
+    /** `[Standard]` Creates a Unsafe type that infers for the generic argument */
+    Unsafe(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || 'Unsafe' });
+    }
+}
+exports.StandardTypeBuilder = StandardTypeBuilder;
+// --------------------------------------------------------------------------
+// TypeBuilder
+// --------------------------------------------------------------------------
+class ExtendedTypeBuilder extends StandardTypeBuilder {
+    /** `[Extended]` Creates a BigInt type */
+    BigInt(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'BigInt', type: 'null', typeOf: 'BigInt' });
+    }
+    /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
+    ConstructorParameters(schema, options = {}) {
+        return this.Tuple([...schema.parameters], { ...options });
+    }
+    Constructor(parameters, returns, options = {}) {
+        const clonedReturns = TypeClone.Clone(returns, {});
+        if (TypeGuard.TTuple(parameters)) {
+            const clonedParameters = parameters.items === undefined ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}));
+            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns });
+        }
+        else if (globalThis.Array.isArray(parameters)) {
+            const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
+            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns });
+        }
+        else {
+            throw new Error('ExtendedTypeBuilder.Constructor: Invalid parameters');
+        }
+    }
+    /** `[Extended]` Creates a Date type */
+    Date(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Date', type: 'object', instanceOf: 'Date' });
+    }
+    Function(parameters, returns, options = {}) {
+        const clonedReturns = TypeClone.Clone(returns, {});
+        if (TypeGuard.TTuple(parameters)) {
+            const clonedParameters = parameters.items === undefined ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}));
+            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns });
+        }
+        else if (globalThis.Array.isArray(parameters)) {
+            const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
+            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns });
+        }
+        else {
+            throw new Error('ExtendedTypeBuilder.Function: Invalid parameters');
+        }
+    }
+    /** `[Extended]` Extracts the InstanceType from the given Constructor */
+    InstanceType(schema, options = {}) {
+        return TypeClone.Clone(schema.returns, options);
+    }
+    /** `[Extended]` Extracts the Parameters from the given Function type */
+    Parameters(schema, options = {}) {
+        return this.Tuple(schema.parameters, { ...options });
+    }
+    /** `[Extended]` Creates a Promise type */
+    Promise(item, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'object', instanceOf: 'Promise', item: TypeClone.Clone(item, {}) });
+    }
+    /** `[Extended]` Creates a regular expression type */
+    RegEx(regex, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'String', type: 'string', pattern: regex.source });
+    }
+    /** `[Extended]` Extracts the ReturnType from the given Function */
+    ReturnType(schema, options = {}) {
+        return TypeClone.Clone(schema.returns, options);
+    }
+    /** `[Extended]` Creates a Symbol type */
+    Symbol(options) {
+        return this.Create({ ...options, [exports.Kind]: 'Symbol', type: 'null', typeOf: 'Symbol' });
+    }
+    /** `[Extended]` Creates a Undefined type */
+    Undefined(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Undefined', type: 'null', typeOf: 'Undefined' });
+    }
+    /** `[Extended]` Creates a Uint8Array type */
+    Uint8Array(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Uint8Array', type: 'object', instanceOf: 'Uint8Array' });
+    }
+    /** `[Extended]` Creates a Void type */
+    Void(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Void', type: 'null', typeOf: 'Void' });
+    }
+}
+exports.ExtendedTypeBuilder = ExtendedTypeBuilder;
+/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+exports.StandardType = new StandardTypeBuilder();
+/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+exports.Type = new ExtendedTypeBuilder();