typebox 0.0.1 → 1.0.0

package/build/schema/build.d.mts

@@ -0,0 +1,35 @@
+import * as Engine from './engine/index.mjs';
+import { type XSchemaLike } from './types/index.mjs';
+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/schema/build.mjs

@@ -0,0 +1,97 @@
+// 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 context = new Engine.CheckContext(build.Context(), build.Schema());
+    return (value) => Engine.CheckSchema(context, build.Schema(), value);
+}
+// ------------------------------------------------------------------
+// CreateCheck
+// ------------------------------------------------------------------
+function CreateCheck(build, code) {
+    return Environment.CanEvaluate()
+        ? 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 { IsEvaluated: Environment.CanEvaluate(), 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 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/schema/check.d.mts

@@ -0,0 +1,5 @@
+import { XSchemaLike } from './types/index.mjs';
+/** 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/schema/check.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { CheckSchema, CheckContext } 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]
+    });
+    return CheckSchema(new CheckContext(context, schema), schema, value);
+}

package/build/schema/deref/deref.d.mts

@@ -0,0 +1,4 @@
+import * as S from '../types/index.mjs';
+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;

package/build/schema/deref/deref.mjs

@@ -0,0 +1,77 @@
+import { Guard } from '../../guard/index.mjs';
+import { IsJsonPointer, IsUri } from '../../format/index.mjs';
+import { Pointer } from '../../value/pointer/index.mjs';
+import * as S from '../types/index.mjs';
+// ------------------------------------------------------------------
+// Rebase
+// ------------------------------------------------------------------
+export function Rebase(baseUri, schema) {
+    if (!S.IsId(schema))
+        return baseUri;
+    if (IsUri(schema.$id))
+        return schema.$id;
+    if (!IsUri(schema.$id) && IsUri(baseUri)) {
+        return new URL(schema.$id, baseUri).href;
+    }
+    return baseUri;
+}
+// ------------------------------------------------------------------
+// Select
+// ------------------------------------------------------------------
+function IsHashPointer(value) {
+    return IsHash(value) && IsJsonPointer(value.slice(1));
+}
+function IsHash(value) {
+    return value.length > 0 && value[0] === '#';
+}
+function Select(schema, baseUri, $ref) {
+    if (IsUri(baseUri)) {
+        const [base, ref] = [new URL(baseUri), new URL($ref, baseUri)];
+        const matched = base.pathname === ref.pathname;
+        const withHash = IsHash(ref.hash);
+        if (matched && !withHash) {
+            return schema;
+        }
+    }
+    if (IsHashPointer($ref)) {
+        const target = Pointer.Get(schema, $ref.slice(1));
+        if (S.IsSchemaLike(target))
+            return target;
+    }
+    return undefined;
+}
+// ------------------------------------------------------------------
+// Traversal
+// ------------------------------------------------------------------
+function FromObject(schema, baseUrl, ref) {
+    // ----------------------------------------------------------------
+    // TypeBox: Fast TCyclic Deref
+    // ----------------------------------------------------------------
+    if (S.IsDefs(schema) && Guard.HasPropertyKey(schema.$defs, ref.$ref)) {
+        return schema.$defs[ref.$ref];
+    }
+    // ----------------------------------------------------------------
+    // Json Schema
+    // ----------------------------------------------------------------
+    const rebase = Rebase(baseUrl, schema);
+    const target = Select(schema, rebase, ref.$ref);
+    if (S.IsSchemaLike(target))
+        return target;
+    // Keep searching ...
+    return Object.values(schema).reduce((result, subschema) => result || FromValue(subschema, rebase, ref), undefined);
+}
+function FromArray(schema, baseUri, ref) {
+    return schema.reduce((result, value) => result || FromValue(value, baseUri, ref), undefined);
+}
+function FromValue(schema, base, ref) {
+    return ((Guard.IsObject(schema) && FromObject(schema, base, ref)) ||
+        (Guard.IsArray(schema) && FromArray(schema, base, ref)) ||
+        undefined);
+}
+// ------------------------------------------------------------------
+// Deref
+// ------------------------------------------------------------------
+/** Deferences a schema with the given Ref */
+export function Deref(schema, ref) {
+    return FromValue(schema, '', ref);
+}

package/build/schema/deref/index.d.mts

@@ -0,0 +1 @@
+export { Deref } from './deref.mjs';

package/build/schema/deref/index.mjs

@@ -0,0 +1 @@
+export { Deref } from './deref.mjs';

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

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

package/build/schema/engine/_context.mjs

@@ -0,0 +1,121 @@
+// deno-fmt-ignore-file
+import * as S from '../types/index.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// HasUnevaluated
+// ------------------------------------------------------------------
+function HasUnevaluatedFromObject(value) {
+    return (S.IsUnevaluatedItems(value)
+        || S.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]));
+}
+// ------------------------------------------------------------------
+// BaseContext
+// ------------------------------------------------------------------
+export class BaseContext {
+    constructor(context, schema) {
+        this.context = context;
+        this.schema = schema;
+    }
+    GetContext() {
+        return this.context;
+    }
+    GetSchema() {
+        return this.schema;
+    }
+}
+// ------------------------------------------------------------------
+// BuildContext
+// ------------------------------------------------------------------
+export class BuildContext extends BaseContext {
+    constructor(context, schema, hasUnevaluated) {
+        super(context, schema);
+        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]);
+    }
+    Clone() {
+        return E.Call(E.Member('context', 'Clone'), []);
+    }
+    Merge(results) {
+        return E.Call(E.Member('context', 'Merge'), [results]);
+    }
+}
+// ------------------------------------------------------------------
+// CheckContext
+// ------------------------------------------------------------------
+export class CheckContext extends BaseContext {
+    constructor(context, schema) {
+        super(context, schema);
+        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;
+    }
+    Clone() {
+        return new CheckContext(this.context, this.schema);
+    }
+    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(context, schema, callback) {
+        super(context, schema);
+        this.callback = callback;
+    }
+    AddError(error) {
+        this.callback(error);
+        return false;
+    }
+}
+// ------------------------------------------------------------------
+// AccumulatedErrorContext
+// ------------------------------------------------------------------
+export class AccumulatedErrorContext extends ErrorContext {
+    constructor(context, schema) {
+        super(context, schema, error => this.errors.push(error));
+        this.errors = [];
+    }
+    AddError(error) {
+        this.errors.push(error);
+        return false;
+    }
+    GetErrors() {
+        return this.errors;
+    }
+}

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

