typebox 1.0.33 → 1.0.34

package/build/cjs/schema/engine/minLength.js

@@ -1,30 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildMinLength = BuildMinLength;
-exports.CheckMinLength = CheckMinLength;
-exports.ErrorMinLength = ErrorMinLength;
-const index_1 = require("../../guard/index");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildMinLength(context, schema, value) {
-    return index_1.EmitGuard.IsGreaterEqualThan(index_1.EmitGuard.StringGraphemeCount(value), index_1.EmitGuard.Constant(schema.minLength));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckMinLength(context, schema, value) {
-    return index_1.Guard.IsGreaterEqualThan(index_1.Guard.StringGraphemeCount(value), schema.minLength);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorMinLength(context, schemaPath, instancePath, schema, value) {
-    return CheckMinLength(context, schema, value) || context.AddError({
-        keyword: 'minLength',
-        schemaPath,
-        instancePath,
-        params: { limit: schema.minLength }
-    });
-}

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

@@ -1,5 +0,0 @@
-import * as S from '../types/index';
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-export declare function BuildMinProperties(context: BuildContext, schema: S.XMinProperties, value: string): string;
-export declare function CheckMinProperties(context: CheckContext, schema: S.XMinProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorMinProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMinProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/cjs/schema/engine/minProperties.js

@@ -1,30 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildMinProperties = BuildMinProperties;
-exports.CheckMinProperties = CheckMinProperties;
-exports.ErrorMinProperties = ErrorMinProperties;
-const index_1 = require("../../guard/index");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildMinProperties(context, schema, value) {
-    return index_1.EmitGuard.IsGreaterEqualThan(index_1.EmitGuard.Member(index_1.EmitGuard.Keys(value), 'length'), index_1.EmitGuard.Constant(schema.minProperties));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckMinProperties(context, schema, value) {
-    return index_1.Guard.IsGreaterEqualThan(index_1.Guard.Keys(value).length, schema.minProperties);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorMinProperties(context, schemaPath, instancePath, schema, value) {
-    return CheckMinProperties(context, schema, value) || context.AddError({
-        keyword: 'minProperties',
-        schemaPath,
-        instancePath,
-        params: { limit: schema.minProperties },
-    });
-}

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

@@ -1,5 +0,0 @@
-import * as S from '../types/index';
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-export declare function BuildMinimum(context: BuildContext, schema: S.XMinimum, value: string): string;
-export declare function CheckMinimum(context: CheckContext, schema: S.XMinimum, value: number | bigint): boolean;
-export declare function ErrorMinimum(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMinimum, value: number | bigint): boolean;

package/build/cjs/schema/engine/minimum.js

@@ -1,30 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildMinimum = BuildMinimum;
-exports.CheckMinimum = CheckMinimum;
-exports.ErrorMinimum = ErrorMinimum;
-const index_1 = require("../../guard/index");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildMinimum(context, schema, value) {
-    return index_1.EmitGuard.IsGreaterEqualThan(value, index_1.EmitGuard.Constant(schema.minimum));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckMinimum(context, schema, value) {
-    return index_1.Guard.IsGreaterEqualThan(value, schema.minimum);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorMinimum(context, schemaPath, instancePath, schema, value) {
-    return CheckMinimum(context, schema, value) || context.AddError({
-        keyword: 'minimum',
-        schemaPath,
-        instancePath,
-        params: { comparison: '>=', limit: schema.minimum }
-    });
-}

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

@@ -1,5 +0,0 @@
-import * as S from '../types/index';
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-export declare function BuildMultipleOf(context: BuildContext, schema: S.XMultipleOf, value: string): string;
-export declare function CheckMultipleOf(context: CheckContext, schema: S.XMultipleOf, value: number | bigint): boolean;
-export declare function ErrorMultipleOf(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMultipleOf, value: number | bigint): boolean;

package/build/cjs/schema/engine/multipleOf.js

@@ -1,30 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildMultipleOf = BuildMultipleOf;
-exports.CheckMultipleOf = CheckMultipleOf;
-exports.ErrorMultipleOf = ErrorMultipleOf;
-const index_1 = require("../../guard/index");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildMultipleOf(context, schema, value) {
-    return index_1.EmitGuard.MultipleOf(value, index_1.EmitGuard.Constant(schema.multipleOf));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckMultipleOf(context, schema, value) {
-    return index_1.Guard.IsMultipleOf(value, schema.multipleOf);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorMultipleOf(context, schemaPath, instancePath, schema, value) {
-    return CheckMultipleOf(context, schema, value) || context.AddError({
-        keyword: 'multipleOf',
-        schemaPath,
-        instancePath,
-        params: { multipleOf: schema.multipleOf }
-    });
-}

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

@@ -1,5 +0,0 @@
-import * as S from '../types/index';
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-export declare function BuildNot(context: BuildContext, schema: S.XNot, value: string): string;
-export declare function CheckNot(context: CheckContext, schema: S.XNot, value: unknown): boolean;
-export declare function ErrorNot(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XNot, value: unknown): boolean;

package/build/cjs/schema/engine/not.js

@@ -1,41 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildNot = BuildNot;
-exports.CheckNot = CheckNot;
-exports.ErrorNot = ErrorNot;
-const index_1 = require("../../guard/index");
-const schema_1 = require("./schema");
-const _reducer_1 = require("./_reducer");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildNotUnevaluated(context, schema, value) {
-    return (0, _reducer_1.Reducer)(context, [schema.not], value, index_1.EmitGuard.Not(index_1.EmitGuard.IsEqual(index_1.EmitGuard.Member('results', 'length'), index_1.EmitGuard.Constant(1))));
-}
-function BuildNotFast(context, schema, value) {
-    return index_1.EmitGuard.Not((0, schema_1.BuildSchema)(context, schema.not, value));
-}
-function BuildNot(context, schema, value) {
-    return context.UseUnevaluated() ? BuildNotUnevaluated(context, schema, value) : BuildNotFast(context, schema, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckNot(context, schema, value) {
-    const condition = context.Clone();
-    const isSchema = !(0, schema_1.CheckSchema)(condition, schema.not, value);
-    const isNot = isSchema && context.Merge([condition]);
-    return isNot;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorNot(context, schemaPath, instancePath, schema, value) {
-    return CheckNot(context, schema, value) || context.AddError({
-        keyword: 'not',
-        schemaPath,
-        instancePath,
-        params: {},
-    });
-}

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

@@ -1,5 +0,0 @@
-import * as S from '../types/index';
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-export declare function BuildOneOf(context: BuildContext, schema: S.XOneOf, value: string): string;
-export declare function CheckOneOf(context: CheckContext, schema: S.XOneOf, value: unknown): boolean;
-export declare function ErrorOneOf(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XOneOf, value: unknown): boolean;

package/build/cjs/schema/engine/oneOf.js

@@ -1,63 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildOneOf = BuildOneOf;
-exports.CheckOneOf = CheckOneOf;
-exports.ErrorOneOf = ErrorOneOf;
-const index_1 = require("../../guard/index");
-const _context_1 = require("./_context");
-const schema_1 = require("./schema");
-const _reducer_1 = require("./_reducer");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildOneOfUnevaluated(context, schema, value) {
-    return (0, _reducer_1.Reducer)(context, schema.oneOf, value, index_1.EmitGuard.IsEqual(index_1.EmitGuard.Member('results', 'length'), index_1.EmitGuard.Constant(1)));
-}
-function BuildOneOfFast(context, schema, value) {
-    const results = index_1.EmitGuard.ArrayLiteral(schema.oneOf.map((schema) => (0, schema_1.BuildSchema)(context, schema, value)));
-    const count = index_1.EmitGuard.Call(index_1.EmitGuard.Member(results, 'reduce'), [
-        index_1.EmitGuard.ArrowFunction(['count', 'result'], index_1.EmitGuard.Ternary(index_1.EmitGuard.IsEqual('result', index_1.EmitGuard.Constant(true)), index_1.EmitGuard.PrefixIncrement('count'), 'count')),
-        index_1.EmitGuard.Constant(0),
-    ]);
-    return index_1.EmitGuard.IsEqual(count, index_1.EmitGuard.Constant(1));
-}
-function BuildOneOf(context, schema, value) {
-    return context.UseUnevaluated() ? BuildOneOfUnevaluated(context, schema, value) : BuildOneOfFast(context, schema, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckOneOf(context, schema, value) {
-    const passedContexts = schema.oneOf.reduce((result, schema) => {
-        const nextContext = context.Clone();
-        return (0, schema_1.CheckSchema)(nextContext, schema, value) ? [...result, nextContext] : result;
-    }, []);
-    return index_1.Guard.IsEqual(passedContexts.length, 1) && context.Merge(passedContexts);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorOneOf(context, schemaPath, instancePath, schema, value) {
-    const failedContexts = [];
-    const passingSchemas = [];
-    const passedContexts = schema.oneOf.reduce((result, schema, index) => {
-        const nextContext = new _context_1.AccumulatedErrorContext(context.GetContext(), context.GetSchema());
-        const nextSchemaPath = `${schemaPath}/oneOf/${index}`;
-        const isSchema = (0, schema_1.ErrorSchema)(nextContext, nextSchemaPath, instancePath, schema, value);
-        if (isSchema)
-            passingSchemas.push(index);
-        if (!isSchema)
-            failedContexts.push(nextContext);
-        return isSchema ? [...result, nextContext] : result;
-    }, []);
-    const isOneOf = index_1.Guard.IsEqual(passedContexts.length, 1) && context.Merge(passedContexts);
-    if (!isOneOf && index_1.Guard.IsEqual(passingSchemas.length, 0))
-        failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
-    return isOneOf || context.AddError({
-        keyword: 'oneOf',
-        schemaPath,
-        instancePath,
-        params: { passingSchemas },
-    });
-}

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

@@ -1,5 +0,0 @@
-import * as S from '../types/index';
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-export declare function BuildPattern(context: BuildContext, schema: S.XPattern, value: string): string;
-export declare function CheckPattern(context: CheckContext, schema: S.XPattern, value: string): boolean;
-export declare function ErrorPattern(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XPattern, value: string): boolean;

package/build/cjs/schema/engine/pattern.js

@@ -1,33 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildPattern = BuildPattern;
-exports.CheckPattern = CheckPattern;
-exports.ErrorPattern = ErrorPattern;
-const V = require("./_externals");
-const index_1 = require("../../guard/index");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildPattern(context, schema, value) {
-    const regexp = V.CreateExternalVariable(index_1.Guard.IsString(schema.pattern) ? new RegExp(schema.pattern) : schema.pattern);
-    return index_1.EmitGuard.Call(index_1.EmitGuard.Member(regexp, 'test'), [value]);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckPattern(context, schema, value) {
-    const regexp = index_1.Guard.IsString(schema.pattern) ? new RegExp(schema.pattern) : schema.pattern;
-    return regexp.test(value);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorPattern(context, schemaPath, instancePath, schema, value) {
-    return CheckPattern(context, schema, value) || context.AddError({
-        keyword: 'pattern',
-        schemaPath,
-        instancePath,
-        params: { pattern: schema.pattern }
-    });
-}

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

@@ -1,5 +0,0 @@
-import * as S from '../types/index';
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-export declare function BuildPatternProperties(context: BuildContext, schema: S.XPatternProperties, value: string): string;
-export declare function CheckPatternProperties(context: CheckContext, schema: S.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorPatternProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/cjs/schema/engine/patternProperties.js

@@ -1,47 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildPatternProperties = BuildPatternProperties;
-exports.CheckPatternProperties = CheckPatternProperties;
-exports.ErrorPatternProperties = ErrorPatternProperties;
-const V = require("./_externals");
-const index_1 = require("../../guard/index");
-const schema_1 = require("./schema");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildPatternProperties(context, schema, value) {
-    return index_1.EmitGuard.ReduceAnd(index_1.Guard.Entries(schema.patternProperties).map(([pattern, schema]) => {
-        const regexp = V.CreateExternalVariable(new RegExp(pattern));
-        const notKey = index_1.EmitGuard.Not(index_1.EmitGuard.Call(index_1.EmitGuard.Member(regexp, 'test'), ['key']));
-        const isSchema = (0, schema_1.BuildSchema)(context, schema, 'value');
-        const addKey = context.AddKey('key');
-        const guarded = context.UseUnevaluated() ? index_1.EmitGuard.Or(notKey, index_1.EmitGuard.And(isSchema, addKey)) : index_1.EmitGuard.Or(notKey, isSchema);
-        return index_1.EmitGuard.Every(index_1.EmitGuard.Entries(value), index_1.EmitGuard.Constant(0), ['[key, value]', '_'], guarded);
-    }));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckPatternProperties(context, schema, value) {
-    return index_1.Guard.Every(index_1.Guard.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
-        const regexp = new RegExp(pattern);
-        return index_1.Guard.Every(index_1.Guard.Entries(value), 0, ([key, value]) => {
-            return !regexp.test(key) || (0, schema_1.CheckSchema)(context, schema, value) && context.AddKey(key);
-        });
-    });
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorPatternProperties(context, schemaPath, instancePath, schema, value) {
-    return index_1.Guard.EveryAll(index_1.Guard.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
-        const nextSchemaPath = `${schemaPath}/patternProperties/${pattern}`;
-        const regexp = new RegExp(pattern);
-        return index_1.Guard.EveryAll(index_1.Guard.Entries(value), 0, ([key, value]) => {
-            const nextInstancePath = `${instancePath}/${key}`;
-            const notKey = !regexp.test(key);
-            return notKey || (0, schema_1.ErrorSchema)(context, nextSchemaPath, nextInstancePath, schema, value) && context.AddKey(key);
-        });
-    });
-}

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

@@ -1,5 +0,0 @@
-import * as S from '../types/index';
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-export declare function BuildPrefixItems(context: BuildContext, schema: S.XPrefixItems, value: string): string;
-export declare function CheckPrefixItems(context: CheckContext, schema: S.XPrefixItems, value: unknown[]): boolean;
-export declare function ErrorPrefixItems(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XPrefixItems, value: unknown[]): boolean;

package/build/cjs/schema/engine/prefixItems.js

@@ -1,40 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildPrefixItems = BuildPrefixItems;
-exports.CheckPrefixItems = CheckPrefixItems;
-exports.ErrorPrefixItems = ErrorPrefixItems;
-const index_1 = require("../../guard/index");
-const schema_1 = require("./schema");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildPrefixItems(context, schema, value) {
-    return index_1.EmitGuard.ReduceAnd(schema.prefixItems.map((schema, index) => {
-        const isLength = index_1.EmitGuard.IsLessEqualThan(index_1.EmitGuard.Member(value, 'length'), index_1.EmitGuard.Constant(index));
-        const isSchema = (0, schema_1.BuildSchema)(context, schema, `${value}[${index}]`);
-        const addIndex = context.AddIndex(index_1.EmitGuard.Constant(index));
-        const guarded = context.UseUnevaluated() ? index_1.EmitGuard.And(isSchema, addIndex) : isSchema;
-        return index_1.EmitGuard.Or(isLength, guarded);
-    }));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckPrefixItems(context, schema, value) {
-    return index_1.Guard.IsEqual(value.length, 0) || index_1.Guard.Every(schema.prefixItems, 0, (schema, index) => {
-        return index_1.Guard.IsLessEqualThan(value.length, index)
-            || ((0, schema_1.CheckSchema)(context, schema, value[index]) && context.AddIndex(index));
-    });
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorPrefixItems(context, schemaPath, instancePath, schema, value) {
-    return index_1.Guard.IsEqual(value.length, 0) || index_1.Guard.EveryAll(schema.prefixItems, 0, (schema, index) => {
-        const nextSchemaPath = `${schemaPath}/prefixItems/${index}`;
-        const nextInstancePath = `${instancePath}/${index}`;
-        return index_1.Guard.IsLessEqualThan(value.length, index)
-            || ((0, schema_1.ErrorSchema)(context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
-    });
-}

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

@@ -1,5 +0,0 @@
-import * as S from '../types/index';
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-export declare function BuildProperties(context: BuildContext, schema: S.XProperties, value: string): string;
-export declare function CheckProperties(context: CheckContext, schema: S.XProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/cjs/schema/engine/properties.js

@@ -1,80 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildProperties = BuildProperties;
-exports.CheckProperties = CheckProperties;
-exports.ErrorProperties = ErrorProperties;
-const index_1 = require("../../guard/index");
-const S = require("../types/index");
-const schema_1 = require("./schema");
-const _exact_optional_1 = require("./_exact_optional");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildProperties(context, schema, value) {
-    const required = S.IsRequired(schema) ? schema.required : [];
-    const everyKey = index_1.Guard.Entries(schema.properties).map(([key, schema]) => {
-        const notKey = index_1.EmitGuard.Not(index_1.EmitGuard.HasPropertyKey(value, index_1.EmitGuard.Constant(key)));
-        const isSchema = (0, schema_1.BuildSchema)(context, schema, index_1.EmitGuard.Member(value, key));
-        const addKey = context.AddKey(index_1.EmitGuard.Constant(key));
-        const guarded = context.UseUnevaluated() ? index_1.EmitGuard.And(isSchema, addKey) : isSchema;
-        // --------------------------------------------------------------
-        // Optimization
-        //
-        // If a key is required, we can skip the `notKey` check since this
-        // condition is already enforced by Required. This optimization is
-        // only valid when Required is evaluated before Properties.
-        //
-        // --------------------------------------------------------------
-        const isProperty = required.includes(key) ? guarded : index_1.EmitGuard.Or(notKey, guarded);
-        // --------------------------------------------------------------
-        // ExactOptionalProperties
-        //
-        // By default, TypeScript allows optional properties to be assigned
-        // undefined. This is a bit misleading, since 'optional' is usually
-        // understood to mean 'the key may be absent', not 'the key may be
-        // present with an undefined value'.
-        //
-        // The 'IsExactOptional' check returns false by default, matching
-        // TypeScript's behavior. When exactOptionalPropertyTypes is enabled
-        // in tsconfig.json, TypeBox can be configured to use the stricter 
-        // semantics via System settings:
-        //
-        //   Settings.Set({ exactOptionalPropertyTypes: true })
-        //
-        // --------------------------------------------------------------
-        return (0, _exact_optional_1.IsExactOptional)(required, key)
-            ? isProperty
-            : index_1.EmitGuard.Or((0, _exact_optional_1.InexactOptionalBuild)(value, key), isProperty);
-    });
-    return index_1.EmitGuard.ReduceAnd(everyKey);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckProperties(context, schema, value) {
-    const required = S.IsRequired(schema) ? schema.required : [];
-    const isProperties = index_1.Guard.Every(index_1.Guard.Entries(schema.properties), 0, ([key, schema]) => {
-        const isProperty = !index_1.Guard.HasPropertyKey(value, key) || ((0, schema_1.CheckSchema)(context, schema, value[key]) && context.AddKey(key));
-        return (0, _exact_optional_1.IsExactOptional)(required, key)
-            ? isProperty
-            : (0, _exact_optional_1.InexactOptionalCheck)(value, key) || isProperty;
-    });
-    return isProperties;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorProperties(context, schemaPath, instancePath, schema, value) {
-    const required = S.IsRequired(schema) ? schema.required : [];
-    const isProperties = index_1.Guard.EveryAll(index_1.Guard.Entries(schema.properties), 0, ([key, schema]) => {
-        const nextSchemaPath = `${schemaPath}/properties/${key}`;
-        const nextInstancePath = `${instancePath}/${key}`;
-        // Defer error generation for IsExactOptional
-        const isProperty = () => (!index_1.Guard.HasPropertyKey(value, key) || ((0, schema_1.ErrorSchema)(context, nextSchemaPath, nextInstancePath, schema, value[key]) && context.AddKey(key)));
-        return (0, _exact_optional_1.IsExactOptional)(required, key)
-            ? isProperty()
-            : (0, _exact_optional_1.InexactOptionalCheck)(value, key) || isProperty();
-    });
-    return isProperties;
-}

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

@@ -1,5 +0,0 @@
-import * as S from '../types/index';
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-export declare function BuildPropertyNames(context: BuildContext, schema: S.XPropertyNames, value: string): string;
-export declare function CheckPropertyNames(context: CheckContext, schema: S.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorPropertyNames(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;

package/build/cjs/schema/engine/propertyNames.js

@@ -1,42 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildPropertyNames = BuildPropertyNames;
-exports.CheckPropertyNames = CheckPropertyNames;
-exports.ErrorPropertyNames = ErrorPropertyNames;
-const index_1 = require("../../guard/index");
-const _context_1 = require("./_context");
-const schema_1 = require("./schema");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildPropertyNames(context, schema, value) {
-    return index_1.EmitGuard.Call(index_1.EmitGuard.Member(index_1.EmitGuard.Keys(value), 'every'), [index_1.EmitGuard.ArrowFunction(['key'], (0, schema_1.BuildSchema)(context, schema.propertyNames, 'key'))]);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckPropertyNames(context, schema, value) {
-    return index_1.Guard.Every(index_1.Guard.Keys(value), 0, (key) => (0, schema_1.CheckSchema)(context, schema.propertyNames, key));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorPropertyNames(context, schemaPath, instancePath, schema, value) {
-    const propertyNames = [];
-    const isPropertyNames = index_1.Guard.EveryAll(index_1.Guard.Keys(value), 0, (key) => {
-        const nextInstancePath = `${instancePath}/${key}`;
-        const nextSchemaPath = `${schemaPath}/propertyNames`;
-        const nextContext = new _context_1.AccumulatedErrorContext(context.GetContext(), context.GetSchema());
-        const isPropertyName = (0, schema_1.ErrorSchema)(nextContext, nextSchemaPath, nextInstancePath, schema.propertyNames, key);
-        if (!isPropertyName)
-            propertyNames.push(key);
-        return isPropertyName;
-    });
-    return isPropertyNames || context.AddError({
-        keyword: 'propertyNames',
-        schemaPath,
-        instancePath,
-        params: { propertyNames }
-    });
-}

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

@@ -1,5 +0,0 @@
-import * as S from '../types/index';
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-export declare function BuildRef(context: BuildContext, schema: S.XRef, value: string): string;
-export declare function CheckRef(context: CheckContext, schema: S.XRef, value: unknown): boolean;
-export declare function ErrorRef(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRef, value: unknown): boolean;

package/build/cjs/schema/engine/ref.js

@@ -1,48 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildRef = BuildRef;
-exports.CheckRef = CheckRef;
-exports.ErrorRef = ErrorRef;
-const F = require("./_functions");
-const S = require("../types/index");
-const index_1 = require("../../guard/index");
-const schema_1 = require("./schema");
-const index_2 = require("../deref/index");
-// ------------------------------------------------------------------
-// Resolve
-// ------------------------------------------------------------------
-function Resolve(context, schema) {
-    // note: it is safe to coerce to XSchema here as it wouldn't be possible
-    // to enter a ref resolution if the root schema was boolean.
-    const schemaRoot = context.GetSchema();
-    // contextual schema
-    const schemaContext = context.GetContext();
-    if (index_1.Guard.HasPropertyKey(schemaContext, schema.$ref)) {
-        return schemaContext[schema.$ref];
-    }
-    // inline referential schema
-    const dereferenced = (0, index_2.Deref)(schemaRoot, { $ref: schema.$ref });
-    return S.IsSchemaLike(dereferenced) ? dereferenced : false;
-}
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildRef(context, schema, value) {
-    const target = Resolve(context, schema);
-    return F.CreateFunction(context, target, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckRef(context, schema, value) {
-    const target = Resolve(context, schema);
-    return (S.IsSchemaLike(target) && (0, schema_1.CheckSchema)(context, target, value));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorRef(context, schemaPath, instancePath, schema, value) {
-    const target = Resolve(context, schema);
-    return (S.IsSchemaLike(target) && (0, schema_1.ErrorSchema)(context, '#', instancePath, target, value));
-}

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

@@ -1,5 +0,0 @@
-import * as S from '../types/index';
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-export declare function BuildRequired(context: BuildContext, schema: S.XRequired, value: string): string;
-export declare function CheckRequired(context: CheckContext, schema: S.XRequired, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorRequired(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRequired, value: Record<PropertyKey, unknown>): boolean;