@depup/typebox 1.1.6-depup.0

package/build/guard/native.d.mts

@@ -0,0 +1,20 @@
+/** 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/guard/native.mjs

@@ -0,0 +1,60 @@
+import * as Guard from './guard.mjs';
+// --------------------------------------------------------------------------
+// Native
+// --------------------------------------------------------------------------
+/** Returns true if this value is a F32 */
+export function IsF32(value) {
+    return Guard.IsNumber(value) &&
+        Guard.IsEqual(value, Math.fround(value));
+}
+/** Returns true if this value is a F64 */
+export function IsF64(value) {
+    return Guard.IsNumber(value);
+}
+/** Returns true if this value is a U8 */
+export function IsU8(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, 0) &&
+        Guard.IsLessEqualThan(value, 255);
+}
+/** Returns true if this value is a U16 */
+export function IsU16(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, 0) &&
+        Guard.IsLessEqualThan(value, 65535);
+}
+/** Returns true if this value is a U32 */
+export function IsU32(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, 0) &&
+        Guard.IsLessEqualThan(value, 4294967295);
+}
+/** Returns true if this value is a U64 */
+export function IsU64(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, 0);
+}
+/** Returns true if this value is a I8 */
+export function IsI8(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, -128) &&
+        Guard.IsLessEqualThan(value, 127);
+}
+/** Returns true if this value is a I16 */
+export function IsI16(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, -32768) &&
+        Guard.IsLessEqualThan(value, 32767);
+}
+/** Returns true if this value is a I32 */
+export function IsI32(value) {
+    return Guard.IsInteger(value) &&
+        Guard.IsGreaterEqualThan(value, -2147483648) &&
+        Guard.IsLessEqualThan(value, 2147483647);
+}
+/** Returns true if this value is a I64 */
+export function IsI64(value) {
+    return Guard.IsBigInt(value) &&
+        Guard.IsGreaterEqualThan(value, BigInt('-9223372036854775808')) &&
+        Guard.IsLessEqualThan(value, BigInt('9223372036854775807'));
+}

package/build/guard/string.d.mts

@@ -0,0 +1,10 @@
+/** Returns the number of grapheme clusters in a string */
+export declare function GraphemeCount(value: string): number;
+/** Checks if a string has at least a minimum number of grapheme clusters */
+export declare function IsMinLength(value: string, minLength: number): boolean;
+/** Checks if a string has at most a maximum number of grapheme clusters */
+export declare function IsMaxLength(value: string, maxLength: number): boolean;
+/** Fast check for minimum grapheme length, falls back to full check if needed */
+export declare function IsMinLengthFast(value: string, minLength: number): boolean;
+/** Fast check for maximum grapheme length, falls back to full check if needed */
+export declare function IsMaxLengthFast(value: string, maxLength: number): boolean;

package/build/guard/string.mjs

