typebox 1.0.33 → 1.0.34

package/build/cjs/guard/guard.d.ts

@@ -1,59 +0,0 @@
-/** Returns true if this value is an array */
-export declare function IsArray(value: unknown): value is unknown[];
-/** Returns true if this value is an async iterator */
-export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown>;
-/** Returns true if this value is bigint */
-export declare function IsBigInt(value: unknown): value is bigint;
-/** Returns true if this value is a boolean */
-export declare function IsBoolean(value: unknown): value is boolean;
-/** Returns true if this value is a constructor */
-export declare function IsConstructor(value: unknown): value is new (...args: never[]) => unknown;
-/** Returns true if this value is a function */
-export declare function IsFunction(value: unknown): value is Function;
-/** Returns true if this value is integer */
-export declare function IsInteger(value: unknown): value is number;
-/** Returns true if this value is an iterator */
-export declare function IsIterator(value: unknown): value is IterableIterator<unknown>;
-/** Returns true if this value is null */
-export declare function IsNull(value: unknown): value is null;
-/** Returns true if this value is number */
-export declare function IsNumber(value: unknown): value is number;
-/** Returns true if this value is an object but not an array */
-export declare function IsObjectNotArray(value: unknown): value is Record<PropertyKey, unknown>;
-/** Returns true if this value is an object */
-export declare function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
-/** Returns true if this value is string */
-export declare function IsString(value: unknown): value is string;
-/** Returns true if this value is symbol */
-export declare function IsSymbol(value: unknown): value is symbol;
-/** Returns true if this value is undefined */
-export declare function IsUndefined(value: unknown): value is undefined;
-export declare function IsEqual(left: unknown, right: unknown): boolean;
-export declare function IsGreaterThan<Type extends number | bigint>(left: Type, right: Type): boolean;
-export declare function IsLessThan<Type extends number | bigint>(left: Type, right: Type): boolean;
-export declare function IsLessEqualThan<Type extends number | bigint>(left: Type, right: Type): boolean;
-export declare function IsGreaterEqualThan<Type extends number | bigint>(left: Type, right: Type): boolean;
-export declare function IsMultipleOf(dividend: bigint | number, divisor: bigint | number): boolean;
-/** Returns true if the value appears to be an instance of a class. */
-export declare function IsClassInstance(value: unknown): boolean;
-export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
-/** Returns the number of Unicode Grapheme Clusters */
-export declare function StringGraphemeCount(value: string): number;
-export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
-export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
-/** Returns true if this value has this property key */
-export declare function HasPropertyKey<Key extends PropertyKey>(value: object, key: Key): value is {
-    [_ in Key]: unknown;
-};
-/** Returns object entries as `[RegExp, Value][]` */
-export declare function EntriesRegExp<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [RegExp, Value][];
-/** Returns object entries as `[string, Value][]` */
-export declare function Entries<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [string, Value][];
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
-export declare function Keys(value: Record<PropertyKey, unknown>): string[];
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
-export declare function Symbols(value: Record<PropertyKey, unknown>): symbol[];
-/** Returns the property values for the given object via `Object.values()` */
-export declare function Values(value: Record<PropertyKey, unknown>): unknown[];
-/** Tests values for deep equality */
-export declare function IsDeepEqual(left: unknown, right: unknown): boolean;

package/build/cjs/guard/guard.js

