@sourcemeta/blaze 15.0.0 → 15.2.0

package/index.d.mts

@@ -9,6 +9,32 @@ export type EvaluationCallback = (
   annotation: unknown
 ) => void;
 
+export type StandardOutputFormat = 'flag' | 'basic';
+
+export interface StandardOutputErrorEntry {
+  keywordLocation: string;
+  absoluteKeywordLocation: string;
+  instanceLocation: string;
+  error: string;
+}
+
+export interface StandardOutputAnnotationEntry {
+  keywordLocation: string;
+  absoluteKeywordLocation: string;
+  instanceLocation: string;
+  annotation: unknown[];
+}
+
+export type StandardOutputFlagResult = { valid: boolean };
+
+export type StandardOutputBasicResult =
+  | { valid: true; annotations?: StandardOutputAnnotationEntry[] }
+  | { valid: false; errors: StandardOutputErrorEntry[] };
+
+export type StandardOutputResult =
+  | StandardOutputFlagResult
+  | StandardOutputBasicResult;
+
 export declare class Blaze {
   static reviver(
     key: string,
@@ -16,5 +42,16 @@ export declare class Blaze {
     context: { source: string }
   ): unknown;
   constructor(template: Template);
+  validate(instance: unknown, format: 'flag'): StandardOutputFlagResult;
+  validate(instance: unknown, format: 'basic'): StandardOutputBasicResult;
   validate(instance: unknown, callback?: EvaluationCallback): boolean;
 }
+
+export declare function describe(
+  valid: boolean,
+  instruction: unknown[],
+  evaluatePath: string,
+  instanceLocation: string,
+  instance: unknown,
+  annotation: unknown
+): string;

package/index.mjs

@@ -1,10 +1,11 @@
+import {
+  ANNOTATION_EMIT, ANNOTATION_TO_PARENT, ANNOTATION_BASENAME_TO_PARENT,
+  CONTROL_GROUP as CONTROL_GROUP_START,
+  CONTROL_EVALUATE as CONTROL_EVALUATE_END
+} from './opcodes.mjs';
+
 const JSON_VERSION = 4;
 const DEPTH_LIMIT = 300;
-const ANNOTATION_EMIT = 49;
-const ANNOTATION_TO_PARENT = 50;
-const ANNOTATION_BASENAME_TO_PARENT = 51;
-const CONTROL_GROUP_START = 92;
-const CONTROL_EVALUATE_END = 96;
 const URI_REGEX = /^[a-zA-Z][a-zA-Z0-9+\-.]*:[^\s]*$/;
 
 function buildJsonPointer(tokens, length) {
@@ -423,7 +424,13 @@ class Blaze {
     this._nativeValidate = generateNativeValidator(template);
   }
 
-  validate(instance, callback) {
+  validate(instance, callbackOrFormat) {
+    if (typeof callbackOrFormat === 'string') {
+      return runStandard(this, instance, callbackOrFormat);
+    }
+
+    const callback = callbackOrFormat;
+
     if (callback === undefined && this._nativeValidate) {
       return this._nativeValidate(instance, this);
     }
@@ -3967,4 +3974,178 @@ fastHandlers[89] = LoopItemsIntegerBounded_fast;
 fastHandlers[90] = LoopItemsIntegerBoundedSized_fast;
 fastHandlers[97] = ControlDynamicAnchorJump_fast;
 
+import { describe } from './describe.mjs';
+
+const STANDARD_MASK_KEYWORDS =
+  new Set([ 'anyOf', 'oneOf', 'not', 'if', 'contains' ]);
+
+function isAnnotationOpcode(opcode) {
+  return opcode >= ANNOTATION_EMIT && opcode <= ANNOTATION_BASENAME_TO_PARENT;
+}
+
+function lastEvaluatePathToken(evaluatePath) {
+  const lastSlash = evaluatePath.lastIndexOf('/');
+  if (lastSlash < 0) return '';
+  return evaluatePath.slice(lastSlash + 1);
+}
+
+function isPathPrefix(path, prefix) {
+  if (path === prefix) return true;
+  return path.startsWith(prefix) && path[prefix.length] === '/';
+}
+
+function maskKey(evaluatePath, instanceLocation) {
+  return evaluatePath + '\u0000' + instanceLocation;
+}
+
+class SimpleOutput {
+  constructor(instance) {
+    this.instance = instance;
+    this.errors = [];
+    this.mask = [];
+    this.maskedTraces = new Map();
+    this.annotations = new Map();
+  }
+
+  callback(type, valid, instruction, evaluatePath, instanceLocation, annotation) {
+    if (evaluatePath === '') return;
+
+    const opcode = instruction[0];
+    const isAnnotation = isAnnotationOpcode(opcode);
+    const keyword = lastEvaluatePathToken(evaluatePath);
+
+    if (valid && !isAnnotation) {
+      if (type === 'pre' && STANDARD_MASK_KEYWORDS.has(keyword)) {
+        this.mask.push({
+          evaluatePath, instanceLocation,
+          key: maskKey(evaluatePath, instanceLocation)
+        });
+      } else if (type === 'post' && this.mask.length > 0) {
+        const top = this.mask[this.mask.length - 1];
+        if (top.evaluatePath === evaluatePath &&
+            top.instanceLocation === instanceLocation) {
+          this.maskedTraces.delete(top.key);
+          this.mask.pop();
+        }
+      }
+      return;
+    }
+
+    if (isAnnotation) {
+      if (type !== 'post') return;
+      const annotationKey =
+        evaluatePath + '\u0000' + instanceLocation + '\u0000' + instruction[3];
+      let bucket = this.annotations.get(annotationKey);
+      if (bucket === undefined) {
+        bucket = {
+          keywordLocation: evaluatePath,
+          absoluteKeywordLocation: instruction[3],
+          instanceLocation,
+          annotation: [ annotation ]
+        };
+        this.annotations.set(annotationKey, bucket);
+      } else {
+        const last = bucket.annotation[bucket.annotation.length - 1];
+        let isSame = last === annotation;
+        if (!isSame && Array.isArray(last) && Array.isArray(annotation) &&
+            last.length === annotation.length) {
+          isSame = last.every((value, index) => value === annotation[index]);
+        }
+        if (!isSame) bucket.annotation.push(annotation);
+      }
+      return;
+    }
+
+    if (type === 'pre') {
+      if (STANDARD_MASK_KEYWORDS.has(keyword)) {
+        this.mask.push({
+          evaluatePath, instanceLocation,
+          key: maskKey(evaluatePath, instanceLocation)
+        });
+      }
+      return;
+    }
+
+    const currentKey = maskKey(evaluatePath, instanceLocation);
+    const matchIndex = this.mask.findIndex(entry => entry.key === currentKey);
+    if (matchIndex >= 0) {
+      if (!valid && keyword !== 'not' && keyword !== 'if') {
+        const buffered = this.maskedTraces.get(currentKey);
+        if (buffered !== undefined) {
+          for (const entry of buffered) this.errors.push(entry);
+          this.maskedTraces.delete(currentKey);
+        }
+      } else {
+        this.maskedTraces.delete(currentKey);
+      }
+      this.mask.splice(matchIndex, 1);
+    }
+
+    if (valid) return;
+
+    if (this.annotations.size > 0) {
+      const lastSlash = evaluatePath.lastIndexOf('/');
+      const parentPath = lastSlash <= 0 ? '' : evaluatePath.slice(0, lastSlash);
+      for (const [ key, value ] of this.annotations) {
+        if (value.instanceLocation === instanceLocation &&
+            (parentPath === '' ||
+             isPathPrefix(value.keywordLocation, parentPath))) {
+          this.annotations.delete(key);
+        }
+      }
+    }
+
+    if (keyword === 'if') return;
+
+    const entry = {
+      keywordLocation: evaluatePath,
+      absoluteKeywordLocation: instruction[3],
+      instanceLocation,
+      error: describe(valid, instruction, evaluatePath, instanceLocation,
+                      this.instance, annotation)
+    };
+
+    for (const maskEntry of this.mask) {
+      if (isPathPrefix(evaluatePath, maskEntry.evaluatePath)) {
+        let buffer = this.maskedTraces.get(maskEntry.key);
+        if (buffer === undefined) {
+          buffer = [];
+          this.maskedTraces.set(maskEntry.key, buffer);
+        }
+        buffer.push(entry);
+        return;
+      }
+    }
+
+    this.errors.push(entry);
+  }
+
+  toBasic(valid) {
+    if (valid) {
+      const result = { valid: true };
+      if (this.annotations.size > 0) {
+        result.annotations = [ ...this.annotations.values() ];
+      }
+      return result;
+    }
+    return { valid: false, errors: this.errors };
+  }
+}
+
+function runStandard(evaluator, instance, format) {
+  if (format === 'flag') {
+    return { valid: evaluator.validate(instance) };
+  }
+  if (format !== 'basic') {
+    throw new Error(`Unknown standard output format: ${format}`);
+  }
+  const collector = new SimpleOutput(instance);
+  const valid = evaluator.validate(instance,
+    (type, ok, instruction, evaluatePath, instanceLocation, annotation) =>
+      collector.callback(type, ok, instruction, evaluatePath, instanceLocation,
+                         annotation));
+  return collector.toBasic(valid);
+}
+
 export { Blaze };
+export { describe } from './describe.mjs';

package/opcodes.mjs

@@ -0,0 +1,206 @@
+export const ASSERTION_FAIL = 0;
+export const ASSERTION_DEFINES = 1;
+export const ASSERTION_DEFINES_STRICT = 2;
+export const ASSERTION_DEFINES_ALL = 3;
+export const ASSERTION_DEFINES_ALL_STRICT = 4;
+export const ASSERTION_DEFINES_EXACTLY = 5;
+export const ASSERTION_DEFINES_EXACTLY_STRICT = 6;
+export const ASSERTION_DEFINES_EXACTLY_STRICT_HASH3 = 7;
+export const ASSERTION_PROPERTY_DEPENDENCIES = 8;
+export const ASSERTION_TYPE = 9;
+export const ASSERTION_TYPE_ANY = 10;
+export const ASSERTION_TYPE_STRICT = 11;
+export const ASSERTION_TYPE_STRICT_ANY = 12;
+export const ASSERTION_TYPE_STRING_BOUNDED = 13;
+export const ASSERTION_TYPE_STRING_UPPER = 14;
+export const ASSERTION_TYPE_ARRAY_BOUNDED = 15;
+export const ASSERTION_TYPE_ARRAY_UPPER = 16;
+export const ASSERTION_TYPE_OBJECT_BOUNDED = 17;
+export const ASSERTION_TYPE_OBJECT_UPPER = 18;
+export const ASSERTION_REGEX = 19;
+export const ASSERTION_STRING_SIZE_LESS = 20;
+export const ASSERTION_STRING_SIZE_GREATER = 21;
+export const ASSERTION_ARRAY_SIZE_LESS = 22;
+export const ASSERTION_ARRAY_SIZE_GREATER = 23;
+export const ASSERTION_OBJECT_SIZE_LESS = 24;
+export const ASSERTION_OBJECT_SIZE_GREATER = 25;
+export const ASSERTION_EQUAL = 26;
+export const ASSERTION_EQUALS_ANY = 27;
+export const ASSERTION_EQUALS_ANY_STRING_HASH = 28;
+export const ASSERTION_GREATER_EQUAL = 29;
+export const ASSERTION_LESS_EQUAL = 30;
+export const ASSERTION_GREATER = 31;
+export const ASSERTION_LESS = 32;
+export const ASSERTION_UNIQUE = 33;
+export const ASSERTION_DIVISIBLE = 34;
+export const ASSERTION_TYPE_INTEGER_BOUNDED = 35;
+export const ASSERTION_TYPE_INTEGER_BOUNDED_STRICT = 36;
+export const ASSERTION_TYPE_INTEGER_LOWER_BOUND = 37;
+export const ASSERTION_TYPE_INTEGER_LOWER_BOUND_STRICT = 38;
+export const ASSERTION_STRING_TYPE = 39;
+export const ASSERTION_PROPERTY_TYPE = 40;
+export const ASSERTION_PROPERTY_TYPE_EVALUATE = 41;
+export const ASSERTION_PROPERTY_TYPE_STRICT = 42;
+export const ASSERTION_PROPERTY_TYPE_STRICT_EVALUATE = 43;
+export const ASSERTION_PROPERTY_TYPE_STRICT_ANY = 44;
+export const ASSERTION_PROPERTY_TYPE_STRICT_ANY_EVALUATE = 45;
+export const ASSERTION_ARRAY_PREFIX = 46;
+export const ASSERTION_ARRAY_PREFIX_EVALUATE = 47;
+export const ASSERTION_OBJECT_PROPERTIES_SIMPLE = 48;
+export const ANNOTATION_EMIT = 49;
+export const ANNOTATION_TO_PARENT = 50;
+export const ANNOTATION_BASENAME_TO_PARENT = 51;
+export const EVALUATE = 52;
+export const LOGICAL_NOT = 53;
+export const LOGICAL_NOT_EVALUATE = 54;
+export const LOGICAL_OR = 55;
+export const LOGICAL_AND = 56;
+export const LOGICAL_XOR = 57;
+export const LOGICAL_CONDITION = 58;
+export const LOGICAL_WHEN_TYPE = 59;
+export const LOGICAL_WHEN_DEFINES = 60;
+export const LOGICAL_WHEN_ARRAY_SIZE_GREATER = 61;
+export const LOOP_PROPERTIES_UNEVALUATED = 62;
+export const LOOP_PROPERTIES_UNEVALUATED_EXCEPT = 63;
+export const LOOP_PROPERTIES_MATCH = 64;
+export const LOOP_PROPERTIES_MATCH_CLOSED = 65;
+export const LOOP_PROPERTIES = 66;
+export const LOOP_PROPERTIES_EVALUATE = 67;
+export const LOOP_PROPERTIES_REGEX = 68;
+export const LOOP_PROPERTIES_REGEX_CLOSED = 69;
+export const LOOP_PROPERTIES_STARTS_WITH = 70;
+export const LOOP_PROPERTIES_EXCEPT = 71;
+export const LOOP_PROPERTIES_TYPE = 72;
+export const LOOP_PROPERTIES_TYPE_EVALUATE = 73;
+export const LOOP_PROPERTIES_EXACTLY_TYPE_STRICT = 74;
+export const LOOP_PROPERTIES_EXACTLY_TYPE_STRICT_HASH = 75;
+export const LOOP_PROPERTIES_TYPE_STRICT = 76;
+export const LOOP_PROPERTIES_TYPE_STRICT_EVALUATE = 77;
+export const LOOP_PROPERTIES_TYPE_STRICT_ANY = 78;
+export const LOOP_PROPERTIES_TYPE_STRICT_ANY_EVALUATE = 79;
+export const LOOP_KEYS = 80;
+export const LOOP_ITEMS = 81;
+export const LOOP_ITEMS_FROM = 82;
+export const LOOP_ITEMS_UNEVALUATED = 83;
+export const LOOP_ITEMS_TYPE = 84;
+export const LOOP_ITEMS_TYPE_STRICT = 85;
+export const LOOP_ITEMS_TYPE_STRICT_ANY = 86;
+export const LOOP_ITEMS_PROPERTIES_EXACTLY_TYPE_STRICT_HASH = 87;
+export const LOOP_ITEMS_PROPERTIES_EXACTLY_TYPE_STRICT_HASH3 = 88;
+export const LOOP_ITEMS_INTEGER_BOUNDED = 89;
+export const LOOP_ITEMS_INTEGER_BOUNDED_SIZED = 90;
+export const LOOP_CONTAINS = 91;
+export const CONTROL_GROUP = 92;
+export const CONTROL_GROUP_WHEN_DEFINES = 93;
+export const CONTROL_GROUP_WHEN_DEFINES_DIRECT = 94;
+export const CONTROL_GROUP_WHEN_TYPE = 95;
+export const CONTROL_EVALUATE = 96;
+export const CONTROL_DYNAMIC_ANCHOR_JUMP = 97;
+export const CONTROL_JUMP = 98;
+
+export const INSTRUCTION_NAMES = {
+  "AssertionFail": ASSERTION_FAIL,
+  "AssertionDefines": ASSERTION_DEFINES,
+  "AssertionDefinesStrict": ASSERTION_DEFINES_STRICT,
+  "AssertionDefinesAll": ASSERTION_DEFINES_ALL,
+  "AssertionDefinesAllStrict": ASSERTION_DEFINES_ALL_STRICT,
+  "AssertionDefinesExactly": ASSERTION_DEFINES_EXACTLY,
+  "AssertionDefinesExactlyStrict": ASSERTION_DEFINES_EXACTLY_STRICT,
+  "AssertionDefinesExactlyStrictHash3": ASSERTION_DEFINES_EXACTLY_STRICT_HASH3,
+  "AssertionPropertyDependencies": ASSERTION_PROPERTY_DEPENDENCIES,
+  "AssertionType": ASSERTION_TYPE,
+  "AssertionTypeAny": ASSERTION_TYPE_ANY,
+  "AssertionTypeStrict": ASSERTION_TYPE_STRICT,
+  "AssertionTypeStrictAny": ASSERTION_TYPE_STRICT_ANY,
+  "AssertionTypeStringBounded": ASSERTION_TYPE_STRING_BOUNDED,
+  "AssertionTypeStringUpper": ASSERTION_TYPE_STRING_UPPER,
+  "AssertionTypeArrayBounded": ASSERTION_TYPE_ARRAY_BOUNDED,
+  "AssertionTypeArrayUpper": ASSERTION_TYPE_ARRAY_UPPER,
+  "AssertionTypeObjectBounded": ASSERTION_TYPE_OBJECT_BOUNDED,
+  "AssertionTypeObjectUpper": ASSERTION_TYPE_OBJECT_UPPER,
+  "AssertionRegex": ASSERTION_REGEX,
+  "AssertionStringSizeLess": ASSERTION_STRING_SIZE_LESS,
+  "AssertionStringSizeGreater": ASSERTION_STRING_SIZE_GREATER,
+  "AssertionArraySizeLess": ASSERTION_ARRAY_SIZE_LESS,
+  "AssertionArraySizeGreater": ASSERTION_ARRAY_SIZE_GREATER,
+  "AssertionObjectSizeLess": ASSERTION_OBJECT_SIZE_LESS,
+  "AssertionObjectSizeGreater": ASSERTION_OBJECT_SIZE_GREATER,
+  "AssertionEqual": ASSERTION_EQUAL,
+  "AssertionEqualsAny": ASSERTION_EQUALS_ANY,
+  "AssertionEqualsAnyStringHash": ASSERTION_EQUALS_ANY_STRING_HASH,
+  "AssertionGreaterEqual": ASSERTION_GREATER_EQUAL,
+  "AssertionLessEqual": ASSERTION_LESS_EQUAL,
+  "AssertionGreater": ASSERTION_GREATER,
+  "AssertionLess": ASSERTION_LESS,
+  "AssertionUnique": ASSERTION_UNIQUE,
+  "AssertionDivisible": ASSERTION_DIVISIBLE,
+  "AssertionTypeIntegerBounded": ASSERTION_TYPE_INTEGER_BOUNDED,
+  "AssertionTypeIntegerBoundedStrict": ASSERTION_TYPE_INTEGER_BOUNDED_STRICT,
+  "AssertionTypeIntegerLowerBound": ASSERTION_TYPE_INTEGER_LOWER_BOUND,
+  "AssertionTypeIntegerLowerBoundStrict": ASSERTION_TYPE_INTEGER_LOWER_BOUND_STRICT,
+  "AssertionStringType": ASSERTION_STRING_TYPE,
+  "AssertionPropertyType": ASSERTION_PROPERTY_TYPE,
+  "AssertionPropertyTypeEvaluate": ASSERTION_PROPERTY_TYPE_EVALUATE,
+  "AssertionPropertyTypeStrict": ASSERTION_PROPERTY_TYPE_STRICT,
+  "AssertionPropertyTypeStrictEvaluate": ASSERTION_PROPERTY_TYPE_STRICT_EVALUATE,
+  "AssertionPropertyTypeStrictAny": ASSERTION_PROPERTY_TYPE_STRICT_ANY,
+  "AssertionPropertyTypeStrictAnyEvaluate": ASSERTION_PROPERTY_TYPE_STRICT_ANY_EVALUATE,
+  "AssertionArrayPrefix": ASSERTION_ARRAY_PREFIX,
+  "AssertionArrayPrefixEvaluate": ASSERTION_ARRAY_PREFIX_EVALUATE,
+  "AssertionObjectPropertiesSimple": ASSERTION_OBJECT_PROPERTIES_SIMPLE,
+  "AnnotationEmit": ANNOTATION_EMIT,
+  "AnnotationToParent": ANNOTATION_TO_PARENT,
+  "AnnotationBasenameToParent": ANNOTATION_BASENAME_TO_PARENT,
+  "Evaluate": EVALUATE,
+  "LogicalNot": LOGICAL_NOT,
+  "LogicalNotEvaluate": LOGICAL_NOT_EVALUATE,
+  "LogicalOr": LOGICAL_OR,
+  "LogicalAnd": LOGICAL_AND,
+  "LogicalXor": LOGICAL_XOR,
+  "LogicalCondition": LOGICAL_CONDITION,
+  "LogicalWhenType": LOGICAL_WHEN_TYPE,
+  "LogicalWhenDefines": LOGICAL_WHEN_DEFINES,
+  "LogicalWhenArraySizeGreater": LOGICAL_WHEN_ARRAY_SIZE_GREATER,
+  "LoopPropertiesUnevaluated": LOOP_PROPERTIES_UNEVALUATED,
+  "LoopPropertiesUnevaluatedExcept": LOOP_PROPERTIES_UNEVALUATED_EXCEPT,
+  "LoopPropertiesMatch": LOOP_PROPERTIES_MATCH,
+  "LoopPropertiesMatchClosed": LOOP_PROPERTIES_MATCH_CLOSED,
+  "LoopProperties": LOOP_PROPERTIES,
+  "LoopPropertiesEvaluate": LOOP_PROPERTIES_EVALUATE,
+  "LoopPropertiesRegex": LOOP_PROPERTIES_REGEX,
+  "LoopPropertiesRegexClosed": LOOP_PROPERTIES_REGEX_CLOSED,
+  "LoopPropertiesStartsWith": LOOP_PROPERTIES_STARTS_WITH,
+  "LoopPropertiesExcept": LOOP_PROPERTIES_EXCEPT,
+  "LoopPropertiesType": LOOP_PROPERTIES_TYPE,
+  "LoopPropertiesTypeEvaluate": LOOP_PROPERTIES_TYPE_EVALUATE,
+  "LoopPropertiesExactlyTypeStrict": LOOP_PROPERTIES_EXACTLY_TYPE_STRICT,
+  "LoopPropertiesExactlyTypeStrictHash": LOOP_PROPERTIES_EXACTLY_TYPE_STRICT_HASH,
+  "LoopPropertiesTypeStrict": LOOP_PROPERTIES_TYPE_STRICT,
+  "LoopPropertiesTypeStrictEvaluate": LOOP_PROPERTIES_TYPE_STRICT_EVALUATE,
+  "LoopPropertiesTypeStrictAny": LOOP_PROPERTIES_TYPE_STRICT_ANY,
+  "LoopPropertiesTypeStrictAnyEvaluate": LOOP_PROPERTIES_TYPE_STRICT_ANY_EVALUATE,
+  "LoopKeys": LOOP_KEYS,
+  "LoopItems": LOOP_ITEMS,
+  "LoopItemsFrom": LOOP_ITEMS_FROM,
+  "LoopItemsUnevaluated": LOOP_ITEMS_UNEVALUATED,
+  "LoopItemsType": LOOP_ITEMS_TYPE,
+  "LoopItemsTypeStrict": LOOP_ITEMS_TYPE_STRICT,
+  "LoopItemsTypeStrictAny": LOOP_ITEMS_TYPE_STRICT_ANY,
+  "LoopItemsPropertiesExactlyTypeStrictHash": LOOP_ITEMS_PROPERTIES_EXACTLY_TYPE_STRICT_HASH,
+  "LoopItemsPropertiesExactlyTypeStrictHash3": LOOP_ITEMS_PROPERTIES_EXACTLY_TYPE_STRICT_HASH3,
+  "LoopItemsIntegerBounded": LOOP_ITEMS_INTEGER_BOUNDED,
+  "LoopItemsIntegerBoundedSized": LOOP_ITEMS_INTEGER_BOUNDED_SIZED,
+  "LoopContains": LOOP_CONTAINS,
+  "ControlGroup": CONTROL_GROUP,
+  "ControlGroupWhenDefines": CONTROL_GROUP_WHEN_DEFINES,
+  "ControlGroupWhenDefinesDirect": CONTROL_GROUP_WHEN_DEFINES_DIRECT,
+  "ControlGroupWhenType": CONTROL_GROUP_WHEN_TYPE,
+  "ControlEvaluate": CONTROL_EVALUATE,
+  "ControlDynamicAnchorJump": CONTROL_DYNAMIC_ANCHOR_JUMP,
+  "ControlJump": CONTROL_JUMP,
+  "Annotation": -1
+};
+
+export const ANNOTATION_OPCODES = new Set([
+  ANNOTATION_EMIT, ANNOTATION_TO_PARENT, ANNOTATION_BASENAME_TO_PARENT
+]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sourcemeta/blaze",
-  "version": "15.0.0",
+  "version": "15.2.0",
   "description": "A pure JavaScript port of the evaluator from Blaze, a high-performance C++ JSON Schema validator. Zero dependencies. Supports Draft 4, Draft 6, Draft 7, 2019-09, and 2020-12 with schema-specific code generation for near-native speed",
   "type": "module",
   "main": "./index.mjs",
@@ -20,7 +20,7 @@
     "url": "https://www.sourcemeta.com"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=21.7"
   },
   "funding": "https://github.com/sponsors/sourcemeta",
   "keywords": [
@@ -66,6 +66,8 @@
   "files": [
     "index.mjs",
     "index.d.mts",
+    "opcodes.mjs",
+    "describe.mjs",
     "README.md",
     "LICENSE"
   ]