@@ -0,0 +1,158 @@
+// --------------------------------------------------------------------------
+// IsBetween
+// --------------------------------------------------------------------------
+function IsBetween(value, min, max) {
+    return value >= min && value <= max;
+}
+// --------------------------------------------------------------------------
+// IsRegionalIndicator
+// --------------------------------------------------------------------------
+function IsRegionalIndicator(value) {
+    return IsBetween(value, 0x1F1E6, 0x1F1FF);
+}
+// --------------------------------------------------------------------------
+// IsVariationSelector
+// --------------------------------------------------------------------------
+function IsVariationSelector(value) {
+    return IsBetween(value, 0xFE00, 0xFE0F);
+}
+// --------------------------------------------------------------------------
+// IsCombiningMark
+// --------------------------------------------------------------------------
+function IsCombiningMark(value) {
+    return (IsBetween(value, 0x0300, 0x036F) ||
+        IsBetween(value, 0x1AB0, 0x1AFF) ||
+        IsBetween(value, 0x1DC0, 0x1DFF) ||
+        IsBetween(value, 0xFE20, 0xFE2F));
+}
+// --------------------------------------------------------------------------
+// CodePointLength
+// --------------------------------------------------------------------------
+function CodePointLength(value) {
+    return value > 0xFFFF ? 2 : 1;
+}
+// --------------------------------------------------------------------------
+// ConsumeModifiers (helper)
+// --------------------------------------------------------------------------
+function ConsumeModifiers(value, index) {
+    while (index < value.length) {
+        const point = value.codePointAt(index);
+        if (IsCombiningMark(point) || IsVariationSelector(point)) {
+            index += CodePointLength(point);
+        }
+        else {
+            break;
+        }
+    }
+    return index;
+}
+// --------------------------------------------------------------------------
+// NextGraphemeClusterIndex
+// --------------------------------------------------------------------------
+function NextGraphemeClusterIndex(value, clusterStart) {
+    const startCP = value.codePointAt(clusterStart);
+    let clusterEnd = clusterStart + CodePointLength(startCP);
+    // Consume combining marks & variation selectors
+    clusterEnd = ConsumeModifiers(value, clusterEnd);
+    // Handle multi-ZWJ sequences
+    while (clusterEnd < value.length - 1 && value[clusterEnd] === '\u200D') {
+        const nextCP = value.codePointAt(clusterEnd + 1);
+        clusterEnd += 1 + CodePointLength(nextCP);
+        clusterEnd = ConsumeModifiers(value, clusterEnd);
+    }
+    // Handle regional indicator pairs (flags)
+    if (IsRegionalIndicator(startCP) &&
+        clusterEnd < value.length &&
+        IsRegionalIndicator(value.codePointAt(clusterEnd))) {
+        clusterEnd += CodePointLength(value.codePointAt(clusterEnd));
+    }
+    return clusterEnd;
+}
+// --------------------------------------------------------------------------
+// IsGraphemeCodePoint
+// --------------------------------------------------------------------------
+function IsGraphemeCodePoint(value) {
+    return (IsBetween(value, 0xD800, 0xDBFF) || // High surrogate
+        IsBetween(value, 0x0300, 0x036F) || // Combining diacritical marks
+        (value === 0x200D) // Zero-width joiner
+    );
+}
+// --------------------------------------------------------------------------
+// GraphemeCount
+// --------------------------------------------------------------------------
+/** Returns the number of grapheme clusters in a string */
+export function GraphemeCount(value) {
+    let count = 0;
+    let index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+    }
+    return count;
+}
+// --------------------------------------------------------------------------
+// IsMinLength
+// --------------------------------------------------------------------------
+/** Checks if a string has at least a minimum number of grapheme clusters */
+export function IsMinLength(value, minLength) {
+    if (minLength === 0)
+        return true; // 0-length
+    let count = 0;
+    let index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+        if (count >= minLength)
+            return true;
+    }
+    return false;
+}
+// --------------------------------------------------------------------------
+// IsMaxLength
+// --------------------------------------------------------------------------
+/** Checks if a string has at most a maximum number of grapheme clusters */
+export function IsMaxLength(value, maxLength) {
+    let count = 0;
+    let index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+        if (count > maxLength)
+            return false;
+    }
+    return true;
+}
+// --------------------------------------------------------------------------
+// IsMinLengthFast
+// --------------------------------------------------------------------------
+/** Fast check for minimum grapheme length, falls back to full check if needed */
+export function IsMinLengthFast(value, minLength) {
+    if (minLength === 0)
+        return true; // 0-length
+    let index = 0;
+    while (index < value.length) {
+        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
+            return IsMinLength(value, minLength);
+        }
+        index++;
+        if (index >= minLength)
+            return true;
+    }
+    return false;
+}
+// --------------------------------------------------------------------------
+// IsMaxLengthFast
+// --------------------------------------------------------------------------
+/** Fast check for maximum grapheme length, falls back to full check if needed */
+export function IsMaxLengthFast(value, maxLength) {
+    let index = 0;
+    while (index < value.length) {
+        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
+            return IsMaxLength(value, maxLength);
+        }
+        index++;
+        if (index > maxLength)
+            return false;
+    }
+    return true;
+}