@@ -1,233 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsArray = IsArray;
-exports.IsAsyncIterator = IsAsyncIterator;
-exports.IsBigInt = IsBigInt;
-exports.IsBoolean = IsBoolean;
-exports.IsConstructor = IsConstructor;
-exports.IsFunction = IsFunction;
-exports.IsInteger = IsInteger;
-exports.IsIterator = IsIterator;
-exports.IsNull = IsNull;
-exports.IsNumber = IsNumber;
-exports.IsObjectNotArray = IsObjectNotArray;
-exports.IsObject = IsObject;
-exports.IsString = IsString;
-exports.IsSymbol = IsSymbol;
-exports.IsUndefined = IsUndefined;
-exports.IsEqual = IsEqual;
-exports.IsGreaterThan = IsGreaterThan;
-exports.IsLessThan = IsLessThan;
-exports.IsLessEqualThan = IsLessEqualThan;
-exports.IsGreaterEqualThan = IsGreaterEqualThan;
-exports.IsMultipleOf = IsMultipleOf;
-exports.IsClassInstance = IsClassInstance;
-exports.IsValueLike = IsValueLike;
-exports.StringGraphemeCount = StringGraphemeCount;
-exports.Every = Every;
-exports.EveryAll = EveryAll;
-exports.HasPropertyKey = HasPropertyKey;
-exports.EntriesRegExp = EntriesRegExp;
-exports.Entries = Entries;
-exports.Keys = Keys;
-exports.Symbols = Symbols;
-exports.Values = Values;
-exports.IsDeepEqual = IsDeepEqual;
-// --------------------------------------------------------------------------
-// Guards
-// --------------------------------------------------------------------------
-/** Returns true if this value is an array */
-function IsArray(value) {
-    return Array.isArray(value);
-}
-/** Returns true if this value is an async iterator */
-function IsAsyncIterator(value) {
-    return IsObject(value) && Symbol.asyncIterator in value;
-}
-/** Returns true if this value is bigint */
-function IsBigInt(value) {
-    return IsEqual(typeof value, 'bigint');
-}
-/** Returns true if this value is a boolean */
-function IsBoolean(value) {
-    return IsEqual(typeof value, 'boolean');
-}
-/** Returns true if this value is a constructor */
-function IsConstructor(value) {
-    if (IsUndefined(value) || !IsFunction(value))
-        return false;
-    const result = Function.prototype.toString.call(value);
-    if (/^class\s/.test(result))
-        return true;
-    if (/\[native code\]/.test(result))
-        return true;
-    return false;
-}
-/** Returns true if this value is a function */
-function IsFunction(value) {
-    return IsEqual(typeof value, 'function');
-}
-/** Returns true if this value is integer */
-function IsInteger(value) {
-    return Number.isInteger(value);
-}
-/** Returns true if this value is an iterator */
-function IsIterator(value) {
-    return IsObject(value) && Symbol.iterator in value;
-}
-/** Returns true if this value is null */
-function IsNull(value) {
-    return IsEqual(value, null);
-}
-/** Returns true if this value is number */
-function IsNumber(value) {
-    return Number.isFinite(value);
-}
-/** Returns true if this value is an object but not an array */
-function IsObjectNotArray(value) {
-    return IsObject(value) && !IsArray(value);
-}
-/** Returns true if this value is an object */
-function IsObject(value) {
-    return IsEqual(typeof value, 'object') && !(IsNull(value));
-}
-/** Returns true if this value is string */
-function IsString(value) {
-    return IsEqual(typeof value, 'string');
-}
-/** Returns true if this value is symbol */
-function IsSymbol(value) {
-    return IsEqual(typeof value, 'symbol');
-}
-/** Returns true if this value is undefined */
-function IsUndefined(value) {
-    return IsEqual(value, undefined);
-}
-// --------------------------------------------------------------------------
-// Relational
-// --------------------------------------------------------------------------
-function IsEqual(left, right) {
-    return left === right;
-}
-function IsGreaterThan(left, right) {
-    return left > right;
-}
-function IsLessThan(left, right) {
-    return left < right;
-}
-function IsLessEqualThan(left, right) {
-    return left <= right;
-}
-function IsGreaterEqualThan(left, right) {
-    return left >= right;
-}
-// --------------------------------------------------------------------------
-// MultipleOf
-// --------------------------------------------------------------------------
-function IsMultipleOf(dividend, divisor) {
-    if (IsBigInt(dividend) || IsBigInt(divisor)) {
-        return BigInt(dividend) % BigInt(divisor) === 0n;
-    }
-    const tolerance = 1e-10;
-    if (!IsNumber(dividend))
-        return true;
-    if (IsInteger(dividend) && (1 / divisor) % 1 === 0)
-        return true;
-    const mod = dividend % divisor;
-    return Math.min(Math.abs(mod), Math.abs(mod - divisor)) < tolerance;
-}
-// ------------------------------------------------------------------
-// IsClassInstance
-// ------------------------------------------------------------------
-/** Returns true if the value appears to be an instance of a class. */
-function IsClassInstance(value) {
-    if (!IsObject(value))
-        return false;
-    const proto = globalThis.Object.getPrototypeOf(value);
-    if (IsNull(proto))
-        return false;
-    return IsEqual(typeof proto.constructor, 'function') &&
-        !(IsEqual(proto.constructor, globalThis.Object) ||
-            IsEqual(proto.constructor.name, 'Object'));
-}
-// ------------------------------------------------------------------
-// IsValueLike
-// ------------------------------------------------------------------
-function IsValueLike(value) {
-    return IsBigInt(value) ||
-        IsBoolean(value) ||
-        IsNull(value) ||
-        IsNumber(value) ||
-        IsString(value) ||
-        IsUndefined(value);
-}
-// --------------------------------------------------------------------------
-// String
-// --------------------------------------------------------------------------
-/** Returns the number of Unicode Grapheme Clusters */
-function StringGraphemeCount(value) {
-    return Array.from(value).length;
-}
-// --------------------------------------------------------------------------
-// Array
-// --------------------------------------------------------------------------
-function Every(value, offset, callback) {
-    for (let index = offset; index < value.length; index++) {
-        if (!callback(value[index], index))
-            return false;
-    }
-    return true;
-}
-function EveryAll(value, offset, callback) {
-    let result = true;
-    for (let index = offset; index < value.length; index++) {
-        if (!callback(value[index], index))
-            result = false;
-    }
-    return result;
-}
-// --------------------------------------------------------------------------
-// Object
-// --------------------------------------------------------------------------
-/** Returns true if this value has this property key */
-function HasPropertyKey(value, key) {
-    return Object.prototype.hasOwnProperty.call(value, key);
-}
-/** Returns object entries as `[RegExp, Value][]` */
-function EntriesRegExp(value) {
-    return Keys(value).map((key) => [new RegExp(`^${key}$`), value[key]]);
-}
-/** Returns object entries as `[string, Value][]` */
-function Entries(value) {
-    return Object.entries(value);
-}
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
-function Keys(value) {
-    return Object.getOwnPropertyNames(value);
-}
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
-function Symbols(value) {
-    return Object.getOwnPropertySymbols(value);
-}
-/** Returns the property values for the given object via `Object.values()` */
-function Values(value) {
-    return Object.values(value);
-}
-// ------------------------------------------------------------------
-// IsDeepEqual
-// ------------------------------------------------------------------
-function DeepEqualObject(left, right) {
-    if (!IsObject(right))
-        return false;
-    const keys = Keys(left);
-    return IsEqual(keys.length, Keys(right).length) &&
-        keys.every((key) => IsDeepEqual(left[key], right[key]));
-}
-function DeepEqualArray(left, right) {
-    return IsArray(right) && IsEqual(left.length, right.length) &&
-        left.every((_, index) => IsDeepEqual(left[index], right[index]));
-}
-/** Tests values for deep equality */
-function IsDeepEqual(left, right) {
-    return (IsArray(left) ? DeepEqualArray(left, right) : IsObject(left) ? DeepEqualObject(left, right) : IsEqual(left, right));
-}

