@hyperjump/json-schema 1.13.0 → 1.14.1

package/lib/core.js

@@ -11,6 +11,8 @@ import { InvalidSchemaError } from "./invalid-schema-error.js";
 import { getSchema, registerSchema, unregisterSchema as schemaUnregister } from "./schema.js";
 import { getKeywordName } from "./keywords.js";
 import Validation from "./keywords/validation.js";
+import { basicOutputPlugin } from "./evaluation-plugins/basic-output.js";
+import { detailedOutputPlugin } from "./evaluation-plugins/detailed-output.js";
 
 
 export const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED";
@@ -25,16 +27,29 @@ export const validate = async (url, value = undefined, outputFormat = undefined)
 };
 
 export const compile = async (schema) => {
-  const ast = { metaData: {} };
+  const ast = { metaData: {}, plugins: new Set() };
   const schemaUri = await Validation.compile(schema, ast);
   return { ast, schemaUri };
 };
 
 export const interpret = curry(({ ast, schemaUri }, instance, outputFormat = FLAG) => {
-  const errors = [];
-  const context = { ast, dynamicAnchors: {}, errors, annotations: [], outputFormat };
+  const context = { ast, plugins: [...ast.plugins] };
+
+  switch (outputFormat) {
+    case FLAG:
+      break;
+    case BASIC:
+      context.plugins.push(basicOutputPlugin);
+      break;
+    case DETAILED:
+      context.plugins.push(detailedOutputPlugin);
+      break;
+    default:
+      throw Error(`Unsupported output format '${outputFormat}'`);
+  }
+
   const valid = Validation.interpret(schemaUri, instance, context);
-  return outputFormat === FLAG || valid ? { valid } : { valid, errors };
+  return !valid && "errors" in context ? { valid, errors: context.errors } : { valid };
 });
 
 const metaValidators = {};

package/lib/evaluation-plugins/annotations.js

@@ -0,0 +1,32 @@
+import * as Instance from "../instance.js";
+
+
+export const annotationsPlugin = {
+  beforeSchema(_url, _instance, context) {
+    context.annotations ??= [];
+    context.schemaAnnotations = [];
+  },
+  beforeKeyword(_node, _instance, context) {
+    context.annotations = [];
+  },
+  afterKeyword(node, instance, context, valid, schemaContext, keyword) {
+    if (valid) {
+      const [keywordId, schemaUri, keywordValue] = node;
+      const annotation = keyword.annotation?.(keywordValue, instance, context);
+      if (annotation !== undefined) {
+        schemaContext.schemaAnnotations.push({
+          keyword: keywordId,
+          absoluteKeywordLocation: schemaUri,
+          instanceLocation: Instance.uri(instance),
+          annotation: annotation
+        });
+      }
+      schemaContext.schemaAnnotations.push(...context.annotations);
+    }
+  },
+  afterSchema(_schemaNode, _instanceNode, context, valid) {
+    if (valid) {
+      context.annotations.push(...context.schemaAnnotations);
+    }
+  }
+};

package/lib/evaluation-plugins/basic-output.js

@@ -0,0 +1,34 @@
+import { Validation } from "../experimental.js";
+import * as Instance from "../instance.js";
+
+
+export const basicOutputPlugin = {
+  beforeSchema(_url, _intance, context) {
+    context.errors ??= [];
+  },
+  beforeKeyword(_node, _instance, context) {
+    context.errors = [];
+  },
+  afterKeyword(node, instance, context, valid, schemaContext, keyword) {
+    if (!valid) {
+      if (!keyword.simpleApplicator) {
+        const [keywordId, schemaUri] = node;
+        schemaContext.errors.push({
+          keyword: keywordId,
+          absoluteKeywordLocation: schemaUri,
+          instanceLocation: Instance.uri(instance)
+        });
+      }
+      schemaContext.errors.push(...context.errors);
+    }
+  },
+  afterSchema(url, instance, context, valid) {
+    if (typeof context.ast[url] === "boolean" && !valid) {
+      context.errors.push({
+        keyword: Validation.id,
+        absoluteKeywordLocation: url,
+        instanceLocation: Instance.uri(instance)
+      });
+    }
+  }
+};