package/build/index.d.mts

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

package/build/index.mjs

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

package/build/schema/build.d.mts

@@ -0,0 +1,35 @@
+import * as Engine from './engine/index.mjs';
+import * as Schema from './types/index.mjs';
+export type CheckFunction = (value: unknown) => boolean;
+export interface EvaluateResult {
+    IsAccelerated: 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, Schema.XSchema>, schema: Schema.XSchema, external: Engine.TExternal, functions: string[], call: string, useUnevaluated: boolean);
+    /** Returns the Context used for this build */
+    Context(): Record<PropertyKey, Schema.XSchema>;
+    /** Returns the Schema used for this build */
+    Schema(): Schema.XSchema;
+    /** 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: Schema.XSchema): BuildResult;
+/** Builds a schema into a optimized runtime validator */
+export declare function Build(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema): BuildResult;

package/build/schema/build.mjs

@@ -0,0 +1,99 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Environment } from '../system/environment/index.mjs';
+import { Hashing } from '../system/hashing/index.mjs';
+import { Guard } from '../guard/index.mjs';
+import { Format } from '../format/index.mjs';
+import * as Engine from './engine/index.mjs';
+// ------------------------------------------------------------------
+// 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, Guard, Format, Hashing, build.External().variables);
+}
+// ------------------------------------------------------------------
+// CreateDynamicCheck
+// ------------------------------------------------------------------
+function CreateDynamicCheck(build) {
+    const stack = new Engine.Stack(build.Context(), build.Schema());
+    const context = new Engine.CheckContext();
+    return (value) => Engine.CheckSchema(stack, context, build.Schema(), value);
+}
+// ------------------------------------------------------------------
+// CreateCheck
+// ------------------------------------------------------------------
+function CreateCheck(build, code) {
+    return Environment.CanAccelerate()
+        ? CreateEvaluatedCheck(build, code)
+        : CreateDynamicCheck(build);
+}
+// ------------------------------------------------------------------
+// BuildResult
+// ------------------------------------------------------------------
+export 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 { IsAccelerated: Environment.CanAccelerate(), Code, Check };
+    }
+}
+/** Builds a schema into a optimized runtime validator */
+export function Build(...args) {
+    const [context, schema] = Arguments.Match(args, {
+        2: (context, schema) => [context, schema],
+        1: (schema) => [{}, schema]
+    });
+    Engine.ResetExternal();
+    Engine.ResetFunctions();
+    const stack = new Engine.Stack(context, schema);
+    const build = new Engine.BuildContext(Engine.HasUnevaluated(context, schema));
+    const call = Engine.CreateFunction(stack, build, schema, 'value');
+    const functions = Engine.GetFunctions();
+    const externals = Engine.GetExternal();
+    return new BuildResult(context, schema, externals, functions, call, build.UseUnevaluated());
+}

package/build/schema/check.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from './types/index.mjs';
+import * as Static from './static/index.mjs';
+/** Checks a value against the provided schema */
+export declare function Check<const Schema extends Schema.XSchema>(schema: Schema, value: unknown): value is Static.XStatic<Schema>;
+/** Checks a value against the provided schema */
+export declare function Check<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema, value: unknown): value is Static.XStatic<Schema>;

package/build/schema/check.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import * as Engine from './engine/index.mjs';
+/** Checks a value against the provided schema */
+export function Check(...args) {
+    const [context, schema, value] = Arguments.Match(args, {
+        3: (context, schema, value) => [context, schema, value],
+        2: (schema, value) => [{}, schema, value]
+    });
+    const stack = new Engine.Stack(context, schema);
+    const checkContext = new Engine.CheckContext();
+    return Engine.CheckSchema(stack, checkContext, schema, value);
+}

package/build/schema/compile.d.mts

