@hyperjump/json-schema 1.5.1 → 1.6.0

package/README.md

@@ -18,7 +18,9 @@ A collection of modules for working with JSON Schemas.
 * Provides utilities for working with annotations
 
 ## Install
-Includes support for node.js (ES Modules, TypeScript) and browsers.
+Includes support for node.js/bun.js (ES Modules, TypeScript) and browsers (works
+with CSP
+[`unsafe-eval`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src#unsafe_eval_expressions)).
 
 ### Node.js
 ```bash
@@ -40,6 +42,16 @@ configuration.
   ]
 ```
 
+### TypeScript
+This package uses the package.json "exports" field. [TypeScript understands
+"exports"](https://devblogs.microsoft.com/typescript/announcing-typescript-4-5-beta/#packagejson-exports-imports-and-self-referencing),
+but you need to change a couple settings in your `tsconfig.json` for it to work.
+
+```jsonc
+    "module": "Node16", // or "NodeNext"
+    "moduleResolution": "Node16", // or "NodeNext"
+```
+
 ### Versioning
 The API for this library is divided into two categories: Stable and
 Experimental. The Stable API strictly follows semantic versioning, but the
@@ -96,20 +108,30 @@ const output2 = isString(42);
 
 **Fetching schemas**
 
-You can fetch schemas from the web or from the file system, but when fetching
-from the file system, there are limitations for security reasons. If your schema
-has an identifier with an http(s) scheme (**https**://example.com), it's not
-allowed to reference schemas with a file scheme
-(**file**:///path/to/my/schemas).
+Schemas that are available on the web can be loaded automatically without
+needing to load them manually.
 
 ```javascript
 const output = await validate("http://example.com/schemas/string", "foo");
 ```
 
+When running on the server, you can also load schemas directly from the
+filesystem using `file:` URIs. When fetching from the file system, there are
+limitations for security reasons. If your schema has an identifier with an
+http(s) scheme (**https**://example.com), it's not allowed to reference schemas
+with a file scheme (**file**:///path/to/my/schemas).
+
 ```javascript
 const output = await validate(`file://${__dirname}/string.schema.json`, "foo");
 ```
 
+If the schema URI is relative, the base URI in the browser is the browser
+location and the base URI on the server is the current working directory.
+
+```javascript
+const output = await validate(`./string.schema.json`, "foo");
+```
+
 **Media type plugins**
 
 There is a plugin system for adding support for different media types. By

package/lib/context-uri.browser.js

@@ -0,0 +1 @@
+export const contextUri = () => document.location.toString();

package/lib/context-uri.js

@@ -0,0 +1,4 @@
+import { cwd } from "node:process";
+
+
+export const contextUri = () => `file://${cwd()}/`;

package/lib/core.d.ts

@@ -20,7 +20,7 @@ export const addSchema: typeof add;
 
 export type Validator = (value: unknown, outputFormat?: OutputFormat) => OutputUnit;
 
-export type OutputFormat = "FLAG" | "BASIC" | "DETAILED" | "VERBOSE" | string;
+export type OutputFormat = "FLAG" | "BASIC" | "DETAILED" | "VERBOSE";
 
 export type OutputUnit = {
   keyword: string;

package/lib/core.js

@@ -90,9 +90,15 @@ subscribe("validate.metaValidate", async (message, schema) => {
       const isDynamicRefEnabled = isExperimentalKeywordEnabled(dyanmicRefKeywordId);
       setExperimentalKeywordEnabled(dyanmicRefKeywordId, true);
 
+      // itemPattern is experimental, but is necessary for meta-validation
+      const itemPatternKeywordId = "https://json-schema.org/keyword/itemPattern";
+      const isItemPatternEnabled = isExperimentalKeywordEnabled(itemPatternKeywordId);
+      setExperimentalKeywordEnabled(itemPatternKeywordId, true);
+
       const compiledSchema = await compile(schema.dialectId);
       metaValidators[schema.dialectId] = interpret(compiledSchema);
 
+      setExperimentalKeywordEnabled(itemPatternKeywordId, isItemPatternEnabled);
       setExperimentalKeywordEnabled(dyanmicRefKeywordId, isDynamicRefEnabled);
     }
 

package/lib/fetch.js

@@ -1,15 +1,15 @@
-import fs from "fs/promises";
+import { createReadStream } from "node:fs";
+import { Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
 import { fetch, Response } from "undici";
-import Url from "url";
 import * as MediaTypes from "./media-types.js";
 
 
-export default async (url, options) => {
+export default (url, options) => {
   if (url.startsWith("file://")) {
-    const filePath = Url.fileURLToPath(url);
-    const fd = await fs.open(filePath);
-    const stream = fd.createReadStream();
-    const response = new Response(stream, {
+    const filePath = fileURLToPath(url);
+    const stream = createReadStream(filePath);
+    const response = new Response(Readable.toWeb(stream), {
       headers: { "Content-Type": MediaTypes.getContentType(filePath) }
     });
     Object.defineProperty(response, "url", { value: url });

package/lib/index.js

@@ -5,6 +5,7 @@ import additionalProperties from "./keywords/additionalProperties.js";
 import allOf from "./keywords/allOf.js";
 import anchor from "./keywords/anchor.js";
 import anyOf from "./keywords/anyOf.js";
+import conditional from "./keywords/conditional.js";
 import const_ from "./keywords/const.js";
 import contains from "./keywords/contains.js";
 import comment from "./keywords/comment.js";
@@ -27,6 +28,7 @@ import exclusiveMinimum from "./keywords/exclusiveMinimum.js";
 import format from "./keywords/format.js";
 import id from "./keywords/id.js";
 import if_ from "./keywords/if.js";
+import itemPattern from "./keywords/itemPattern.js";
 import items from "./keywords/items.js";
 import maxContains from "./keywords/maxContains.js";
 import maxItems from "./keywords/maxItems.js";
@@ -74,6 +76,7 @@ addKeyword(additionalProperties);
 addKeyword(allOf);
 addKeyword(anchor);
 addKeyword(anyOf);
+addKeyword(conditional);
 addKeyword(const_);
 addKeyword(contains);
 addKeyword(comment);
@@ -120,6 +123,7 @@ addKeyword(readOnly);
 addKeyword(ref);
 addKeyword(requireAllExcept);
 addKeyword(required);
+addKeyword(itemPattern);
 addKeyword(title);
 addKeyword(then);
 addKeyword(type);

package/lib/keywords/additionalProperties.js

@@ -1,4 +1,4 @@
-import { filter, every, pipe } from "@hyperjump/pact";
+import { concat, join, empty, map, filter, every, pipe } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import { getKeywordName } from "../keywords.js";
@@ -8,26 +8,24 @@ import Validation from "./validation.js";
 const id = "https://json-schema.org/keyword/additionalProperties";
 
 const compile = async (schema, ast, parentSchema) => {
-  const patterns = [];
-
   const propertiesKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/properties");
   const propertiesSchema = await Schema.step(propertiesKeyword, parentSchema);
-  if (Schema.typeOf(propertiesSchema, "object")) {
-    for (const name of Schema.keys(propertiesSchema)) {
-      patterns.push(regexEscape(name));
-    }
-  }
+  const propertyPatterns = Schema.typeOf(propertiesSchema, "object")
+    ? map((propertyName) => "^" + regexEscape(propertyName) + "$", Schema.keys(propertiesSchema))
+    : empty();
 
   const patternPropertiesKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/patternProperties");
   const patternProperties = await Schema.step(patternPropertiesKeyword, parentSchema);
-  if (Schema.typeOf(patternProperties, "object")) {
-    patterns.push(...Schema.keys(patternProperties));
-  }
+  const patternPropertyPatterns = Schema.typeOf(patternProperties, "object")
+    ? Schema.keys(patternProperties)
+    : empty();
+
+  const pattern = pipe(
+    concat(propertyPatterns, patternPropertyPatterns),
+    join("|")
+  ) || "(?!)";
 
-  return [
-    new RegExp(patterns.length > 0 ? patterns.join("|") : "(?!)", "u"),
-    await Validation.compile(schema, ast)
-  ];
+  return [new RegExp(pattern, "u"), await Validation.compile(schema, ast)];
 };
 
 const regexEscape = (string) => string

package/lib/keywords/conditional.js

@@ -0,0 +1,65 @@
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
+import * as Schema from "../schema.js";
+import Validation from "./validation.js";
+
+
+const id = "https://json-schema.org/keyword/conditional";
+const experimental = true;
+
+const compile = (schema, ast) => pipe(
+  Schema.iter(schema),
+  schemaFlatten,
+  asyncMap((subSchema) => Validation.compile(subSchema, ast)),
+  asyncCollectArray
+);
+
+const interpret = (conditional, instance, ast, dynamicAnchors, quiet) => {
+  for (let index = 0; index < conditional.length; index += 2) {
+    const isValid = Validation.interpret(conditional[index], instance, ast, dynamicAnchors, quiet);
+    if (index + 1 === conditional.length) {
+      return isValid;
+    } else if (isValid) {
+      return Validation.interpret(conditional[index + 1], instance, ast, dynamicAnchors, quiet);
+    }
+  }
+
+  return true;
+};
+
+const collectEvaluatedProperties = (conditional, instance, ast, dynamicAnchors) => {
+  for (let index = 0; index < conditional.length; index += 2) {
+    const unevaluatedProperties = Validation.collectEvaluatedProperties(conditional[index], instance, ast, dynamicAnchors);
+    if (index + 1 === conditional.length) {
+      return unevaluatedProperties;
+    } else if (unevaluatedProperties !== false) {
+      return Validation.collectEvaluatedProperties(conditional[index + 1], instance, ast, dynamicAnchors);
+    }
+  }
+
+  return new Set();
+};
+
+const collectEvaluatedItems = (conditional, instance, ast, dynamicAnchors) => {
+  for (let index = 0; index < conditional.length; index += 2) {
+    const unevaluatedItems = Validation.collectEvaluatedItems(conditional[index], instance, ast, dynamicAnchors);
+    if (index + 1 === conditional.length) {
+      return unevaluatedItems;
+    } else if (unevaluatedItems !== false) {
+      return Validation.collectEvaluatedItems(conditional[index + 1], instance, ast, dynamicAnchors);
+    }
+  }
+
+  return new Set();
+};
+
+const schemaFlatten = async function* (iter, depth = 1) {
+  for await (const n of iter) {
+    if (depth > 0 && Schema.typeOf(n, "array")) {
+      yield* schemaFlatten(Schema.iter(n), depth - 1);
+    } else {
+      yield n;
+    }
+  }
+};
+
+export default { id, experimental, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/contains.js

@@ -1,4 +1,4 @@
-import { pipe, map, filter, reduce, collectSet, zip, range } from "@hyperjump/pact";
+import { pipe, map, filter, count, collectSet, zip, range } from "@hyperjump/pact";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
 import { getKeywordName } from "../keywords.js";
@@ -34,7 +34,7 @@ const interpret = ({ contains, minContains, maxContains }, instance, ast, dynami
   const matches = pipe(
     iterator,
     filter((item) => Validation.interpret(contains, item, ast, dynamicAnchors, quiet)),
-    reduce((matches) => matches + 1, 0)
+    count
   );
   return matches >= minContains && matches <= maxContains;
 };

package/lib/keywords/dependentRequired.js

@@ -12,10 +12,8 @@ const compile = (schema) => pipe(
 );
 
 const interpret = (dependentRequired, instance) => {
-  const value = Instance.value(instance);
-
   return !Instance.typeOf(instance, "object") || dependentRequired.every(([propertyName, required]) => {
-    return !(propertyName in value) || required.every((key) => key in value);
+    return !Instance.has(propertyName, instance) || required.every((key) => Instance.has(key, instance));
   });
 };
 

package/lib/keywords/dependentSchemas.js

@@ -13,22 +13,19 @@ const compile = (schema, ast) => pipe(
 );
 
 const interpret = (dependentSchemas, instance, ast, dynamicAnchors, quiet) => {
-  const value = Instance.value(instance);
-
   return !Instance.typeOf(instance, "object") || dependentSchemas.every(([propertyName, dependentSchema]) => {
-    return !(propertyName in value) || Validation.interpret(dependentSchema, instance, ast, dynamicAnchors, quiet);
+    return !Instance.has(propertyName, instance) || Validation.interpret(dependentSchema, instance, ast, dynamicAnchors, quiet);
   });
 };
 
 const collectEvaluatedProperties = (dependentSchemas, instance, ast, dynamicAnchors) => {
-  const value = Instance.value(instance);
   if (!Instance.typeOf(instance, "object")) {
     return false;
   }
 
   const evaluatedPropertyNames = new Set();
   for (const [propertyName, dependentSchema] of dependentSchemas) {
-    if (propertyName in value) {
+    if (Instance.has(propertyName, instance)) {
       const propertyNames = Validation.collectEvaluatedProperties(dependentSchema, instance, ast, dynamicAnchors);
       if (propertyNames === false) {
         return false;

package/lib/keywords/itemPattern.js

@@ -0,0 +1,88 @@
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
+import Validation from "./validation.js";
+import { fromEpsilon, fromSchema, closure, zeroOrOne, oneOrMore, concat, union } from "../nfa.js";
+
+
+const id = "https://json-schema.org/keyword/itemPattern";
+const experimental = true;
+
+const compile = async (schema, ast) => {
+  const groups = [[]];
+  let group = groups[0];
+
+  for await (const rule of Schema.iter(schema)) {
+    if (Schema.typeOf(rule, "string")) {
+      const operator = Schema.value(rule);
+
+      if (operator === "*") {
+        group.push(closure(group.pop()));
+      } else if (operator === "?") {
+        group.push(zeroOrOne(group.pop()));
+      } else if (operator === "+") {
+        group.push(oneOrMore(group.pop()));
+      } else if (operator === "|") {
+        group = [];
+        groups.push(group);
+      } else {
+        throw Error(`Unsupported pattern syntax: ${operator}`);
+      }
+    } else {
+      const node = Schema.typeOf(rule, "array")
+        ? compile(rule, ast)
+        : fromSchema(await Validation.compile(rule, ast));
+      group.push(await node);
+    }
+  }
+
+  return Schema.length(schema) === 0 ? fromEpsilon() : groups
+    .map((group) => group.reduce(concat))
+    .reduce(union);
+};
+
+const interpret = (nfa, instance, ast, dynamicAnchors, quiet) => {
+  if (!Instance.typeOf(instance, "array")) {
+    return true;
+  }
+
+  let currentStates = [];
+  addNextState(nfa.start, currentStates, []);
+
+  for (const item of Instance.iter(instance)) {
+    const nextStates = [];
+
+    for (const state of currentStates) {
+      const nextState = transition(state.transition, item, ast, dynamicAnchors, quiet);
+      if (nextState) {
+        addNextState(nextState, nextStates, []);
+      }
+    }
+
+    currentStates = nextStates;
+  }
+
+  return Boolean(currentStates.find((s) => s.isEnd));
+};
+
+const addNextState = (state, nextStates, visited) => {
+  if (state.epsilonTransitions.length) {
+    for (const epsilonState of state.epsilonTransitions) {
+      if (!visited.find((visited) => visited === epsilonState)) {
+        visited.push(epsilonState);
+        addNextState(epsilonState, nextStates, visited);
+      }
+    }
+  } else {
+    nextStates.push(state);
+  }
+};
+
+const transition = (transitions, instance, ast, dynamicAnchors, quiet) => {
+  for (const schema in transitions) {
+    if (Validation.interpret(schema, instance, ast, dynamicAnchors, quiet)) {
+      return transitions[schema];
+    }
+  }
+};
+
+export default { id, experimental, compile, interpret };

package/lib/keywords/prefixItems.js

@@ -13,11 +13,7 @@ const compile = (schema, ast) => pipe(
 );
 
 const interpret = (prefixItems, instance, ast, dynamicAnchors, quiet) => {
-  if (!Instance.typeOf(instance, "array")) {
-    return true;
-  }
-
-  return pipe(
+  return !Instance.typeOf(instance, "array") || pipe(
     zip(prefixItems, Instance.iter(instance)),
     take(Instance.length(instance)),
     every(([prefixItem, item]) => Validation.interpret(prefixItem, item, ast, dynamicAnchors, quiet))

package/lib/nfa.js

@@ -0,0 +1,95 @@
+export const fromEpsilon = () => {
+  const start = createState(false);
+  const end = createState(true);
+  addEpsilonTransition(start, end);
+
+  return { start, end };
+};
+
+export const fromSchema = (schema) => {
+  const start = createState(false);
+  const end = createState(true);
+  addTransition(start, end, schema);
+
+  return { start, end };
+};
+
+export const concat = (first, second) => {
+  if (first === undefined) {
+    return second;
+  }
+  addEpsilonTransition(first.end, second.start);
+  first.end.isEnd = false;
+
+  return { start: first.start, end: second.end };
+};
+
+export const union = (first, second) => {
+  const start = createState(false);
+  addEpsilonTransition(start, first.start);
+  addEpsilonTransition(start, second.start);
+
+  const end = createState(true);
+
+  addEpsilonTransition(first.end, end);
+  first.end.isEnd = false;
+  addEpsilonTransition(second.end, end);
+  second.end.isEnd = false;
+
+  return { start, end };
+};
+
+export const closure = (nfa) => {
+  const start = createState(false);
+  const end = createState(true);
+
+  addEpsilonTransition(start, end);
+  addEpsilonTransition(start, nfa.start);
+
+  addEpsilonTransition(nfa.end, end);
+  addEpsilonTransition(nfa.end, nfa.start);
+  nfa.end.isEnd = false;
+
+  return { start, end };
+};
+
+export const zeroOrOne = (nfa) => {
+  const start = createState(false);
+  const end = createState(true);
+
+  addEpsilonTransition(start, end);
+  addEpsilonTransition(start, nfa.start);
+
+  addEpsilonTransition(nfa.end, end);
+  nfa.end.isEnd = false;
+
+  return { start, end };
+};
+
+export const oneOrMore = (nfa) => {
+  const start = createState(false);
+  const end = createState(true);
+
+  addEpsilonTransition(start, nfa.start);
+  addEpsilonTransition(nfa.end, end);
+  addEpsilonTransition(nfa.end, nfa.start);
+  nfa.end.isEnd = false;
+
+  return { start, end };
+};
+
+const addEpsilonTransition = (from, to) => {
+  from.epsilonTransitions.push(to);
+};
+
+const addTransition = (from, to, symbol) => {
+  from.transition[symbol] = to;
+};
+
+const createState = (isEnd) => {
+  return {
+    isEnd,
+    transition: {},
+    epsilonTransitions: []
+  };
+};

package/lib/schema.js

@@ -1,6 +1,7 @@
 import { nil as nilPointer, append as pointerAppend, get as pointerGet } from "@hyperjump/json-pointer";
 import { toAbsoluteIri } from "@hyperjump/uri";
 import { jsonTypeOf, resolveUri, uriFragment, pathRelative, jsonStringify } from "./common.js";
+import { contextUri } from "./context-uri.js";
 import fetch from "./fetch.js";
 import { hasDialect, loadDialect, getKeywordName } from "./keywords.js";
 import { parseResponse, acceptableMediaTypes } from "./media-types.js";
@@ -11,13 +12,14 @@ import * as Reference from "./reference.js";
 const schemaStore = {};
 const schemaStoreAlias = {};
 
-const defaultDialectId = "https://json-schema.org/validation";
-
 export const add = (schema, retrievalUri = undefined, contextDialectId = undefined) => {
   schema = JSON.parse(JSON.stringify(schema));
 
   // Dialect / JSON Schema Version
-  const dialectId = toAbsoluteIri(schema.$schema || contextDialectId || defaultDialectId);
+  if ((typeof schema !== "object" || !("$schema" in schema)) && !contextDialectId) {
+    throw Error("Unable to determine a dialect for the schema. The dialect can be declared in a number of ways, but the recommended way is to use the '$schema' keyword in your schema.");
+  }
+  const dialectId = toAbsoluteIri(schema.$schema || contextDialectId);
   delete schema.$schema;
 
   if (!hasDialect(dialectId)) {
@@ -159,7 +161,7 @@ const nil = {
 };
 
 export const get = async (url, contextDoc = nil) => {
-  const resolvedUrl = resolveUri(url, contextDoc.id);
+  const resolvedUrl = resolveUri(url, contextDoc.id || contextUri());
   const id = toAbsoluteIri(resolvedUrl);
   const fragment = uriFragment(resolvedUrl);
 
@@ -173,9 +175,11 @@ export const get = async (url, contextDoc = nil) => {
     const [schema, contextDialectId] = await parseResponse(response);
 
     // Try to determine the dialect from the meta-schema if it isn't already known
-    const dialectId = toAbsoluteIri(schema.$schema || contextDialectId || defaultDialectId);
-    if (!hasDialect(dialectId) && !hasStoredSchema(dialectId)) {
-      await get(dialectId);
+    if (schema.$schema || contextDialectId) {
+      const dialectId = toAbsoluteIri(schema.$schema || contextDialectId);
+      if (!hasDialect(dialectId) && !hasStoredSchema(dialectId)) {
+        await get(dialectId);
+      }
     }
 
     add(schema, id, contextDialectId);
@@ -204,7 +208,7 @@ const getAnchorPointer = (schema, fragment) => {
 
 // Utility Functions
 export const uri = (doc) => doc.id ? `${doc.id}#${encodeURI(doc.pointer)}` : undefined;
-export const value = (doc) => Reference.isReference(doc.value) ? Reference.value(doc.value) : doc.value;
+export const value = (doc) => doc.value;
 export const has = (key, doc) => key in value(doc);
 export const typeOf = (doc, type) => jsonTypeOf(value(doc), type);
 
@@ -272,7 +276,7 @@ export const toSchema = (schemaDoc, options = {}) => {
     dynamicAnchors[pointer] = anchor;
   }
 
-  const schema = JSON.parse(jsonStringify(schemaDoc.schema, (key, value, pointer) => {
+  const schema = JSON.parse(jsonStringify(schemaDoc.schema, (_key, value, pointer) => {
     if (Reference.isReference(value)) {
       const refValue = Reference.value(value);
       if (fullOptions.includeEmbedded || !(idToken in refValue)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "A JSON Schema validator with support for custom keywords, vocabularies, and dialects",
   "type": "module",
   "main": "./stable/index.js",
@@ -21,7 +21,8 @@
     "./bundle": "./bundle/index.js"
   },
   "browser": {
-    "./lib/fetch.js": "./lib/fetch.browser.js"
+    "./lib/fetch.js": "./lib/fetch.browser.js",
+    "./lib/context-uri.js": "./lib/context-uri.browser.js"
   },
   "scripts": {
     "clean": "xargs -a .gitignore rm -rf",
@@ -31,10 +32,13 @@
   "repository": "github:hyperjump-io/json-schema",
   "keywords": [
     "JSON Schema",
+    "json-schema",
+    "jsonschema",
     "JSON",
     "Schema",
     "2020-12",
     "2019-09",
+    "draft-07",
     "draft-06",
     "draft-04",
     "vocabulary",
@@ -49,6 +53,7 @@
   "devDependencies": {
     "@types/chai": "*",
     "@types/mocha": "*",
+    "@types/node": "^20.6.2",
     "@typescript-eslint/eslint-plugin": "*",
     "@typescript-eslint/parser": "*",
     "chai": "*",
@@ -64,7 +69,7 @@
   },
   "dependencies": {
     "@hyperjump/json-pointer": "^1.0.0",
-    "@hyperjump/pact": "^1.0.0",
+    "@hyperjump/pact": "^1.2.0",
     "@hyperjump/uri": "^1.2.0",
     "content-type": "^1.0.4",
     "fastest-stable-stringify": "^2.0.2",

package/stable/index.js

@@ -34,7 +34,9 @@ defineVocabulary("https://json-schema.org/vocab/applicator", {
   "if": "https://json-schema.org/keyword/if",
   "then": "https://json-schema.org/keyword/then",
   "else": "https://json-schema.org/keyword/else",
+  "conditional": "https://json-schema.org/keyword/conditional",
   "items": "https://json-schema.org/keyword/items",
+  "itemPattern": "https://json-schema.org/keyword/itemPattern",
   "not": "https://json-schema.org/keyword/not",
   "oneOf": "https://json-schema.org/keyword/oneOf",
   "patternProperties": "https://json-schema.org/keyword/patternProperties",
@@ -95,7 +97,8 @@ defineVocabulary("https://json-schema.org/vocab/unevaluated", {
   "unevaluatedProperties": "https://json-schema.org/keyword/unevaluatedProperties"
 });
 
-loadDialect("https://json-schema.org/validation", {
+const dialectId = "https://json-schema.org/validation";
+loadDialect(dialectId, {
   "https://json-schema.org/vocab/core": true,
   "https://json-schema.org/vocab/applicator": true,
   "https://json-schema.org/vocab/validation": true,
@@ -105,14 +108,14 @@ loadDialect("https://json-schema.org/validation", {
   "https://json-schema.org/vocab/unevaluated": true
 });
 
-addSchema(metaSchema);
-addSchema(coreMetaSchema);
-addSchema(applicatorMetaSchema);
-addSchema(validationMetaSchema);
-addSchema(metaDataMetaSchema);
-addSchema(formatAnnotationMetaSchema);
-addSchema(formatAssertionMetaSchema);
-addSchema(contentMetaSchema);
-addSchema(unevaluatedMetaSchema);
+addSchema(metaSchema, dialectId);
+addSchema(coreMetaSchema, "https://json-schema.org/meta/core");
+addSchema(applicatorMetaSchema, "https://json-schema.org/meta/applicator");
+addSchema(validationMetaSchema, "https://json-schema.org/meta/validation");
+addSchema(metaDataMetaSchema, "https://json-schema.org/meta/meta-data");
+addSchema(formatAnnotationMetaSchema, "https://json-schema.org/meta/format-annotation");
+addSchema(formatAssertionMetaSchema, "https://json-schema.org/meta/format-assertion");
+addSchema(contentMetaSchema, "https://json-schema.org/meta/content");
+addSchema(unevaluatedMetaSchema, "https://json-schema.org/meta/unevaluated");
 
 export * from "../lib/index.js";

package/stable/meta/applicator.js

@@ -1,5 +1,5 @@
 export default {
-  "$id": "https://json-schema.org/meta/applicator",
+  "$schema": "https://json-schema.org/validation",
   "title": "Applicator vocabulary meta-schema",
 
   "$dynamicAnchor": "meta",
@@ -8,6 +8,7 @@ export default {
     "prefixItems": { "$ref": "#/$defs/schemaArray" },
     "items": { "$dynamicRef": "meta" },
     "contains": { "$dynamicRef": "meta" },
+    "itemPattern": { "$ref": "#/$defs/itemPattern" },
     "additionalProperties": { "$dynamicRef": "meta" },
     "properties": {
       "type": "object",
@@ -33,6 +34,16 @@ export default {
     "if": { "$dynamicRef": "meta" },
     "then": { "$dynamicRef": "meta" },
     "else": { "$dynamicRef": "meta" },
+    "conditional": {
+      "type": "array",
+      "items": {
+        "if": { "type": "array" },
+        "then": {
+          "items": { "$dynamicRef": "meta" }
+        },
+        "else": { "$dynamicRef": "meta" }
+      }
+    },
     "allOf": { "$ref": "#/$defs/schemaArray" },
     "anyOf": { "$ref": "#/$defs/schemaArray" },
     "oneOf": { "$ref": "#/$defs/schemaArray" },
@@ -44,6 +55,21 @@ export default {
       "type": "array",
       "minItems": 1,
       "items": { "$dynamicRef": "meta" }
+    },
+    "itemPattern": {
+      "type": "array",
+      "itemPattern": [
+        [
+          {
+            "if": { "type": "array" },
+            "then": { "$ref": "#/$defs/itemPattern" },
+            "else": { "$dynamicRef": "meta" }
+          },
+          { "enum": ["?", "*", "+"] }, "?",
+          "|",
+          { "const": "|" }
+        ], "*"
+      ]
     }
   }
 };

package/stable/meta/content.js

@@ -1,5 +1,5 @@
 export default {
-  "$id": "https://json-schema.org/meta/content",
+  "$schema": "https://json-schema.org/validation",
   "title": "Content vocabulary meta-schema",
 
   "$dynamicAnchor": "meta",

package/stable/meta/core.js

@@ -1,5 +1,5 @@
 export default {
-  "$id": "https://json-schema.org/meta/core",
+  "$schema": "https://json-schema.org/validation",
   "title": "Core vocabulary meta-schema",
 
   "$dynamicAnchor": "meta",

package/stable/meta/format-annotation.js

@@ -1,5 +1,5 @@
 export default {
-  "$id": "https://json-schema.org/meta/format-annotation",
+  "$schema": "https://json-schema.org/validation",
   "title": "Format vocabulary meta-schema for annotation results",
 
   "$dynamicAnchor": "meta",

package/stable/meta/format-assertion.js

@@ -1,5 +1,5 @@
 export default {
-  "$id": "https://json-schema.org/meta/format-assertion",
+  "$schema": "https://json-schema.org/validation",
   "title": "Format vocabulary meta-schema for assertion results",
 
   "$dynamicAnchor": "meta",

package/stable/meta/meta-data.js

@@ -1,5 +1,5 @@
 export default {
-  "$id": "https://json-schema.org/meta/meta-data",
+  "$schema": "https://json-schema.org/validation",
   "title": "Meta-data vocabulary meta-schema",
 
   "$dynamicAnchor": "meta",

package/stable/meta/unevaluated.js

@@ -1,5 +1,5 @@
 export default {
-  "$id": "https://json-schema.org/meta/unevaluated",
+  "$schema": "https://json-schema.org/validation",
   "title": "Unevaluated applicator vocabulary meta-schema",
 
   "$dynamicAnchor": "meta",

package/stable/meta/validation.js

@@ -1,5 +1,5 @@
 export default {
-  "$id": "https://json-schema.org/meta/validation",
+  "$schema": "https://json-schema.org/validation",
   "title": "Validation vocabulary meta-schema",
 
   "$dynamicAnchor": "meta",

package/stable/validation.js

@@ -1,5 +1,5 @@
 export default {
-  "$id": "https://json-schema.org/validation",
+  "$schema": "https://json-schema.org/validation",
   "$vocabulary": {
     "https://json-schema.org/vocab/core": true,
     "https://json-schema.org/vocab/applicator": true,