@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.6

package/dist/v1/language/validation/diagnostic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic.js","sourceRoot":"","sources":["../../../../v1/language/validation/diagnostic.ts"],"names":[],"mappings":"AA4BA,MAAM,UAAU,UAAU,CACxB,IAAU,EACV,OAAe,EACf,OAAe,EACf,GAAY;IAEZ,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,CAAA;AACzF,CAAC"}

package/dist/v1/language/value/compile/fields.d.ts

@@ -0,0 +1,4 @@
+import type { ValueProgram } from './model.js';
+/** Exact field constraints available for independent scalar route validation. */
+export declare function inputFieldNodes(program: ValueProgram): Readonly<Record<string, readonly number[]>> | undefined;
+//# sourceMappingURL=fields.d.ts.map

package/dist/v1/language/value/compile/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../../../../v1/language/value/compile/fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,iFAAiF;AACjF,wBAAgB,eAAe,CAC7B,OAAO,EAAE,YAAY,GACpB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,GAAG,SAAS,CAuDzD"}

package/dist/v1/language/value/compile/fields.js

@@ -0,0 +1,61 @@
+/** Exact field constraints available for independent scalar route validation. */
+export function inputFieldNodes(program) {
+    const fields = new Map();
+    const visited = new Set();
+    let closed = false;
+    let unsupported = false;
+    const visit = (index) => {
+        if (visited.has(index))
+            return;
+        visited.add(index);
+        const node = program.nodes[index];
+        if (node === undefined ||
+            node.schema === null ||
+            typeof node.schema !== 'object' ||
+            Array.isArray(node.schema))
+            return;
+        const schema = node.schema;
+        if (schema.additionalProperties === false || schema.unevaluatedProperties === false)
+            closed = true;
+        if (schema.anyOf !== undefined || schema.oneOf !== undefined || schema.if !== undefined)
+            unsupported = true;
+        if (node.reference !== undefined)
+            visit(node.reference);
+        if (Array.isArray(schema.allOf)) {
+            schema.allOf.forEach((_, position) => {
+                const child = node.children[`allOf/${position}`];
+                if (child === undefined)
+                    throw new TypeError('Compiled input allOf branch is absent.');
+                visit(child);
+            });
+        }
+        if (schema.properties === null ||
+            typeof schema.properties !== 'object' ||
+            Array.isArray(schema.properties))
+            return;
+        for (const name of Object.keys(schema.properties)) {
+            const child = node.children[`properties/${escapePointer(name)}`];
+            if (child === undefined)
+                throw new TypeError(`Compiled input field ${name} is absent.`);
+            const constraints = fields.get(name) ?? new Set();
+            constraints.add(child);
+            fields.set(name, constraints);
+        }
+    };
+    visit(program.root);
+    if (!closed || unsupported)
+        return undefined;
+    return Object.freeze(Object.fromEntries([...fields]
+        .sort(([left], [right]) => compare(left, right))
+        .map(([name, nodes]) => [
+        name,
+        Object.freeze([...nodes].sort((left, right) => left - right)),
+    ])));
+}
+function escapePointer(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+//# sourceMappingURL=fields.js.map

package/dist/v1/language/value/compile/fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.js","sourceRoot":"","sources":["../../../../../v1/language/value/compile/fields.ts"],"names":[],"mappings":"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"}

package/dist/v1/language/value/compile/load.d.ts

@@ -0,0 +1,5 @@
+import type { CompiledInstanceSchema } from '../evaluate/types.js';
+import type { ValueProgram } from './model.js';
+/** Bind admitted portable indices to the canonical instance evaluator. */
+export declare function loadValueProgram(program: ValueProgram): CompiledInstanceSchema;
+//# sourceMappingURL=load.d.ts.map

package/dist/v1/language/value/compile/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../../../v1/language/value/compile/load.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAkB,MAAM,sBAAsB,CAAA;AAElF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAK9C,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,sBAAsB,CAoC9E"}

package/dist/v1/language/value/compile/load.js

@@ -0,0 +1,42 @@
+import { loadPattern } from '../regexp/matcher.js';
+import { appendPointer } from '../syntax/pointer.js';
+/** Bind admitted portable indices to the canonical instance evaluator. */
+export function loadValueProgram(program) {
+    const resource = { key: 'compiled', schema: true, ownerOrigin: 'compiled' };
+    const locations = program.nodes.map((node, index) => ({
+        key: String(index),
+        pointer: '',
+        resource,
+        schema: node.schema,
+    }));
+    const patterns = new Map(program.patterns.map((pattern) => [pattern.source, loadPattern(pattern)]));
+    const root = locations[program.root];
+    if (root === undefined)
+        throw new TypeError('Compiled value program root is absent.');
+    return {
+        root,
+        locations: new Map(locations.map((location) => [location.key, location])),
+        resolutions: new Map(),
+        program: () => program,
+        child(location, keyword, member) {
+            const base = appendPointer('', keyword);
+            const key = (member === undefined ? base : appendPointer(base, member)).slice(1);
+            const index = program.nodes[Number(location.key)]?.children[key];
+            const child = index === undefined ? undefined : locations[index];
+            if (child === undefined)
+                throw new TypeError('Compiled value program child is absent.');
+            return child;
+        },
+        reference(location) {
+            const index = program.nodes[Number(location.key)]?.reference;
+            return index === undefined ? undefined : locations[index];
+        },
+        matcher(source) {
+            const matcher = patterns.get(source);
+            if (matcher === undefined)
+                throw new TypeError('Compiled value program pattern is absent.');
+            return matcher;
+        },
+    };
+}
+//# sourceMappingURL=load.js.map

package/dist/v1/language/value/compile/load.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.js","sourceRoot":"","sources":["../../../../../v1/language/value/compile/load.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEpD,0EAA0E;AAC1E,MAAM,UAAU,gBAAgB,CAAC,OAAqB;IACpD,MAAM,QAAQ,GAAG,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,IAAa,EAAE,WAAW,EAAE,UAAU,EAAE,CAAA;IACpF,MAAM,SAAS,GAAqB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;QACtE,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC;QAClB,OAAO,EAAE,EAAE;QACX,QAAQ;QACR,MAAM,EAAE,IAAI,CAAC,MAAoB;KAClC,CAAC,CAAC,CAAA;IACH,MAAM,QAAQ,GAAG,IAAI,GAAG,CACtB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAC1E,CAAA;IACD,MAAM,IAAI,GAAG,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IACpC,IAAI,IAAI,KAAK,SAAS;QAAE,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC,CAAA;IACrF,OAAO;QACL,IAAI;QACJ,SAAS,EAAE,IAAI,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC;QACzE,WAAW,EAAE,IAAI,GAAG,EAAE;QACtB,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO;QACtB,KAAK,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM;YAC7B,MAAM,IAAI,GAAG,aAAa,CAAC,EAAE,EAAE,OAAO,CAAC,CAAA;YACvC,MAAM,GAAG,GAAG,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;YAChF,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAA;YAChE,MAAM,KAAK,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;YAChE,IAAI,KAAK,KAAK,SAAS;gBAAE,MAAM,IAAI,SAAS,CAAC,yCAAyC,CAAC,CAAA;YACvF,OAAO,KAAK,CAAA;QACd,CAAC;QACD,SAAS,CAAC,QAAQ;YAChB,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,CAAA;YAC5D,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;QAC3D,CAAC;QACD,OAAO,CAAC,MAAM;YACZ,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;YACpC,IAAI,OAAO,KAAK,SAAS;gBAAE,MAAM,IAAI,SAAS,CAAC,2CAA2C,CAAC,CAAA;YAC3F,OAAO,OAAO,CAAA;QAChB,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/v1/language/value/compile/model.d.ts

@@ -0,0 +1,28 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+export type ScalarRange = readonly [minimum: number, maximum: number];
+export interface PatternTransition {
+    readonly to: number;
+    readonly ranges: readonly ScalarRange[];
+}
+export interface PatternState {
+    readonly epsilon: readonly number[];
+    readonly transitions: readonly PatternTransition[];
+    readonly accepting?: true;
+}
+export interface Pattern {
+    readonly source: string;
+    readonly start: number;
+    readonly states: readonly PatternState[];
+}
+export interface ValueNode {
+    readonly schema: JsonValue;
+    readonly children: Readonly<Record<string, number>>;
+    readonly reference?: number;
+}
+/** Portable, JSON-safe evaluation program for one admitted ValueSchema. */
+export interface ValueProgram {
+    readonly root: number;
+    readonly nodes: readonly ValueNode[];
+    readonly patterns: readonly Pattern[];
+}
+//# sourceMappingURL=model.d.ts.map

package/dist/v1/language/value/compile/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../../../v1/language/value/compile/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAEtE,MAAM,MAAM,WAAW,GAAG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,CAAA;AAErE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAA;CACxC;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;IACnC,QAAQ,CAAC,WAAW,EAAE,SAAS,iBAAiB,EAAE,CAAA;IAClD,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAA;CAC1B;AAED,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAA;CACzC;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;IAC1B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACnD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED,2EAA2E;AAC3E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAA;IACpC,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAA;CACtC"}

package/dist/v1/language/value/compile/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../../../../../v1/language/value/compile/model.ts"],"names":[],"mappings":""}

package/dist/v1/language/value/evaluate/assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../../../../../v1/language/value/evaluate/assertions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAMtE,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAiBpE;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAEpE;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAQ5D;AAED,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAQpE"}

package/dist/v1/language/value/evaluate/assertions.js

@@ -0,0 +1,59 @@
+import { equal, json } from '@astrale-os/kernel-dsl/value';
+import { isValueObject as isJsonObject } from '../model/object.js';
+export function matchesType(input, value) {
+    switch (input) {
+        case 'null':
+            return value === null;
+        case 'boolean':
+        case 'number':
+        case 'string':
+            return typeof value === input;
+        case 'integer':
+            return typeof value === 'number' && Number.isInteger(value);
+        case 'array':
+            return Array.isArray(value);
+        case 'object':
+            return isJsonObject(value);
+        default:
+            return false;
+    }
+}
+export function jsonEqual(left, right) {
+    return equal(left, right);
+}
+export function unique(values) {
+    const seen = new Set();
+    for (const value of values) {
+        const key = json.serialize(value);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+    }
+    return true;
+}
+/** Compare finite JSON numbers as their exact ECMAScript decimal spellings. */
+export function isMultipleOf(value, divisor) {
+    if (!(divisor > 0))
+        return false;
+    const left = decimalInteger(value);
+    const right = decimalInteger(divisor);
+    const exponent = Math.min(left.exponent, right.exponent);
+    const dividend = left.coefficient * powerOfTen(left.exponent - exponent);
+    const factor = right.coefficient * powerOfTen(right.exponent - exponent);
+    return dividend % factor === 0n;
+}
+function decimalInteger(input) {
+    const source = input.toString().toLowerCase();
+    const [mantissa = '', exponentSource = '0'] = source.split('e');
+    const negative = mantissa.startsWith('-');
+    const unsigned = negative ? mantissa.slice(1) : mantissa;
+    const point = unsigned.indexOf('.');
+    const fractionDigits = point === -1 ? 0 : unsigned.length - point - 1;
+    const digits = unsigned.replace('.', '');
+    const coefficient = BigInt(`${negative ? '-' : ''}${digits}`);
+    return { coefficient, exponent: Number(exponentSource) - fractionDigits };
+}
+function powerOfTen(exponent) {
+    return 10n ** BigInt(exponent);
+}
+//# sourceMappingURL=assertions.js.map

package/dist/v1/language/value/evaluate/assertions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.js","sourceRoot":"","sources":["../../../../../v1/language/value/evaluate/assertions.ts"],"names":[],"mappings":"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"}

package/dist/v1/language/value/evaluate/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../../../../v1/language/value/evaluate/evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAGtE,OAAO,KAAK,EACV,sBAAsB,EACtB,UAAU,EAGX,MAAM,YAAY,CAAA;AAQnB,oFAAoF;AACpF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,sBAAsB,EAAE,KAAK,EAAE,SAAS,GAAG,UAAU,CAE/F"}

package/dist/v1/language/value/evaluate/evaluator.js

@@ -0,0 +1,362 @@
+import { isInstantValue } from '../model/instant.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { appendPointer } from '../syntax/pointer.js';
+import { isMultipleOf, jsonEqual, matchesType, unique } from './assertions.js';
+import { evaluation, mergeAnnotations } from './types.js';
+/** Evaluate complete Draft 2020-12 acceptance without dynamic source generation. */
+export function evaluateInstance(compiled, input) {
+    return new InstanceEvaluator(compiled).evaluate(compiled.root, input, '');
+}
+class InstanceEvaluator {
+    compiled;
+    active = new Set();
+    constructor(compiled) {
+        this.compiled = compiled;
+    }
+    evaluate(location, input, instancePointer) {
+        const activeKey = `${location.key}\u0000${instancePointer}`;
+        if (this.active.has(activeKey)) {
+            throw new TypeError('Admitted value schema entered a non-productive evaluation cycle.');
+        }
+        this.active.add(activeKey);
+        try {
+            if (location.schema === true)
+                return evaluation();
+            if (location.schema === false) {
+                return evaluation([
+                    invalid(instancePointer, 'false', 'The false schema rejects every value.'),
+                ]);
+            }
+            return this.evaluateObjectSchema(location, location.schema, input, instancePointer);
+        }
+        finally {
+            this.active.delete(activeKey);
+        }
+    }
+    evaluateObjectSchema(location, schema, input, instancePointer) {
+        const failures = [];
+        const properties = new Set();
+        const items = new Set();
+        const absorbSameLocation = (result) => {
+            if (result.valid)
+                mergeAnnotations(properties, items, result);
+            else
+                failures.push(...result.failures);
+        };
+        if (Object.hasOwn(schema, '$ref')) {
+            const target = this.compiled.reference(location);
+            if (target === undefined) {
+                throw new TypeError('Admitted value schema reference has no prepared resolution.');
+            }
+            absorbSameLocation(this.evaluate(target, input, instancePointer));
+        }
+        this.evaluateCompositions(location, schema, input, instancePointer, failures, properties, items);
+        this.evaluateCommonAssertions(schema, input, instancePointer, failures);
+        if (typeof input === 'number') {
+            this.evaluateNumberAssertions(schema, input, instancePointer, failures);
+        }
+        if (typeof input === 'string') {
+            this.evaluateStringAssertions(schema, input, instancePointer, failures);
+        }
+        if (Array.isArray(input)) {
+            this.evaluateArray(location, schema, input, instancePointer, failures, properties, items);
+        }
+        else if (isJsonObject(input)) {
+            this.evaluateObject(location, schema, input, instancePointer, failures, properties, items);
+        }
+        return evaluation(failures, properties, items);
+    }
+    evaluateCompositions(location, schema, input, instancePointer, failures, properties, items) {
+        const absorb = (result) => {
+            if (result.valid)
+                mergeAnnotations(properties, items, result);
+            else
+                failures.push(...result.failures);
+        };
+        const allOf = schemaList(schema.allOf);
+        allOf?.forEach((_, index) => {
+            absorb(this.evaluate(this.child(location, 'allOf', index), input, instancePointer));
+        });
+        const anyOf = schemaList(schema.anyOf);
+        if (anyOf !== undefined) {
+            const results = anyOf.map((_, index) => this.evaluate(this.child(location, 'anyOf', index), input, instancePointer));
+            const admitted = results.filter(({ valid }) => valid);
+            if (admitted.length === 0) {
+                failures.push(invalid(instancePointer, 'anyOf', 'Value satisfies no anyOf branch.'));
+            }
+            else {
+                admitted.forEach((result) => mergeAnnotations(properties, items, result));
+            }
+        }
+        const oneOf = schemaList(schema.oneOf);
+        if (oneOf !== undefined) {
+            const admitted = oneOf
+                .map((_, index) => this.evaluate(this.child(location, 'oneOf', index), input, instancePointer))
+                .filter(({ valid }) => valid);
+            if (admitted.length !== 1) {
+                failures.push(invalid(instancePointer, 'oneOf', 'Value must satisfy exactly one oneOf branch.'));
+            }
+            else {
+                mergeAnnotations(properties, items, admitted[0]);
+            }
+        }
+        if (isSchema(schema.not)) {
+            const result = this.evaluate(this.child(location, 'not'), input, instancePointer);
+            if (result.valid)
+                failures.push(invalid(instancePointer, 'not', 'Value satisfies not.'));
+        }
+        if (isSchema(schema.if)) {
+            const condition = this.evaluate(this.child(location, 'if'), input, instancePointer);
+            if (condition.valid)
+                mergeAnnotations(properties, items, condition);
+            const branch = condition.valid ? 'then' : 'else';
+            if (isSchema(schema[branch])) {
+                absorb(this.evaluate(this.child(location, branch), input, instancePointer));
+            }
+        }
+    }
+    evaluateCommonAssertions(schema, input, instancePointer, failures) {
+        if (schema['x-astrale-value-kind'] === 'instant' && !isInstantValue(input)) {
+            failures.push(invalid(instancePointer, 'x-astrale-value-kind', 'Value is not an exact UTC millisecond Instant.'));
+        }
+        if (typeof schema.type === 'string') {
+            if (!matchesType(schema.type, input)) {
+                failures.push(invalid(instancePointer, 'type', `Value is not of type ${schema.type}.`));
+            }
+        }
+        else if (Array.isArray(schema.type) &&
+            !schema.type.some((candidate) => typeof candidate === 'string' ? matchesType(candidate, input) : false)) {
+            failures.push(invalid(instancePointer, 'type', 'Value matches none of the admitted types.'));
+        }
+        if (Object.hasOwn(schema, 'const') && !jsonEqual(input, schema.const)) {
+            failures.push(invalid(instancePointer, 'const', 'Value differs from const.'));
+        }
+        if (Array.isArray(schema.enum) &&
+            !schema.enum.some((candidate) => jsonEqual(input, candidate))) {
+            failures.push(invalid(instancePointer, 'enum', 'Value is absent from enum.'));
+        }
+    }
+    evaluateNumberAssertions(schema, input, instancePointer, failures) {
+        if (typeof schema.multipleOf === 'number' && !isMultipleOf(input, schema.multipleOf)) {
+            failures.push(invalid(instancePointer, 'multipleOf', 'Number is not an exact multiple.'));
+        }
+        if (typeof schema.maximum === 'number' && input > schema.maximum) {
+            failures.push(invalid(instancePointer, 'maximum', 'Number exceeds maximum.'));
+        }
+        if (typeof schema.exclusiveMaximum === 'number' && input >= schema.exclusiveMaximum) {
+            failures.push(invalid(instancePointer, 'exclusiveMaximum', 'Number reaches exclusiveMaximum.'));
+        }
+        if (typeof schema.minimum === 'number' && input < schema.minimum) {
+            failures.push(invalid(instancePointer, 'minimum', 'Number is below minimum.'));
+        }
+        if (typeof schema.exclusiveMinimum === 'number' && input <= schema.exclusiveMinimum) {
+            failures.push(invalid(instancePointer, 'exclusiveMinimum', 'Number reaches exclusiveMinimum.'));
+        }
+    }
+    evaluateStringAssertions(schema, input, instancePointer, failures) {
+        const length = Array.from(input).length;
+        if (typeof schema.maxLength === 'number' && length > schema.maxLength) {
+            failures.push(invalid(instancePointer, 'maxLength', 'String exceeds maxLength.'));
+        }
+        if (typeof schema.minLength === 'number' && length < schema.minLength) {
+            failures.push(invalid(instancePointer, 'minLength', 'String is below minLength.'));
+        }
+        if (typeof schema.pattern === 'string' && !this.compiled.matcher(schema.pattern).test(input)) {
+            failures.push(invalid(instancePointer, 'pattern', 'String does not match pattern.'));
+        }
+        if (typeof schema.fullMatch === 'string' &&
+            !this.compiled.matcher(schema.fullMatch).matches(input)) {
+            failures.push(invalid(instancePointer, 'fullMatch', 'String does not match fullMatch.'));
+        }
+    }
+    evaluateArray(location, schema, input, instancePointer, failures, _properties, items) {
+        if (typeof schema.maxItems === 'number' && input.length > schema.maxItems) {
+            failures.push(invalid(instancePointer, 'maxItems', 'Array exceeds maxItems.'));
+        }
+        if (typeof schema.minItems === 'number' && input.length < schema.minItems) {
+            failures.push(invalid(instancePointer, 'minItems', 'Array is below minItems.'));
+        }
+        if (schema.uniqueItems === true && !unique(input)) {
+            failures.push(invalid(instancePointer, 'uniqueItems', 'Array items are not unique.'));
+        }
+        const prefixItems = schemaList(schema.prefixItems) ?? [];
+        const presentPrefix = Math.min(prefixItems.length, input.length);
+        let prefixValid = true;
+        for (let index = 0; index < presentPrefix; index++) {
+            const result = this.evaluate(this.child(location, 'prefixItems', index), input[index], appendPointer(instancePointer, index));
+            if (!result.valid) {
+                prefixValid = false;
+                failures.push(...result.failures);
+            }
+        }
+        if (prefixValid) {
+            for (let index = 0; index < presentPrefix; index++)
+                items.add(index);
+        }
+        if (isSchema(schema.items)) {
+            let itemValid = true;
+            const admitted = [];
+            for (let index = prefixItems.length; index < input.length; index++) {
+                const result = this.evaluate(this.child(location, 'items'), input[index], appendPointer(instancePointer, index));
+                if (result.valid)
+                    admitted.push(index);
+                else {
+                    itemValid = false;
+                    failures.push(...result.failures);
+                }
+            }
+            if (itemValid)
+                admitted.forEach((index) => items.add(index));
+        }
+        if (isSchema(schema.contains)) {
+            const matches = [];
+            for (let index = 0; index < input.length; index++) {
+                const result = this.evaluate(this.child(location, 'contains'), input[index], appendPointer(instancePointer, index));
+                if (result.valid)
+                    matches.push(index);
+            }
+            const minimum = typeof schema.minContains === 'number' ? schema.minContains : 1;
+            const maximum = typeof schema.maxContains === 'number' ? schema.maxContains : Number.POSITIVE_INFINITY;
+            if (matches.length < minimum || matches.length > maximum) {
+                failures.push(invalid(instancePointer, 'contains', 'Array has an invalid number of contains matches.'));
+            }
+            else {
+                matches.forEach((index) => items.add(index));
+            }
+        }
+        if (isSchema(schema.unevaluatedItems)) {
+            let valid = true;
+            const admitted = [];
+            for (let index = 0; index < input.length; index++) {
+                if (items.has(index))
+                    continue;
+                const result = this.evaluate(this.child(location, 'unevaluatedItems'), input[index], appendPointer(instancePointer, index));
+                if (result.valid)
+                    admitted.push(index);
+                else {
+                    valid = false;
+                    failures.push(...result.failures);
+                }
+            }
+            if (valid)
+                admitted.forEach((index) => items.add(index));
+        }
+    }
+    evaluateObject(location, schema, input, instancePointer, failures, properties, _items) {
+        const names = Object.keys(input);
+        if (typeof schema.maxProperties === 'number' && names.length > schema.maxProperties) {
+            failures.push(invalid(instancePointer, 'maxProperties', 'Object exceeds maxProperties.'));
+        }
+        if (typeof schema.minProperties === 'number' && names.length < schema.minProperties) {
+            failures.push(invalid(instancePointer, 'minProperties', 'Object is below minProperties.'));
+        }
+        if (Array.isArray(schema.required)) {
+            for (const name of schema.required) {
+                if (typeof name === 'string' && !Object.hasOwn(input, name)) {
+                    failures.push(invalid(instancePointer, 'required', `Object is missing required property ${name}.`));
+                }
+            }
+        }
+        if (isJsonObject(schema.dependentRequired)) {
+            for (const [name, required] of Object.entries(schema.dependentRequired)) {
+                if (!Object.hasOwn(input, name) || !Array.isArray(required))
+                    continue;
+                for (const dependency of required) {
+                    if (typeof dependency === 'string' && !Object.hasOwn(input, dependency)) {
+                        failures.push(invalid(instancePointer, 'dependentRequired', `Property ${name} requires property ${dependency}.`));
+                    }
+                }
+            }
+        }
+        const declared = isJsonObject(schema.properties) ? schema.properties : {};
+        const declaredPresent = Object.keys(declared).filter((name) => Object.hasOwn(input, name));
+        let declaredValid = true;
+        for (const name of declaredPresent) {
+            const result = this.evaluate(this.child(location, 'properties', name), input[name], appendPointer(instancePointer, name));
+            if (!result.valid) {
+                declaredValid = false;
+                failures.push(...result.failures);
+            }
+        }
+        if (declaredValid)
+            declaredPresent.forEach((name) => properties.add(name));
+        const patterns = isJsonObject(schema.patternProperties) ? schema.patternProperties : {};
+        const patternMatched = new Set();
+        let patternsValid = true;
+        for (const pattern of Object.keys(patterns)) {
+            const matcher = this.compiled.matcher(pattern);
+            for (const name of names) {
+                if (!matcher.test(name))
+                    continue;
+                patternMatched.add(name);
+                const result = this.evaluate(this.child(location, 'patternProperties', pattern), input[name], appendPointer(instancePointer, name));
+                if (!result.valid) {
+                    patternsValid = false;
+                    failures.push(...result.failures);
+                }
+            }
+        }
+        if (patternsValid)
+            patternMatched.forEach((name) => properties.add(name));
+        if (isSchema(schema.additionalProperties)) {
+            const additional = names.filter((name) => !Object.hasOwn(declared, name) && !patternMatched.has(name));
+            let additionalValid = true;
+            for (const name of additional) {
+                const result = this.evaluate(this.child(location, 'additionalProperties'), input[name], appendPointer(instancePointer, name));
+                if (!result.valid) {
+                    additionalValid = false;
+                    failures.push(...result.failures);
+                }
+            }
+            if (additionalValid)
+                additional.forEach((name) => properties.add(name));
+        }
+        if (isSchema(schema.propertyNames)) {
+            for (const name of names) {
+                const result = this.evaluate(this.child(location, 'propertyNames'), name, appendPointer(instancePointer, name));
+                if (!result.valid)
+                    failures.push(...result.failures);
+            }
+        }
+        if (isJsonObject(schema.dependentSchemas)) {
+            for (const name of Object.keys(schema.dependentSchemas)) {
+                if (!Object.hasOwn(input, name))
+                    continue;
+                const result = this.evaluate(this.child(location, 'dependentSchemas', name), input, instancePointer);
+                if (result.valid)
+                    mergeAnnotations(properties, new Set(), result);
+                else
+                    failures.push(...result.failures);
+            }
+        }
+        if (isSchema(schema.unevaluatedProperties)) {
+            const unevaluated = names.filter((name) => !properties.has(name));
+            let valid = true;
+            const admitted = [];
+            for (const name of unevaluated) {
+                const result = this.evaluate(this.child(location, 'unevaluatedProperties'), input[name], appendPointer(instancePointer, name));
+                if (result.valid)
+                    admitted.push(name);
+                else {
+                    valid = false;
+                    failures.push(...result.failures);
+                }
+            }
+            if (valid)
+                admitted.forEach((name) => properties.add(name));
+        }
+    }
+    child(parent, keyword, member) {
+        return this.compiled.child(parent, keyword, member);
+    }
+}
+function schemaList(input) {
+    return Array.isArray(input) ? input : undefined;
+}
+function isSchema(input) {
+    return typeof input === 'boolean' || isJsonObject(input);
+}
+function invalid(instancePointer, keyword, message) {
+    return { instancePointer, keyword, message };
+}
+//# sourceMappingURL=evaluator.js.map