@@ -0,0 +1,22 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import * as Schema from './types/index.mjs';
+import * as Static from './static/index.mjs';
+export declare class Validator<Schema extends Schema.XSchema = Schema.XSchema, Value extends unknown = Static.XStatic<Schema>> {
+    private readonly build;
+    private readonly result;
+    constructor(context: Record<string, Schema.XSchema>, schema: Schema);
+    /** Returns true if this Validator is using JIT acceleration. */
+    IsAccelerated(): boolean;
+    /** Returns the underlying Schema used to construct this Validator. */
+    Schema(): Schema;
+    /** Performs a type-guard check on the provided value. */
+    Check(value: unknown): value is Value;
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value: unknown): Value;
+    /** Inspects a value and returns a detailed list of validation errors. */
+    Errors(value: unknown): [result: boolean, errors: TLocalizedValidationError[]];
+}
+/** Compiles this schema into a high performance Validator */
+export declare function Compile<const Schema extends Schema.XSchema>(schema: Schema): Validator<Schema>;
+/** Compiles this schema into a high performance Validator */
+export declare function Compile<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema): Validator<Schema>;

package/build/schema/compile.mjs

@@ -0,0 +1,46 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import * as Build from './build.mjs';
+import { Errors } from './errors.mjs';
+import { ParseError } from './parse.mjs';
+// ------------------------------------------------------------------
+// Validator
+// ------------------------------------------------------------------
+export class Validator {
+    constructor(context, schema) {
+        this.build = Build.Build(context, schema);
+        this.result = this.build.Evaluate();
+    }
+    /** Returns true if this Validator is using JIT acceleration. */
+    IsAccelerated() {
+        return this.result.IsAccelerated;
+    }
+    /** Returns the underlying Schema used to construct this Validator. */
+    Schema() {
+        return this.build.Schema();
+    }
+    /** Performs a type-guard check on the provided value. */
+    Check(value) {
+        return this.result.Check(value);
+    }
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value) {
+        if (this.result.Check(value))
+            return value;
+        const [_result, errors] = Errors(this.build.Context(), this.build.Schema(), value);
+        throw new ParseError(this.build.Schema(), value, errors);
+    }
+    /** Inspects a value and returns a detailed list of validation errors. */
+    Errors(value) {
+        return Errors(this.build.Context(), this.build.Schema(), value);
+    }
+}
+/** Compiles this schema into a high performance Validator */
+export function Compile(...args) {
+    const [context, schema] = Arguments.Match(args, {
+        2: (context, schema) => [context, schema],
+        1: (schema) => [{}, schema]
+    });
+    return new Validator(context, schema);
+}

package/build/schema/engine/_context.d.mts

@@ -0,0 +1,32 @@
+import type { TValidationError } from '../../error/index.mjs';
+export declare function HasUnevaluated(context: Record<PropertyKey, unknown>, schema: unknown): boolean;
+export declare class BuildContext {
+    private readonly hasUnevaluated;
+    constructor(hasUnevaluated: boolean);
+    UseUnevaluated(): boolean;
+    AddIndex(index: string): string;
+    AddKey(key: string): string;
+    Merge(results: string): string;
+}
+export declare class CheckContext {
+    private readonly indices;
+    private readonly keys;
+    constructor();
+    AddIndex(index: number): true;
+    AddKey(key: string): true;
+    GetIndices(): Set<number>;
+    GetKeys(): Set<string>;
+    Merge(results: CheckContext[]): true;
+}
+export type ErrorContextCallback = (error: TValidationError) => unknown;
+export declare class ErrorContext extends CheckContext {
+    private readonly callback;
+    constructor(callback: ErrorContextCallback);
+    AddError(error: TValidationError): false;
+}
+export declare class AccumulatedErrorContext extends ErrorContext {
+    private readonly errors;
+    constructor();
+    AddError(error: TValidationError): false;
+    GetErrors(): TValidationError[];
+}

package/build/schema/engine/_context.mjs