package/build/cjs/guard/index.d.ts

@@ -1,6 +0,0 @@
-export * as EmitGuard from './emit';
-export * as GlobalsGuard from './globals';
-export * as NativeGuard from './native';
-import * as Guard from './guard';
-export * as Guard from './guard';
-export default Guard;

package/build/cjs/guard/index.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Guard = exports.NativeGuard = exports.GlobalsGuard = exports.EmitGuard = void 0;
-exports.EmitGuard = require("./emit");
-exports.GlobalsGuard = require("./globals");
-exports.NativeGuard = require("./native");
-const Guard = require("./guard");
-exports.Guard = require("./guard");
-exports.default = Guard;

package/build/cjs/guard/native.d.ts

@@ -1,20 +0,0 @@
-/** Returns true if this value is a F32 */
-export declare function IsF32(value: unknown): value is number;
-/** Returns true if this value is a F64 */
-export declare function IsF64(value: unknown): value is number;
-/** Returns true if this value is a U8 */
-export declare function IsU8(value: unknown): value is number;
-/** Returns true if this value is a U16 */
-export declare function IsU16(value: unknown): value is number;
-/** Returns true if this value is a U32 */
-export declare function IsU32(value: unknown): value is number;
-/** Returns true if this value is a U64 */
-export declare function IsU64(value: unknown): value is number;
-/** Returns true if this value is a I8 */
-export declare function IsI8(value: unknown): value is number;
-/** Returns true if this value is a I16 */
-export declare function IsI16(value: unknown): value is number;
-/** Returns true if this value is a I32 */
-export declare function IsI32(value: unknown): value is number;
-/** Returns true if this value is a I64 */
-export declare function IsI64(value: unknown): value is number | bigint;