@@ -0,0 +1,9 @@
+export interface TExternal {
+    /** The name of the variable that holds external variables in generated code */
+    identifier: string;
+    /** An array of external variables */
+    variables: unknown[];
+}
+export declare function ResetExternal(): void;
+export declare function CreateExternalVariable(value: unknown): string;
+export declare function GetExternal(): TExternal;

package/build/schema/engine/_externals.mjs

@@ -0,0 +1,34 @@
+// deno-fmt-ignore-file
+const identifier = 'external_';
+let resetCount = 0;
+const state = {
+    identifier: `${identifier}${resetCount}`,
+    variables: []
+};
+// ------------------------------------------------------------------
+// ResetExternals
+//
+// Each reset results in a new external group identifier. This is done 
+// to prevent variable name overlap when generating and evaluating
+// multiple types in the same scope.
+//
+// ------------------------------------------------------------------
+export function ResetExternal() {
+    state.identifier = `${identifier}${resetCount}`;
+    state.variables = [];
+    resetCount += 1;
+}
+// ------------------------------------------------------------------
+// CreateExternalVariable
+// ------------------------------------------------------------------
+export function CreateExternalVariable(value) {
+    const call = `${state.identifier}[${state.variables.length}]`;
+    state.variables.push(value);
+    return call;
+}
+// ------------------------------------------------------------------
+// GetExternals
+// ------------------------------------------------------------------
+export function GetExternal() {
+    return state;
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext } from './_context.mjs';
+export declare function ResetFunctions(): void;
+export declare function GetFunctions(): string[];
+export declare function CreateFunction(context: BuildContext, schema: S.XSchemaLike, value: string): string;

package/build/schema/engine/_functions.mjs

@@ -0,0 +1,46 @@
+// deno-fmt-ignore-file
+import { Hashing } from '../../system/hashing/index.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema } from './schema.mjs';
+const functions = new Map();
+// ------------------------------------------------------------------
+// CreateCallExpression
+// ------------------------------------------------------------------
+function CreateCallExpression(context, schema, hash, value) {
+    return context.UseUnevaluated()
+        ? E.Call(`check_${hash}`, ['context', value])
+        : E.Call(`check_${hash}`, [value]);
+}
+// ------------------------------------------------------------------
+// CreateFunctionExpression
+// ------------------------------------------------------------------
+function CreateFunctionExpression(context, schema, hash) {
+    const expression = BuildSchema(context, schema, 'value');
+    return context.UseUnevaluated()
+        ? E.ConstDeclaration(`check_${hash}`, E.ArrowFunction(['context', 'value'], expression))
+        : E.ConstDeclaration(`check_${hash}`, E.ArrowFunction(['value'], expression));
+}
+// ------------------------------------------------------------------
+// ResetFunctions
+// ------------------------------------------------------------------
+export function ResetFunctions() {
+    functions.clear();
+}
+// ------------------------------------------------------------------
+// GetFunctions
+// ------------------------------------------------------------------
+export function GetFunctions() {
+    return [...functions.values()];
+}
+// ------------------------------------------------------------------
+// CreateFunction
+// ------------------------------------------------------------------
+export function CreateFunction(context, schema, value) {
+    const hash = Hashing.Hash(schema);
+    const call = CreateCallExpression(context, schema, hash, value);
+    if (functions.has(hash))
+        return call;
+    functions.set(hash, '');
+    functions.set(hash, CreateFunctionExpression(context, schema, hash));
+    return call;
+}

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

