@procedures/json 0.0.0-stage → 0.3.0

package/package.json

@@ -1,6 +1,84 @@
 {
+  "$schema": "https://json.schemastore.org/package",
   "name": "@procedures/json",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.3.0",
+  "description": "Pure JSON and YAML procedures: a query with JSON Pointer or a path, JSON Patch, a diff, a merge patch, a JSON Schema check, and YAML to JSON and back.",
+  "keywords": [
+    "procedures",
+    "json",
+    "yaml",
+    "json-pointer",
+    "json-patch",
+    "merge-patch",
+    "json-schema",
+    "diff"
+  ],
+  "homepage": "https://mark1russell7.github.io/client/",
+  "bugs": {
+    "url": "https://github.com/mark1russell7/client/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mark1russell7/client.git",
+    "directory": "packages/json"
+  },
+  "license": "MIT",
+  "author": "Mark Russell (https://github.com/mark1russell7)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./module": {
+      "types": "./dist/module.d.ts",
+      "import": "./dist/module.js"
+    },
+    "./register": {
+      "types": "./dist/register.d.ts",
+      "import": "./dist/register.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/__tests__",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": [
+    "./dist/register.js"
+  ],
+  "devDependencies": {
+    "@mark1russell7/cue": "^1.0.0",
+    "fast-check": "^4.10.2",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.3"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "client": {
+    "procedures": "./dist/register.js"
+  },
+  "dependencies": {
+    "@procedures/client": "0.3.0",
+    "@procedures/compiler": "0.3.0",
+    "yaml": "^2.9.1",
+    "zod": "^4.6.5"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist .tsbuildinfo",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
 }

package/src/diff.ts

@@ -0,0 +1,58 @@
+/**
+ * The diff of two JSON values: a JSON Patch (RFC 6902) that changes the first value into the
+ * second value. `applyPatch(a, diffJson(a, b))` gives a value equal to `b`.
+ *
+ * - Two objects: a `remove` for each key that only the first has, a diff of each shared key, and
+ *   an `add` for each key that only the second has.
+ * - Two arrays: the items of the shared start and end stay. The items between them get a diff
+ *   for each shared position, then a `remove` or an `add` for each other item.
+ * - Other values: one `replace`.
+ *
+ * The patch never names `__proto__`, `constructor` or `prototype`, because `applyPatch` refuses
+ * them. When a difference is under such a key, the patch replaces the object that holds the key.
+ */
+
+import type { PatchOperation } from "./patch.js";
+import { cloneJson, formatPointer, hasOwn, jsonEqual, PROTOTYPE_KEYS, type JsonValue } from "./value.js";
+
+function diffAt(a: JsonValue, b: JsonValue, tokens: (string | number)[], out: PatchOperation[]): void {
+  if (jsonEqual(a, b)) return;
+  const path = formatPointer(tokens);
+  if (Array.isArray(a) && Array.isArray(b)) {
+    diffArrays(a, b, tokens, out);
+    return;
+  }
+  if (a !== null && b !== null && typeof a === "object" && typeof b === "object" && !Array.isArray(a) && !Array.isArray(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    const named = [...keysA, ...keysB].some((key) => PROTOTYPE_KEYS.has(key) && !(hasOwn(a, key) && hasOwn(b, key) && jsonEqual(a[key]!, b[key]!)));
+    if (!named) {
+      for (const key of keysA) if (!hasOwn(b, key)) out.push({ op: "remove", path: formatPointer([...tokens, key]) });
+      for (const key of keysA) if (hasOwn(b, key)) diffAt(a[key]!, b[key]!, [...tokens, key], out);
+      for (const key of keysB) if (!hasOwn(a, key)) out.push({ op: "add", path: formatPointer([...tokens, key]), value: cloneJson(b[key]!) });
+      return;
+    }
+  }
+  out.push({ op: "replace", path, value: cloneJson(b) });
+}
+
+function diffArrays(a: JsonValue[], b: JsonValue[], tokens: (string | number)[], out: PatchOperation[]): void {
+  let start = 0;
+  while (start < a.length && start < b.length && jsonEqual(a[start]!, b[start]!)) start++;
+  let end = 0;
+  while (end < a.length - start && end < b.length - start && jsonEqual(a[a.length - 1 - end]!, b[b.length - 1 - end]!)) end++;
+  const middleA = a.length - start - end;
+  const middleB = b.length - start - end;
+  const shared = Math.min(middleA, middleB);
+  for (let i = 0; i < shared; i++) diffAt(a[start + i]!, b[start + i]!, [...tokens, start + i], out);
+  // The items after the shared positions: remove from the last one, so each index stays valid
+  for (let i = middleA - 1; i >= shared; i--) out.push({ op: "remove", path: formatPointer([...tokens, start + i]) });
+  for (let i = shared; i < middleB; i++) out.push({ op: "add", path: formatPointer([...tokens, start + i]), value: cloneJson(b[start + i]!) });
+}
+
+/** This function gives a JSON Patch that changes `a` into `b`. Equal values give an empty patch. */
+export function diffJson(a: JsonValue, b: JsonValue): PatchOperation[] {
+  const out: PatchOperation[] = [];
+  diffAt(a, b, [], out);
+  return out;
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+// The root registers nothing: import "<package>/register", or give the module to createRegistry()
+export * from "./module.js";
+export * from "./types.js";
+export { jsonQuery, jsonPatch, jsonDiff, jsonMerge, jsonValidate } from "./procedures/json/index.js";
+export { yamlParse, yamlStringify } from "./procedures/yaml/index.js";
+// The functions behind the procedures, for a program in the same process
+export { assertJson, cloneJson, jsonEqual, JsonError, PROTOTYPE_KEYS, formatPointer, escapeToken, type JsonErrorCode } from "./value.js";
+export { parsePointer, lookup, arrayIndex, type Lookup } from "./pointer.js";
+export { parsePath, queryPath, type PathMatch, type PathStep } from "./path.js";
+export { applyPatch } from "./patch.js";
+export { diffJson } from "./diff.js";
+export { mergePatch } from "./merge.js";
+export { validateJson, NOT_EXAMINED, type ValidationIssue, type ValidationResult } from "./schema.js";
+export { parseYaml, stringifyYaml, type YamlParseOptions, type YamlStringifyOptions } from "./yaml.js";

package/src/merge.ts

@@ -0,0 +1,34 @@
+/**
+ * JSON Merge Patch (RFC 7386): a patch is a JSON value of the same form as the target.
+ *
+ * - A patch that is an object changes the target member by member. A member with the value null
+ *   removes the key. Another member merges into the key.
+ * - A patch that is not an object replaces the target.
+ *
+ * The merge applies to a copy of the target. A key `__proto__`, `constructor` or `prototype` in
+ * an object of the patch is refused (roadmap R6).
+ */
+
+import { cloneJson, formatPointer, hasOwn, isPlainObject, JsonError, PROTOTYPE_KEYS, put, type JsonValue } from "./value.js";
+
+function mergeAt(target: JsonValue | undefined, patch: JsonValue, tokens: string[]): JsonValue {
+  if (!isPlainObject(patch)) return cloneJson(patch);
+  const result: Record<string, JsonValue> = isPlainObject(target) ? cloneJson(target as Record<string, JsonValue>) : {};
+  for (const key of Object.keys(patch)) {
+    if (PROTOTYPE_KEYS.has(key)) {
+      throw new JsonError("PROTOTYPE_KEY", `The merge patch has the key "${key}" at "${formatPointer([...tokens, key])}", which reaches a prototype`);
+    }
+    const value = patch[key] as JsonValue;
+    if (value === null) {
+      delete result[key];
+    } else {
+      put(result, key, mergeAt(hasOwn(result, key) ? result[key] : undefined, value, [...tokens, key]));
+    }
+  }
+  return result;
+}
+
+/** This function applies a JSON merge patch to a copy of the target and gives the result. */
+export function mergePatch(target: JsonValue, patch: JsonValue): JsonValue {
+  return mergeAt(target, patch, []);
+}

package/src/module.ts

@@ -0,0 +1,236 @@
+/**
+ * The procedures of @procedures/json as data. Importing this file registers nothing.
+ *
+ * Scaffold a procedure with: mark procedure new <name> --path packages/json
+ *
+ * Each procedure is pure (`PURE_EFFECTS`): its output comes from its input, and it reads and
+ * changes nothing else (roadmap R39).
+ */
+
+import { z } from "zod";
+import { defineModule, registerModules, PROCEDURE_REGISTRY, PURE_EFFECTS, type ProcedureModule, type ProcedureRegistry, createProcedure, zodAdapter } from "@procedures/client";
+import { jsonQuery } from "./procedures/json/query.js";
+import { jsonPatch } from "./procedures/json/patch.js";
+import { jsonDiff } from "./procedures/json/diff.js";
+import { jsonMerge } from "./procedures/json/merge.js";
+import { jsonValidate } from "./procedures/json/validate.js";
+import { yamlParse } from "./procedures/yaml/parse.js";
+import { yamlStringify } from "./procedures/yaml/stringify.js";
+import type {
+  JsonDiffInput,
+  JsonDiffOutput,
+  JsonMergeInput,
+  JsonMergeOutput,
+  JsonPatchInput,
+  JsonPatchOutput,
+  JsonQueryInput,
+  JsonQueryOutput,
+  JsonValidateInput,
+  JsonValidateOutput,
+  YamlParseInput,
+  YamlParseOutput,
+  YamlStringifyInput,
+  YamlStringifyOutput,
+} from "./types.js";
+
+// =============================================================================
+// Schemas
+// =============================================================================
+
+/** A JSON value. The handler examines it, so a key `__proto__` of the data reaches the check. */
+const json = (description: string) => z.unknown().describe(description);
+
+const operation = z.object({
+  op: z.enum(["add", "remove", "replace", "move", "copy", "test"]).describe("The operation"),
+  path: z.string().describe("The JSON Pointer of the location"),
+  from: z.string().optional().describe("The JSON Pointer of the source of move and copy"),
+  value: json("The value of add, replace and test").optional(),
+});
+
+const JsonQueryInputSchema = z.object({
+  value: json("The JSON value to search"),
+  pointer: z.string().optional().describe("A JSON Pointer (RFC 6901), for example /items/0/name. Give pointer or path"),
+  path: z.string().optional().describe("A path query, for example items[*].name or $..id. Give pointer or path"),
+});
+
+const JsonQueryOutputSchema = z.object({
+  found: z.boolean().describe("True when one or more values match"),
+  value: json("The value of the first match").optional(),
+  matches: z.array(z.object({ pointer: z.string().describe("The JSON Pointer of the match"), value: json("The value of the match") })).describe("Each match, in document order"),
+});
+
+const JsonPatchInputSchema = z.object({
+  value: json("The JSON value to change"),
+  patch: z.array(operation).describe("The operations of the JSON Patch (RFC 6902), in order"),
+});
+
+const JsonPatchOutputSchema = z.object({ value: json("The value after the patch") });
+
+const JsonDiffInputSchema = z.object({
+  from: json("The first JSON value"),
+  to: json("The second JSON value"),
+});
+
+const JsonDiffOutputSchema = z.object({
+  patch: z.array(operation).describe("The JSON Patch (RFC 6902) that changes from into to"),
+});
+
+const JsonMergeInputSchema = z.object({
+  target: json("The JSON value to change"),
+  patch: json("The merge patch (RFC 7386): an object of changes, where null removes a key"),
+});
+
+const JsonMergeOutputSchema = z.object({ value: json("The value after the merge") });
+
+const JsonValidateInputSchema = z.object({
+  value: json("The JSON value to examine"),
+  schema: json("The JSON Schema: an object or a boolean"),
+});
+
+const JsonValidateOutputSchema = z.object({
+  valid: z.boolean().describe("True when the check found no problem"),
+  errors: z.array(z.object({ pointer: z.string().describe("The JSON Pointer of the part"), message: z.string().describe("The problem") })).describe("Each problem"),
+  unchecked: z.array(z.string()).describe("The keywords of the schema that the check does not examine. Empty: the verdict is complete"),
+});
+
+const YamlParseInputSchema = z.object({
+  text: z.string().describe("The YAML text"),
+  all: z.boolean().optional().describe("True: the text can have more than one document, and value is the list of documents"),
+});
+
+const YamlParseOutputSchema = z.object({ value: json("The JSON value of the text") });
+
+const YamlStringifyInputSchema = z.object({
+  value: json("The JSON value to write"),
+  indent: z.number().int().min(1).max(8).optional().describe("The spaces of one level of indentation (default: 2)"),
+  lineWidth: z.number().int().min(0).optional().describe("The longest line before a fold. 0: no fold (default: 80)"),
+  sortKeys: z.boolean().optional().describe("True: the keys of each map in alphabetical order"),
+});
+
+const YamlStringifyOutputSchema = z.object({ text: z.string().describe("The YAML text") });
+
+// =============================================================================
+// Procedures
+// =============================================================================
+
+const jsonQueryProcedure = createProcedure()
+  .path(["json", "query"])
+  .input(zodAdapter<JsonQueryInput>(JsonQueryInputSchema))
+  .output(zodAdapter<JsonQueryOutput>(JsonQueryOutputSchema))
+  .meta({
+    description: "Find the values at a JSON Pointer or a path in a JSON value",
+    args: [],
+    shorts: { pointer: "p" },
+    output: "json",
+    effects: PURE_EFFECTS,
+  })
+  .handler(async (input: JsonQueryInput): Promise<JsonQueryOutput> => jsonQuery(input))
+  .build();
+
+const jsonPatchProcedure = createProcedure()
+  .path(["json", "patch"])
+  .input(zodAdapter<JsonPatchInput>(JsonPatchInputSchema))
+  .output(zodAdapter<JsonPatchOutput>(JsonPatchOutputSchema))
+  .meta({
+    description: "Apply an RFC 6902 JSON Patch to a JSON value",
+    args: [],
+    shorts: {},
+    output: "json",
+    effects: PURE_EFFECTS,
+  })
+  .handler(async (input: JsonPatchInput): Promise<JsonPatchOutput> => jsonPatch(input))
+  .build();
+
+const jsonDiffProcedure = createProcedure()
+  .path(["json", "diff"])
+  .input(zodAdapter<JsonDiffInput>(JsonDiffInputSchema))
+  .output(zodAdapter<JsonDiffOutput>(JsonDiffOutputSchema))
+  .meta({
+    description: "Give the RFC 6902 JSON Patch that changes one JSON value into another",
+    args: [],
+    shorts: {},
+    output: "json",
+    effects: PURE_EFFECTS,
+  })
+  .handler(async (input: JsonDiffInput): Promise<JsonDiffOutput> => jsonDiff(input))
+  .build();
+
+const jsonMergeProcedure = createProcedure()
+  .path(["json", "merge"])
+  .input(zodAdapter<JsonMergeInput>(JsonMergeInputSchema))
+  .output(zodAdapter<JsonMergeOutput>(JsonMergeOutputSchema))
+  .meta({
+    description: "Apply an RFC 7386 JSON merge patch to a JSON value",
+    args: [],
+    shorts: {},
+    output: "json",
+    effects: PURE_EFFECTS,
+  })
+  .handler(async (input: JsonMergeInput): Promise<JsonMergeOutput> => jsonMerge(input))
+  .build();
+
+const jsonValidateProcedure = createProcedure()
+  .path(["json", "validate"])
+  .input(zodAdapter<JsonValidateInput>(JsonValidateInputSchema))
+  .output(zodAdapter<JsonValidateOutput>(JsonValidateOutputSchema))
+  .meta({
+    description: "Examine a JSON value against a JSON Schema",
+    args: [],
+    shorts: {},
+    output: "json",
+    effects: PURE_EFFECTS,
+  })
+  .handler(async (input: JsonValidateInput): Promise<JsonValidateOutput> => jsonValidate(input))
+  .build();
+
+const yamlParseProcedure = createProcedure()
+  .path(["yaml", "parse"])
+  .input(zodAdapter<YamlParseInput>(YamlParseInputSchema))
+  .output(zodAdapter<YamlParseOutput>(YamlParseOutputSchema))
+  .meta({
+    description: "Parse YAML text into a JSON value",
+    args: ["text"],
+    shorts: { all: "a" },
+    output: "json",
+    effects: PURE_EFFECTS,
+  })
+  .handler(async (input: YamlParseInput): Promise<YamlParseOutput> => yamlParse(input))
+  .build();
+
+const yamlStringifyProcedure = createProcedure()
+  .path(["yaml", "stringify"])
+  .input(zodAdapter<YamlStringifyInput>(YamlStringifyInputSchema))
+  .output(zodAdapter<YamlStringifyOutput>(YamlStringifyOutputSchema))
+  .meta({
+    description: "Write a JSON value as YAML text",
+    args: [],
+    shorts: { indent: "i", sortKeys: "s" },
+    output: "json",
+    effects: PURE_EFFECTS,
+  })
+  .handler(async (input: YamlStringifyInput): Promise<YamlStringifyOutput> => yamlStringify(input))
+  .build();
+
+/**
+ * The module of this package, for `createRegistry()`: its procedures as data. Importing this
+ * file registers nothing.
+ */
+export const jsonModule: ProcedureModule = defineModule("@procedures/json", [
+  jsonQueryProcedure,
+  jsonPatchProcedure,
+  jsonDiffProcedure,
+  jsonMergeProcedure,
+  jsonValidateProcedure,
+  yamlParseProcedure,
+  yamlStringifyProcedure,
+]);
+
+export default jsonModule;
+
+/**
+ * This function registers the procedures of @procedures/json in a registry. The default is the
+ * global registry.
+ */
+export function registerJsonProcedures(registry: ProcedureRegistry = PROCEDURE_REGISTRY): void {
+  registerModules(registry, [jsonModule]);
+}

package/src/patch.ts

@@ -0,0 +1,132 @@
+/**
+ * JSON Patch (RFC 6902): apply a list of operations to a JSON value.
+ *
+ * The operations are `add`, `remove`, `replace`, `move`, `copy` and `test`. The patch applies to
+ * a copy of the value, and all operations apply or none: the first failure throws, and the input
+ * value does not change. A `path` or a `from` that names `__proto__`, `constructor` or
+ * `prototype` is refused (roadmap R6).
+ */
+
+import { arrayIndex, lookup, parsePointer } from "./pointer.js";
+import { cloneJson, formatPointer, isPlainObject, jsonEqual, JsonError, put, typeName, type JsonValue } from "./value.js";
+
+/** One operation of a JSON Patch. */
+export interface PatchOperation {
+  op: "add" | "remove" | "replace" | "move" | "copy" | "test";
+  path: string;
+  from?: string | undefined;
+  value?: unknown;
+}
+
+/** The parent of a location: the container and the last token. */
+function parentOf(document: JsonValue, tokens: readonly string[], fail: (message: string) => never): { container: JsonValue[] | Record<string, JsonValue>; token: string } {
+  const parentTokens = tokens.slice(0, -1);
+  const found = lookup(document, parentTokens);
+  if (!found.found) fail(`the location ${formatPointer(parentTokens)} does not exist`);
+  const container = (found as { value: JsonValue }).value;
+  if (container === null || typeof container !== "object") fail(`the location ${formatPointer(parentTokens)} is ${typeName(container)}, not an object or an array`);
+  return { container: container as JsonValue[] | Record<string, JsonValue>, token: tokens[tokens.length - 1]! };
+}
+
+function add(document: JsonValue, tokens: readonly string[], value: JsonValue, fail: (message: string) => never): JsonValue {
+  if (tokens.length === 0) return value;
+  const { container, token } = parentOf(document, tokens, fail);
+  if (Array.isArray(container)) {
+    if (token === "-") {
+      container.push(value);
+      return document;
+    }
+    const index = arrayIndex(token);
+    if (index === undefined || index > container.length) fail(`the array index "${token}" is not 0 to ${container.length} or "-"`);
+    container.splice(index!, 0, value);
+    return document;
+  }
+  put(container, token, value);
+  return document;
+}
+
+function remove(document: JsonValue, tokens: readonly string[], fail: (message: string) => never): { document: JsonValue; removed: JsonValue } {
+  if (tokens.length === 0) fail("a patch cannot remove the whole value");
+  const { container, token } = parentOf(document, tokens, fail);
+  if (Array.isArray(container)) {
+    const index = arrayIndex(token);
+    if (index === undefined || index >= container.length) fail(`the array index "${token}" does not exist`);
+    const [removed] = container.splice(index!, 1);
+    return { document, removed: removed! };
+  }
+  if (!Object.prototype.hasOwnProperty.call(container, token)) fail(`the location ${formatPointer(tokens)} does not exist`);
+  const removed = container[token]!;
+  delete container[token];
+  return { document, removed };
+}
+
+function replace(document: JsonValue, tokens: readonly string[], value: JsonValue, fail: (message: string) => never): JsonValue {
+  if (tokens.length === 0) return value;
+  if (!lookup(document, tokens).found) fail(`the location ${formatPointer(tokens)} does not exist`);
+  const { container, token } = parentOf(document, tokens, fail);
+  if (Array.isArray(container)) container[arrayIndex(token)!] = value;
+  else put(container, token, value);
+  return document;
+}
+
+/** The value of an operation: present, and JSON. */
+function valueOf(operation: PatchOperation, fail: (message: string) => never): JsonValue {
+  if (!("value" in operation) || operation.value === undefined) fail(`the operation ${operation.op} needs a value`);
+  return cloneJson(operation.value as JsonValue);
+}
+
+/**
+ * This function applies a JSON Patch to a copy of a value and gives the result. A bad operation,
+ * a location that does not exist and a failed `test` throw a `JsonError` that names the index of
+ * the operation.
+ */
+export function applyPatch(value: JsonValue, operations: readonly PatchOperation[]): JsonValue {
+  let document = cloneJson(value);
+  operations.forEach((operation, index) => {
+    const fail = (message: string, code: "INVALID_PATCH" | "TEST_FAILED" = "INVALID_PATCH"): never => {
+      throw new JsonError(code, `Operation ${index} (${operation.op} ${operation.path}): ${message}`);
+    };
+    if (!isPlainObject(operation) || typeof operation.path !== "string") fail("an operation is an object with op and path");
+    const tokens = parsePointer(operation.path, `path of operation ${index}`);
+    const fromTokens = (): string[] => {
+      if (typeof operation.from !== "string") fail(`the operation ${operation.op} needs from`);
+      return parsePointer(operation.from!, `from of operation ${index}`);
+    };
+    switch (operation.op) {
+      case "add":
+        document = add(document, tokens, valueOf(operation, fail), fail);
+        break;
+      case "remove":
+        document = remove(document, tokens, fail).document;
+        break;
+      case "replace":
+        document = replace(document, tokens, valueOf(operation, fail), fail);
+        break;
+      case "move": {
+        const from = fromTokens();
+        if (from.length === tokens.length && from.every((token, at) => token === tokens[at])) break;
+        if (from.length < tokens.length && from.every((token, at) => token === tokens[at])) fail("a value cannot move into itself");
+        const removed = remove(document, from, fail);
+        document = add(removed.document, tokens, removed.removed, fail);
+        break;
+      }
+      case "copy": {
+        const from = fromTokens();
+        const found = lookup(document, from);
+        if (!found.found) fail(`the location ${formatPointer(from)} does not exist`);
+        document = add(document, tokens, cloneJson((found as { value: JsonValue }).value), fail);
+        break;
+      }
+      case "test": {
+        const expected = valueOf(operation, fail);
+        const found = lookup(document, tokens);
+        if (!found.found) fail(`the location ${operation.path} does not exist`, "TEST_FAILED");
+        if (!jsonEqual((found as { value: JsonValue }).value, expected)) fail(`the value is not ${JSON.stringify(expected)}`, "TEST_FAILED");
+        break;
+      }
+      default:
+        fail(`the operation ${JSON.stringify((operation as { op: unknown }).op)} is not add, remove, replace, move, copy or test`);
+    }
+  });
+  return document;
+}