package/build/cjs/guard/native.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsF32 = IsF32;
-exports.IsF64 = IsF64;
-exports.IsU8 = IsU8;
-exports.IsU16 = IsU16;
-exports.IsU32 = IsU32;
-exports.IsU64 = IsU64;
-exports.IsI8 = IsI8;
-exports.IsI16 = IsI16;
-exports.IsI32 = IsI32;
-exports.IsI64 = IsI64;
-const Guard = require("./guard");
-// --------------------------------------------------------------------------
-// Native
-// --------------------------------------------------------------------------
-/** Returns true if this value is a F32 */
-function IsF32(value) {
-    return Guard.IsNumber(value) &&
-        Guard.IsEqual(value, Math.fround(value));
-}
-/** Returns true if this value is a F64 */
-function IsF64(value) {
-    return Guard.IsNumber(value);
-}
-/** Returns true if this value is a U8 */
-function IsU8(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, 0) &&
-        Guard.IsLessEqualThan(value, 255);
-}
-/** Returns true if this value is a U16 */
-function IsU16(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, 0) &&
-        Guard.IsLessEqualThan(value, 65535);
-}
-/** Returns true if this value is a U32 */
-function IsU32(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, 0) &&
-        Guard.IsLessEqualThan(value, 4294967295);
-}
-/** Returns true if this value is a U64 */
-function IsU64(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, 0);
-}
-/** Returns true if this value is a I8 */
-function IsI8(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, -128) &&
-        Guard.IsLessEqualThan(value, 127);
-}
-/** Returns true if this value is a I16 */
-function IsI16(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, -32768) &&
-        Guard.IsLessEqualThan(value, 32767);
-}
-/** Returns true if this value is a I32 */
-function IsI32(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, -2147483648) &&
-        Guard.IsLessEqualThan(value, 2147483647);
-}
-/** Returns true if this value is a I64 */
-function IsI64(value) {
-    return Guard.IsBigInt(value) &&
-        Guard.IsGreaterEqualThan(value, BigInt('-9223372036854775808')) &&
-        Guard.IsLessEqualThan(value, BigInt('9223372036854775807'));
-}

package/build/cjs/index.d.ts

@@ -1,8 +0,0 @@
-export * from './type/action/index';
-export * from './type/engine/index';
-export * from './type/extends/index';
-export * from './type/script/index';
-export * from './type/types/index';
-export * as Type from './typebox';
-import * as Type from './typebox';
-export default Type;

package/build/cjs/index.js

@@ -1,31 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = void 0;
-// ------------------------------------------------------------------
-// Standard
-// ------------------------------------------------------------------
-__exportStar(require("./type/action/index"), exports);
-__exportStar(require("./type/engine/index"), exports);
-__exportStar(require("./type/extends/index"), exports);
-__exportStar(require("./type/script/index"), exports);
-__exportStar(require("./type/types/index"), exports);
-// ------------------------------------------------------------------
-// TypeBox
-// ------------------------------------------------------------------
-exports.Type = require("./typebox");
-const Type = require("./typebox");
-exports.default = Type;

package/build/cjs/schema/build.d.ts

@@ -1,35 +0,0 @@
-import * as Engine from './engine/index';
-import { type XSchemaLike } from './types/index';
-export type CheckFunction = (value: unknown) => boolean;
-export interface EvaluateResult {
-    IsEvaluated: boolean;
-    Code: string;
-    Check: CheckFunction;
-}
-export declare class BuildResult {
-    private readonly context;
-    private readonly schema;
-    private readonly external;
-    private readonly functions;
-    private readonly call;
-    private readonly useUnevaluated;
-    constructor(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike, external: Engine.TExternal, functions: string[], call: string, useUnevaluated: boolean);
-    /** Returns the Context used for this build */
-    Context(): Record<PropertyKey, XSchemaLike>;
-    /** Returns the Schema used for this build */
-    Schema(): XSchemaLike;
-    /** Returns true if this build requires a Unevaluated context */
-    UseUnevaluated(): boolean;
-    /** Returns external variables */
-    External(): Engine.TExternal;
-    /** Returns check functions */
-    Functions(): string[];
-    /** Return entry function call. */
-    Call(): string;
-    /** Evaluates the build into a validation function */
-    Evaluate(): EvaluateResult;
-}
-/** Builds a schema into a optimized runtime validator */
-export declare function Build(schema: XSchemaLike): BuildResult;
-/** Builds a schema into a optimized runtime validator */
-export declare function Build(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike): BuildResult;

package/build/cjs/schema/build.js