@@ -0,0 +1,3 @@
+import * as S from '../types/index.mjs';
+import { BuildContext } from './_context.mjs';
+export declare function Reducer(context: BuildContext, schemas: S.XSchemaLike[], value: string, check: string): string;

package/build/schema/engine/_reducer.mjs

@@ -0,0 +1,45 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Reducer
+//
+// This function is used to generate an reducer evaluation context 
+// for the allOf, anyOf, oneOf and not keywords. The reducer mechansism
+// is required from 2019-09 onwards to gather evaluated keys and indices
+// for the unevaluatedItems and unevaluatedProperties keywords.
+//
+// ------------------------------------------------------------------
+//
+// const context = new Context() // exterior
+//
+// (() => {
+//   const results = []
+//
+//   const context_0 = context.Clone()
+//   const context_1 = context.Clone()
+//   const context_2 = context.Clone()
+//   const context_3 = context.Clone()
+//   
+//   const condition_0 = ((context) => <subschema>)(context_0)
+//   const condition_1 = ((context) => <subschema>)(context_1)
+//   const condition_2 = ((context) => <subschema>)(context_2)
+//   const condition_3 = ((context) => <subschema>)(context_3)
+// 
+//   if(condition_0) results.push(context_0)
+//   if(condition_1) results.push(context_1)
+//   if(condition_2) results.push(context_2)
+//   if(condition_3) results.push(context_3)
+//
+//   return <check> && context.Merge(results)
+// })()
+//
+// ------------------------------------------------------------------
+export function Reducer(context, schemas, value, check) {
+    const results = E.ConstDeclaration('results', '[]');
+    const context_n = schemas.map((_schema, index) => E.ConstDeclaration(`context_${index}`, context.Clone()));
+    const condition_n = schemas.map((schema, index) => E.ConstDeclaration(`condition_${index}`, E.Call(E.ArrowFunction(['context'], BuildSchema(context, schema, value)), [`context_${index}`])));
+    const checks = schemas.map((_schema, index) => E.If(`condition_${index}`, E.Call(E.Member('results', 'push'), [`context_${index}`])));
+    const returns = E.Return(E.And(check, context.Merge('results')));
+    return E.Call(E.ArrowFunction([], E.Statements([results, ...context_n, ...condition_n, ...checks, returns])), []);
+}

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

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

package/build/schema/engine/_refine.mjs

@@ -0,0 +1,29 @@
+// deno-fmt-ignore-file
+import * as V from './_externals.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildRefine(context, schema, value) {
+    const refinements = V.CreateExternalVariable(schema['~refine'].map((refinement) => refinement));
+    return E.Call(E.Member(refinements, 'every'), [E.ArrowFunction(['refinement'], E.Call(E.Member('refinement', 'callback'), [value]))]);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckRefine(context, schema, value) {
+    return G.Every(schema['~refine'], (refinement) => refinement.callback(value));
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorRefine(context, schemaPath, instancePath, schema, value) {
+    return G.EveryAll(schema['~refine'], (refinement, index) => {
+        return refinement.callback(value) || context.AddError({
+            keyword: '~refine',
+            schemaPath: `${schemaPath}/~refine`,
+            instancePath,
+            params: { index, message: refinement.message },
+        });
+    });
+}

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

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

package/build/schema/engine/_standard.mjs

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+import * as V from './_externals.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildStandardSchemaV1(context, schema, value) {
+    return E.Not(E.HasPropertyKey(E.Call(E.Member(E.Member(V.CreateExternalVariable(schema), '~standard'), 'validate'), [value]), E.Constant('issues')));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckStandardSchemaV1(context, schema, value) {
+    return !G.HasPropertyKey(schema['~standard'].validate(value), 'issues');
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorStandardSchemaV1(context, schemaPath, instancePath, schema, value) {
+    const result = schema['~standard'].validate(value);
+    return !G.HasPropertyKey(result, 'issues') || context.AddError({
+        keyword: '~standard',
+        schemaPath: `${schemaPath}/~standard`,
+        instancePath,
+        params: { vendor: schema[`~standard`].vendor, issues: result.issues },
+    });
+}

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

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