@@ -0,0 +1,98 @@
+// deno-fmt-ignore-file
+import * as Schema from '../types/index.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// HasUnevaluated
+// ------------------------------------------------------------------
+function HasUnevaluatedFromObject(value) {
+    return (Schema.IsUnevaluatedItems(value)
+        || Schema.IsUnevaluatedProperties(value)
+        || G.Keys(value).some(key => HasUnevaluatedFromUnknown(value[key])));
+}
+function HasUnevaluatedFromArray(value) {
+    return value.some(value => HasUnevaluatedFromUnknown(value));
+}
+function HasUnevaluatedFromUnknown(value) {
+    return (G.IsArray(value) ? HasUnevaluatedFromArray(value) :
+        G.IsObject(value) ? HasUnevaluatedFromObject(value) :
+            false);
+}
+export function HasUnevaluated(context, schema) {
+    return HasUnevaluatedFromUnknown(schema) || G.Keys(context).some(key => HasUnevaluatedFromUnknown(context[key]));
+}
+// ------------------------------------------------------------------
+// BuildContext
+// ------------------------------------------------------------------
+export class BuildContext {
+    constructor(hasUnevaluated) {
+        this.hasUnevaluated = hasUnevaluated;
+    }
+    UseUnevaluated() {
+        return this.hasUnevaluated;
+    }
+    AddIndex(index) {
+        return E.Call(E.Member('context', 'AddIndex'), [index]);
+    }
+    AddKey(key) {
+        return E.Call(E.Member('context', 'AddKey'), [key]);
+    }
+    Merge(results) {
+        return E.Call(E.Member('context', 'Merge'), [results]);
+    }
+}
+// ------------------------------------------------------------------
+// CheckContext
+// ------------------------------------------------------------------
+export class CheckContext {
+    constructor() {
+        this.indices = new Set();
+        this.keys = new Set();
+    }
+    AddIndex(index) {
+        this.indices.add(index);
+        return true;
+    }
+    AddKey(key) {
+        this.keys.add(key);
+        return true;
+    }
+    GetIndices() {
+        return this.indices;
+    }
+    GetKeys() {
+        return this.keys;
+    }
+    Merge(results) {
+        for (const context of results) {
+            context.indices.forEach(value => this.indices.add(value));
+            context.keys.forEach(value => this.keys.add(value));
+        }
+        return true;
+    }
+}
+export class ErrorContext extends CheckContext {
+    constructor(callback) {
+        super();
+        this.callback = callback;
+    }
+    AddError(error) {
+        this.callback(error);
+        return false;
+    }
+}
+// ------------------------------------------------------------------
+// AccumulatedErrorContext
+// ------------------------------------------------------------------
+export class AccumulatedErrorContext extends ErrorContext {
+    constructor() {
+        super(error => this.errors.push(error));
+        this.errors = [];
+    }
+    AddError(error) {
+        this.errors.push(error);
+        return false;
+    }
+    GetErrors() {
+        return this.errors;
+    }
+}

package/build/schema/engine/_exact_optional.d.mts

@@ -0,0 +1,3 @@
+export declare function IsExactOptional(required: string[], key: string): boolean;
+export declare function InexactOptionalBuild(value: string, key: string): string;
+export declare function InexactOptionalCheck(value: Record<PropertyKey, unknown>, key: string): boolean;

package/build/schema/engine/_exact_optional.mjs

@@ -0,0 +1,20 @@
+import { Settings } from '../../system/settings/index.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// IsExactOptional
+// ------------------------------------------------------------------
+export function IsExactOptional(required, key) {
+    return required.includes(key) || Settings.Get().exactOptionalPropertyTypes;
+}
+// ------------------------------------------------------------------
+// ExactOptionalBuild
+// ------------------------------------------------------------------
+export function InexactOptionalBuild(value, key) {
+    return E.IsUndefined(E.Member(value, key));
+}
+// ------------------------------------------------------------------
+// ExactOptionalCheck
+// ------------------------------------------------------------------
+export function InexactOptionalCheck(value, key) {
+    return G.IsUndefined(value[key]);
+}