@@ -1,102 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildResult = void 0;
-exports.Build = Build;
-const index_1 = require("../system/arguments/index");
-const index_2 = require("../system/environment/index");
-const index_3 = require("../system/hashing/index");
-const index_4 = require("../guard/index");
-const index_5 = require("../format/index");
-const Engine = require("./engine/index");
-// ------------------------------------------------------------------
-// CreateCode
-// ------------------------------------------------------------------
-function CreateCode(build) {
-    const functions = build.Functions().join(';\n');
-    const statements = build.UseUnevaluated()
-        ? ['const context = new CheckContext({}, {})', `return ${build.Call()}`]
-        : [`return ${build.Call()}`];
-    return `${functions}; return (value) => { ${statements.join('; ')} }`;
-}
-// ------------------------------------------------------------------
-// CreateEvaluatedCheck
-// ------------------------------------------------------------------
-function CreateEvaluatedCheck(build, code) {
-    const factory = new globalThis.Function('CheckContext', 'Guard', 'Format', 'Hashing', build.External().identifier, code);
-    return factory(Engine.CheckContext, index_4.Guard, index_5.Format, index_3.Hashing, build.External().variables);
-}
-// ------------------------------------------------------------------
-// CreateDynamicCheck
-// ------------------------------------------------------------------
-function CreateDynamicCheck(build) {
-    const context = new Engine.CheckContext(build.Context(), build.Schema());
-    return (value) => Engine.CheckSchema(context, build.Schema(), value);
-}
-// ------------------------------------------------------------------
-// CreateCheck
-// ------------------------------------------------------------------
-function CreateCheck(build, code) {
-    return index_2.Environment.CanEvaluate()
-        ? CreateEvaluatedCheck(build, code)
-        : CreateDynamicCheck(build);
-}
-// ------------------------------------------------------------------
-// BuildResult
-// ------------------------------------------------------------------
-class BuildResult {
-    constructor(context, schema, external, functions, call, useUnevaluated) {
-        this.context = context;
-        this.schema = schema;
-        this.external = external;
-        this.functions = functions;
-        this.call = call;
-        this.useUnevaluated = useUnevaluated;
-    }
-    /** Returns the Context used for this build */
-    Context() {
-        return this.context;
-    }
-    /** Returns the Schema used for this build */
-    Schema() {
-        return this.schema;
-    }
-    /** Returns true if this build requires a Unevaluated context */
-    UseUnevaluated() {
-        return this.useUnevaluated;
-    }
-    /** Returns external variables */
-    External() {
-        return this.external;
-    }
-    /** Returns check functions */
-    Functions() {
-        return this.functions;
-    }
-    /** Return entry function call. */
-    Call() {
-        return this.call;
-    }
-    /** Evaluates the build into a validation function */
-    Evaluate() {
-        const Code = CreateCode(this);
-        const Check = CreateCheck(this, Code);
-        return { IsEvaluated: index_2.Environment.CanEvaluate(), Code, Check };
-    }
-}
-exports.BuildResult = BuildResult;
-/** Builds a schema into a optimized runtime validator */
-function Build(...args) {
-    const [context, schema] = index_1.Arguments.Match(args, {
-        2: (context, schema) => [context, schema],
-        1: (schema) => [{}, schema]
-    });
-    Engine.ResetExternal();
-    Engine.ResetFunctions();
-    const build = new Engine.BuildContext(context, schema, Engine.HasUnevaluated(context, schema));
-    const call = Engine.CreateFunction(build, schema, 'value');
-    const functions = Engine.GetFunctions();
-    const externals = Engine.GetExternal();
-    return new BuildResult(context, schema, externals, functions, call, build.UseUnevaluated());
-}

package/build/cjs/schema/check.d.ts

@@ -1,5 +0,0 @@
-import { XSchemaLike } from './types/index';
-/** Checks a value against the provided schema */
-export declare function Check(schema: XSchemaLike, value: unknown): boolean;
-/** Checks a value against the provided schema */
-export declare function Check(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike, value: unknown): boolean;

package/build/cjs/schema/check.js

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Check = Check;
-const index_1 = require("../system/arguments/index");
-const index_2 = require("./engine/index");
-/** Checks a value against the provided schema */
-function Check(...args) {
-    const [context, schema, value] = index_1.Arguments.Match(args, {
-        3: (context, schema, value) => [context, schema, value],
-        2: (schema, value) => [{}, schema, value]
-    });
-    return (0, index_2.CheckSchema)(new index_2.CheckContext(context, schema), schema, value);
-}

package/build/cjs/schema/deref/deref.d.ts

@@ -1,4 +0,0 @@
-import * as S from '../types/index';
-export declare function Rebase(baseUri: string, schema: S.XSchema): string;
-/** Deferences a schema with the given Ref */
-export declare function Deref(schema: object, ref: S.XRef): unknown | undefined;