package/lib/evaluation-plugins/detailed-output.js

@@ -0,0 +1,36 @@
+import { Validation } from "../experimental.js";
+import * as Instance from "../instance.js";
+
+
+export const detailedOutputPlugin = {
+  beforeSchema(_url, _instance, context) {
+    context.errors ??= [];
+  },
+  beforeKeyword(_node, _instance, context) {
+    context.errors = [];
+  },
+  afterKeyword(node, instance, context, valid, schemaContext) {
+    if (!valid) {
+      const [keywordId, schemaUri] = node;
+      const outputUnit = {
+        keyword: keywordId,
+        absoluteKeywordLocation: schemaUri,
+        instanceLocation: Instance.uri(instance)
+      };
+
+      schemaContext.errors.push(outputUnit);
+      if (context.errors.length > 0) {
+        outputUnit.errors = context.errors;
+      }
+    }
+  },
+  afterSchema(url, instance, context, valid) {
+    if (typeof context.ast[url] === "boolean" && !valid) {
+      context.errors.push({
+        keyword: Validation.id,
+        absoluteKeywordLocation: url,
+        instanceLocation: Instance.uri(instance)
+      });
+    }
+  }
+};

package/lib/experimental.d.ts

@@ -18,6 +18,7 @@ export type CompiledSchema = {
 
 type AST = {
   metaData: Record<string, MetaData>;
+  plugins: Set<EvaluationPlugin<unknown>>;
 } & Record<string, Node<unknown>[] | boolean>;
 
 type Node<A> = [keywordId: string, schemaUri: string, keywordValue: A];
@@ -70,18 +71,30 @@ export type Keyword<A> = {
   compile: (schema: Browser<SchemaDocument>, ast: AST, parentSchema: Browser<SchemaDocument>) => Promise<A>;
   interpret: (compiledKeywordValue: A, instance: JsonNode, context: ValidationContext) => boolean;
   simpleApplicator: boolean;
-  collectEvaluatedProperties?: (compiledKeywordValue: A, instance: JsonNode, context: ValidationContext, isTop?: boolean) => Set<string> | false;
-  collectEvaluatedItems?: (compiledKeywordValue: A, instance: JsonNode, context: ValidationContext, isTop?: boolean) => Set<number> | false;
-  collectExternalIds?: (visited: Set<string>, parentSchema: Browser<SchemaDocument>, schema: Browser<SchemaDocument>) => Promise<Set<string>>;
   annotation?: <B>(compiledKeywordValue: A, instance: JsonNode) => B | undefined;
 };
 
 export type ValidationContext = {
   ast: AST;
-  dynamicAnchors: Anchors;
+  plugins: EvaluationPlugin<unknown>[];
+};
+
+export type EvaluationPlugin<Context> = {
+  beforeSchema(url: string, instance: JsonNode, context: Context): void;
+  beforeKeyword(keywordNode: Node<unknown>, instance: JsonNode, context: Context, schemaContext: Context, keyword: Keyword): void;
+  afterKeyword(keywordNode: Node<unknown>, instance: JsonNode, context: Context, valid: boolean, schemaContext: Context, keyword: Keyword): void;
+  afterSchema(url: string, instance: JsonNode, context: Context, valid: boolean): void;
+};
+
+export const basicOutputPlugin: EvaluationPlugin<ErrorsContext>;
+export const detailedOutputPlugin: EvaluationPlugin<ErrorsContext>;
+export type ErrorsContext = {
   errors: OutputUnit[];
+};
+
+export const annotationsPlugin: EvaluationPlugin<AnnotationsContext>;
+export type AnnotationsContext = {
   annotations: OutputUnit[];
-  outputFormat: OutputFormat;
 };
 
 export const Validation: Keyword<string>;

package/lib/experimental.js

@@ -6,3 +6,6 @@ export {
 } from "./keywords.js";
 export { getSchema, toSchema, canonicalUri, buildSchemaDocument } from "./schema.js";
 export { default as Validation } from "./keywords/validation.js";
+export { basicOutputPlugin } from "./evaluation-plugins/basic-output.js";
+export { detailedOutputPlugin } from "./evaluation-plugins/detailed-output.js";
+export { annotationsPlugin } from "./evaluation-plugins/annotations.js";

package/lib/instance.js

@@ -27,7 +27,8 @@ export const fromJs = (value, uri = "", pointer = "", parent = undefined) => {
         objectNode.children = Object.entries(value).map((entry) => {
           const propertyPointer = JsonPointer.append(entry[0], pointer);
           const propertyNode = cons(uri, propertyPointer, undefined, "property", [], objectNode);
-          propertyNode.children = entry.map((property) => fromJs(property, uri, propertyPointer, propertyNode));
+          propertyNode.children[0] = fromJs(entry[0], uri, "*" + propertyPointer, propertyNode);
+          propertyNode.children[1] = fromJs(entry[1], uri, propertyPointer, propertyNode);
           return propertyNode;
         });
         return objectNode;
@@ -62,11 +63,19 @@ export const get = (uri, instance) => {
     throw Error(`Reference '${uri}' is not local to '${instance.baseUri}'`);
   }
 
-  const pointer = uriFragment(uri);
-  return reduce((node, segment) => {
+  let isPropertyNamePointer = false;
+  let pointer = uriFragment(uri);
+  if (pointer.startsWith("*")) {
+    pointer = pointer.slice(1);
+    isPropertyNamePointer = true;
+  }
+
+  const result = reduce((node, segment) => {
     segment = segment === "-" && typeOf(node) === "array" ? length(node) : segment;
     return step(segment, node);
   }, instance.root, JsonPointer.pointerSegments(pointer));
+
+  return isPropertyNamePointer ? result.parent.children[0] : result;
 };
 
 export const uri = (node) => `${node.baseUri}#${encodeURI(node.pointer)}`;

package/lib/keywords/additionalProperties.js

@@ -39,9 +39,15 @@ const interpret = ([isDefinedProperty, additionalProperties], instance, context)
   let isValid = true;
   for (const [propertyNameNode, property] of Instance.entries(instance)) {
     const propertyName = Instance.value(propertyNameNode);
-    if (!isDefinedProperty.test(propertyName) && !Validation.interpret(additionalProperties, property, context)) {
+    if (isDefinedProperty.test(propertyName)) {
+      continue;
+    }
+
+    if (!Validation.interpret(additionalProperties, property, context)) {
       isValid = false;
     }
+
+    context.evaluatedProperties?.add(propertyName);
   }
 
   return isValid;
@@ -49,24 +55,4 @@ const interpret = ([isDefinedProperty, additionalProperties], instance, context)
 
 const simpleApplicator = true;
 
-const collectEvaluatedProperties = ([isDefinedProperty, additionalProperties], instance, context) => {
-  if (Instance.typeOf(instance) !== "object") {
-    return true;
-  }
-
-  const evaluatedPropertyNames = new Set();
-  for (const [propertyNameNode, property] of Instance.entries(instance)) {
-    const propertyName = Instance.value(propertyNameNode);
-    if (!isDefinedProperty.test(propertyName)) {
-      if (!Validation.interpret(additionalProperties, property, context)) {
-        return false;
-      }
-
-      evaluatedPropertyNames.add(propertyName);
-    }
-  }
-
-  return evaluatedPropertyNames;
-};
-
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties };
+export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/allOf.js

@@ -23,32 +23,4 @@ const interpret = (allOf, instance, ast, dynamicAnchors, quiet) => {
 
 const simpleApplicator = true;
 
-const collectEvaluatedProperties = (allOf, instance, context) => {
-  const evaluatedPropertyNames = new Set();
-  for (const schemaUrl of allOf) {
-    const propertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, context);
-    if (!propertyNames) {
-      return false;
-    }
-
-    propertyNames.forEach(evaluatedPropertyNames.add, evaluatedPropertyNames);
-  }
-
-  return evaluatedPropertyNames;
-};
-
-const collectEvaluatedItems = (allOf, instance, context) => {
-  const evaluatedItemIndexes = new Set();
-  for (const schemaUrl of allOf) {
-    const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, context);
-    if (!itemIndexes) {
-      return false;
-    }
-
-    itemIndexes.forEach(evaluatedItemIndexes.add, evaluatedItemIndexes);
-  }
-
-  return evaluatedItemIndexes;
-};
-
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/anyOf.js

@@ -16,30 +16,4 @@ const interpret = (anyOf, instance, ast, dynamicAnchors, quiet) => {
   return matches.length > 0;
 };
 
-const collectEvaluatedProperties = (anyOf, instance, context) => {
-  let evaluatedPropertyNames = false;
-  for (const schemaUrl of anyOf) {
-    const propertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, context);
-    if (propertyNames) {
-      evaluatedPropertyNames ||= new Set();
-      propertyNames.forEach(evaluatedPropertyNames.add, evaluatedPropertyNames);
-    }
-  }
-
-  return evaluatedPropertyNames;
-};
-
-const collectEvaluatedItems = (anyOf, instance, context) => {
-  let evaluatedItemIndexes = false;
-  for (const schemaUrl of anyOf) {
-    const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, context);
-    if (itemIndexes) {
-      evaluatedItemIndexes ||= new Set();
-      itemIndexes.forEach(evaluatedItemIndexes.add, evaluatedItemIndexes);
-    }
-  }
-
-  return evaluatedItemIndexes;
-};
-
-export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret };

package/lib/keywords/conditional.js

@@ -25,32 +25,6 @@ const interpret = (conditional, instance, context) => {
   return true;
 };
 
-const collectEvaluatedProperties = (conditional, instance, context) => {
-  for (let index = 0; index < conditional.length; index += 2) {
-    const unevaluatedProperties = Validation.collectEvaluatedProperties(conditional[index], instance, context);
-    if (index + 1 === conditional.length) {
-      return unevaluatedProperties;
-    } else if (unevaluatedProperties !== false) {
-      return Validation.collectEvaluatedProperties(conditional[index + 1], instance, context);
-    }
-  }
-
-  return new Set();
-};
-
-const collectEvaluatedItems = (conditional, instance, context) => {
-  for (let index = 0; index < conditional.length; index += 2) {
-    const unevaluatedItems = Validation.collectEvaluatedItems(conditional[index], instance, context);
-    if (index + 1 === conditional.length) {
-      return unevaluatedItems;
-    } else if (unevaluatedItems !== false) {
-      return Validation.collectEvaluatedItems(conditional[index + 1], instance, context);
-    }
-  }
-
-  return new Set();
-};
-
 const schemaFlatten = async function* (iter, depth = 1) {
   for await (const n of iter) {
     if (depth > 0 && Browser.typeOf(n) === "array") {
@@ -61,4 +35,4 @@ const schemaFlatten = async function* (iter, depth = 1) {
   }
 };
 
-export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret };

package/lib/keywords/contains.js

@@ -1,4 +1,3 @@
-import { pipe, filter, reduce, zip, range, map, collectSet } from "@hyperjump/pact";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 import { getKeywordName, Validation } from "../experimental.js";
@@ -21,23 +20,20 @@ const compile = async (schema, ast, parentSchema) => {
 };
 
 const interpret = ({ contains, minContains, maxContains }, instance, context) => {
-  const matches = Instance.typeOf(instance) !== "array" || pipe(
-    Instance.iter(instance),
-    filter((item) => Validation.interpret(contains, item, context)),
-    reduce((matches) => matches + 1, 0)
-  );
+  if (Instance.typeOf(instance) !== "array") {
+    return true;
+  }
+
+  let matches = 0;
+  let index = 0;
+  for (const item of Instance.iter(instance)) {
+    if (Validation.interpret(contains, item, context)) {
+      matches++;
+      context.evaluatedItems?.add(index);
+    }
+    index++;
+  }
   return matches >= minContains && matches <= maxContains;
 };
 
-const collectEvaluatedItems = (keywordValue, instance, context) => {
-  return interpret(keywordValue, instance, context)
-    && Instance.typeOf(instance) === "array"
-    && pipe(
-      zip(Instance.iter(instance), range(0)),
-      filter(([item]) => Validation.interpret(keywordValue.contains, item, context)),
-      map(([, itemIndex]) => itemIndex),
-      collectSet
-    );
-};
-
-export default { id, compile, interpret, collectEvaluatedItems };
+export default { id, compile, interpret };

package/lib/keywords/contentSchema.js

@@ -1,4 +1,3 @@
-import { canonicalUri } from "../schema.js";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 import { getKeywordName } from "../keywords.js";
@@ -9,13 +8,17 @@ const id = "https://json-schema.org/keyword/contentSchema";
 const compile = async (contentSchema, _ast, parentSchema) => {
   const contentMediaTypeKeyword = getKeywordName(contentSchema.document.dialectId, "https://json-schema.org/keyword/contentMediaType");
   const contentMediaType = await Browser.step(contentMediaTypeKeyword, parentSchema);
-  return Browser.value(contentMediaType) && canonicalUri(contentSchema);
+  if (Browser.value(contentMediaType) === undefined) {
+    return;
+  }
+
+  return Browser.value(contentSchema);
 };
 
 const interpret = () => true;
 
 const annotation = (contentSchema, instance) => {
-  if (Instance.typeOf(instance) !== "string") {
+  if (!contentSchema || Instance.typeOf(instance) !== "string") {
     return;
   }
 

package/lib/keywords/dependentSchemas.js

@@ -29,24 +29,4 @@ const interpret = (dependentSchemas, instance, context) => {
 
 const simpleApplicator = true;
 
-const collectEvaluatedProperties = (dependentSchemas, instance, context) => {
-  if (Instance.typeOf(instance) !== "object") {
-    return false;
-  }
-
-  const evaluatedPropertyNames = new Set();
-  for (const [propertyName, dependentSchema] of dependentSchemas) {
-    if (Instance.has(propertyName, instance)) {
-      const propertyNames = Validation.collectEvaluatedProperties(dependentSchema, instance, context);
-      if (propertyNames === false) {
-        return false;
-      }
-
-      propertyNames.forEach(Set.prototype.add.bind(evaluatedPropertyNames));
-    }
-  }
-
-  return evaluatedPropertyNames;
-};
-
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties };
+export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/dynamicRef.js

@@ -1,5 +1,6 @@
 import * as Browser from "@hyperjump/browser";
 import { Validation } from "../experimental.js";
+import { toAbsoluteUri } from "../common.js";
 
 
 const id = "https://json-schema.org/keyword/dynamicRef";
@@ -12,17 +13,29 @@ const compile = async (schema, ast) => {
   return reference;
 };
 
-const evaluate = (strategy, fragment, instance, context) => {
+const interpret = (fragment, instance, context) => {
   if (!(fragment in context.dynamicAnchors)) {
     throw Error(`No dynamic anchor found for "${fragment}"`);
   }
-  return strategy(context.dynamicAnchors[fragment], instance, context);
+  return Validation.interpret(context.dynamicAnchors[fragment], instance, context);
 };
 
 const simpleApplicator = true;
 
-const interpret = (...args) => evaluate(Validation.interpret, ...args);
-const collectEvaluatedProperties = (...args) => evaluate(Validation.collectEvaluatedProperties, ...args);
-const collectEvaluatedItems = (...args) => evaluate(Validation.collectEvaluatedItems, ...args);
+const plugin = {
+  beforeSchema(url, _instance, context) {
+    context.dynamicAnchors = {
+      ...context.ast.metaData[toAbsoluteUri(url)].dynamicAnchors,
+      ...context.dynamicAnchors
+    };
+  },
+  beforeKeyword(_url, _instance, context, schemaContext) {
+    context.dynamicAnchors = schemaContext.dynamicAnchors;
+  },
+  afterKeyword() {
+  },
+  afterSchema() {
+  }
+};
 
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator, plugin };

package/lib/keywords/else.js

@@ -1,5 +1,4 @@
 import * as Browser from "@hyperjump/browser";
-import { FLAG } from "../index.js";
 import { getKeywordName, Validation } from "../experimental.js";
 
 
@@ -17,26 +16,10 @@ const compile = async (schema, ast, parentSchema) => {
 
 const interpret = ([ifSchema, elseSchema], instance, context) => {
   return ifSchema === undefined
-    || Validation.interpret(ifSchema, instance, { ...context, errors: [], annotations: [], oututFormat: FLAG })
+    || Validation.interpret(ifSchema, instance, { ...context, plugins: context.ast.plugins })
     || Validation.interpret(elseSchema, instance, context);
 };
 
 const simpleApplicator = true;
 
-const collectEvaluatedProperties = ([ifSchema, elseSchema], instance, context) => {
-  if (ifSchema === undefined || Validation.interpret(ifSchema, instance, context)) {
-    return new Set();
-  }
-
-  return Validation.collectEvaluatedProperties(elseSchema, instance, context);
-};
-
-const collectEvaluatedItems = ([ifSchema, elseSchema], instance, context) => {
-  if (ifSchema === undefined || Validation.interpret(ifSchema, instance, context)) {
-    return new Set();
-  }
-
-  return Validation.collectEvaluatedItems(elseSchema, instance, context);
-};
-
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/if.js

@@ -10,12 +10,4 @@ const interpret = (ifSchema, instance, context) => {
   return true;
 };
 
-const collectEvaluatedProperties = (ifSchema, instance, context) => {
-  return Validation.collectEvaluatedProperties(ifSchema, instance, context) || new Set();
-};
-
-const collectEvaluatedItems = (ifSchema, instance, context) => {
-  return Validation.collectEvaluatedItems(ifSchema, instance, context) || new Set();
-};
-
-export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret };

package/lib/keywords/itemPattern.js

@@ -39,7 +39,7 @@ const compile = async (schema, ast) => {
     .reduce(union);
 };
 
-const evaluate = (strategy, nfa, instance, context) => {
+const interpret = (nfa, instance, context) => {
   if (Instance.typeOf(instance) !== "array") {
     return true;
   }
@@ -51,7 +51,7 @@ const evaluate = (strategy, nfa, instance, context) => {
     const nextStates = [];
 
     for (const state of currentStates) {
-      const nextState = transition(strategy, state.transition, item, context);
+      const nextState = transition(state.transition, item, context);
       if (nextState) {
         addNextState(nextState, nextStates, []);
       }
@@ -76,16 +76,12 @@ const addNextState = (state, nextStates, visited) => {
   }
 };
 
-const transition = (strategy, transitions, instance, context) => {
+const transition = (transitions, instance, context) => {
   for (const schema in transitions) {
-    if (strategy(schema, instance, context)) {
+    if (Validation.interpret(schema, instance, context)) {
       return transitions[schema];
     }
   }
 };
 
-const interpret = (...args) => evaluate(Validation.interpret, ...args);
-const collectEvalatedProperties = (...args) => evaluate(Validation.collectEvaluatedProperties, ...args);
-const collectEvalatedItems = (...args) => evaluate(Validation.collectEvaluatedItems, ...args);
-
-export default { id, compile, interpret, collectEvalatedProperties, collectEvalatedItems };
+export default { id, compile, interpret };

package/lib/keywords/items.js

@@ -20,10 +20,14 @@ const interpret = ([numberOfPrefixItems, items], instance, context) => {
   }
 
   let isValid = true;
+  let index = numberOfPrefixItems;
   for (const item of drop(numberOfPrefixItems, Instance.iter(instance))) {
     if (!Validation.interpret(items, item, context)) {
       isValid = false;
     }
+
+    context.evaluatedItems?.add(index);
+    index++;
   }
 
   return isValid;
@@ -31,17 +35,4 @@ const interpret = ([numberOfPrefixItems, items], instance, context) => {
 
 const simpleApplicator = true;
 
-const collectEvaluatedItems = (keywordValue, instance, context) => {
-  if (!interpret(keywordValue, instance, context)) {
-    return false;
-  }
-
-  const evaluatedIndexes = new Set();
-  for (let ndx = keywordValue[0]; ndx < Instance.length(instance); ndx++) {
-    evaluatedIndexes.add(ndx);
-  }
-
-  return evaluatedIndexes;
-};
-
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator };