@visual-json/core 0.1.0

package/dist/index.mjs

@@ -0,0 +1,775 @@
+// src/tree.ts
+var nextId = 0;
+function generateId() {
+  return `node_${++nextId}`;
+}
+function resetIdCounter() {
+  nextId = 0;
+}
+function getNodeType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function buildSubtree(key, value, parentPath, parentId, nodesById) {
+  const id = generateId();
+  const path = parentPath ? `${parentPath}/${key}` : `/${key}`;
+  const type = getNodeType(value);
+  const node = {
+    id,
+    key,
+    path,
+    type,
+    value: type === "object" || type === "array" ? void 0 : value,
+    children: [],
+    parentId
+  };
+  nodesById.set(id, node);
+  if (type === "object" && value !== null) {
+    const obj = value;
+    node.children = Object.keys(obj).map(
+      (childKey) => buildSubtree(childKey, obj[childKey], path, id, nodesById)
+    );
+  } else if (type === "array") {
+    const arr = value;
+    node.children = arr.map(
+      (item, index) => buildSubtree(String(index), item, path, id, nodesById)
+    );
+  }
+  return node;
+}
+function fromJson(value) {
+  const nodesById = /* @__PURE__ */ new Map();
+  const rootType = getNodeType(value);
+  const root = {
+    id: generateId(),
+    key: "",
+    path: "/",
+    type: rootType,
+    value: rootType === "object" || rootType === "array" ? void 0 : value,
+    children: [],
+    parentId: null
+  };
+  nodesById.set(root.id, root);
+  if (rootType === "object" && value !== null) {
+    const obj = value;
+    root.children = Object.keys(obj).map(
+      (key) => buildSubtree(key, obj[key], "", root.id, nodesById)
+    );
+  } else if (rootType === "array") {
+    const arr = value;
+    root.children = arr.map(
+      (item, index) => buildSubtree(String(index), item, "", root.id, nodesById)
+    );
+  }
+  return { root, nodesById };
+}
+function toJson(node) {
+  switch (node.type) {
+    case "object": {
+      const obj = {};
+      for (const child of node.children) {
+        obj[child.key] = toJson(child);
+      }
+      return obj;
+    }
+    case "array":
+      return node.children.map((child) => toJson(child));
+    default:
+      return node.value;
+  }
+}
+function findNode(state, nodeId) {
+  return state.nodesById.get(nodeId);
+}
+function findNodeByPath(state, path) {
+  if (path === "/") return state.root;
+  const segments = path.split("/").filter(Boolean);
+  let current = state.root;
+  for (const segment of segments) {
+    const child = current.children.find((c) => c.key === segment);
+    if (!child) return void 0;
+    current = child;
+  }
+  return current;
+}
+
+// src/operations.ts
+function rebuildMap(root) {
+  const map = /* @__PURE__ */ new Map();
+  function walk(node) {
+    map.set(node.id, node);
+    for (const child of node.children) walk(child);
+  }
+  walk(root);
+  return map;
+}
+function recomputePaths(node, newParentPath) {
+  const newPath = newParentPath ? `${newParentPath}/${node.key}` : `/${node.key}`;
+  if (node.path === newPath && node.children.length === 0) return node;
+  return {
+    ...node,
+    path: newPath,
+    children: node.children.map((child) => recomputePaths(child, newPath))
+  };
+}
+function clonePathToNode(state, targetId, updater) {
+  const chain = [];
+  let cur = state.nodesById.get(targetId);
+  while (cur) {
+    chain.unshift(cur.id);
+    cur = cur.parentId ? state.nodesById.get(cur.parentId) : void 0;
+  }
+  if (chain.length === 0) return state;
+  function cloneAlongPath(node, depth) {
+    if (depth === chain.length - 1) {
+      return updater(node);
+    }
+    const nextInChain = chain[depth + 1];
+    return {
+      ...node,
+      children: node.children.map(
+        (child) => child.id === nextInChain ? cloneAlongPath(child, depth + 1) : child
+      )
+    };
+  }
+  const newRoot = cloneAlongPath(state.root, 0);
+  return { root: newRoot, nodesById: rebuildMap(newRoot) };
+}
+function reindexArrayChildren(parent) {
+  if (parent.type !== "array") return parent;
+  const parentPath = parent.path === "/" ? "" : parent.path;
+  return {
+    ...parent,
+    children: parent.children.map((child, i) => {
+      const newKey = String(i);
+      if (child.key === newKey) return child;
+      return recomputePaths({ ...child, key: newKey }, parentPath);
+    })
+  };
+}
+function setValue(state, nodeId, value) {
+  const node = state.nodesById.get(nodeId);
+  if (!node) return state;
+  const newType = getNodeType(value);
+  if (newType !== "object" && newType !== "array") {
+    return clonePathToNode(state, nodeId, (n) => ({
+      ...n,
+      type: newType,
+      value,
+      children: []
+    }));
+  }
+  return clonePathToNode(state, nodeId, (n) => {
+    const parentPath = n.path.split("/").slice(0, -1).join("/") || "";
+    const nodesById = /* @__PURE__ */ new Map();
+    const subtree = buildSubtree(n.key, value, parentPath, n.parentId, nodesById);
+    return { ...subtree, id: n.id };
+  });
+}
+function setKey(state, nodeId, newKey) {
+  const node = state.nodesById.get(nodeId);
+  if (!node || !node.parentId) return state;
+  const parent = state.nodesById.get(node.parentId);
+  if (!parent || parent.type !== "object") return state;
+  return clonePathToNode(state, nodeId, (n) => {
+    const parentPath = parent.path === "/" ? "" : parent.path;
+    const newPath = `${parentPath}/${newKey}`;
+    const updated = { ...n, key: newKey, path: newPath };
+    if (updated.children.length > 0) {
+      updated.children = updated.children.map(
+        (child) => recomputePaths(child, newPath)
+      );
+    }
+    return updated;
+  });
+}
+function addProperty(state, parentId, key, value) {
+  const parent = state.nodesById.get(parentId);
+  if (!parent) return state;
+  return clonePathToNode(state, parentId, (p) => {
+    const parentPath = p.path === "/" ? "" : p.path;
+    const nodesById = /* @__PURE__ */ new Map();
+    const newChild = buildSubtree(key, value, parentPath, p.id, nodesById);
+    return { ...p, children: [...p.children, newChild] };
+  });
+}
+function removeNode(state, nodeId) {
+  const node = state.nodesById.get(nodeId);
+  if (!node || !node.parentId) return state;
+  return clonePathToNode(state, node.parentId, (p) => {
+    const newChildren = p.children.filter((c) => c.id !== nodeId);
+    return reindexArrayChildren({ ...p, children: newChildren });
+  });
+}
+function moveNode(state, nodeId, newParentId, index) {
+  const node = state.nodesById.get(nodeId);
+  if (!node || !node.parentId) return state;
+  const srcParent = state.nodesById.get(node.parentId);
+  const dstParent = state.nodesById.get(newParentId);
+  if (!srcParent || !dstParent) return state;
+  const nodeValue = toJson(node);
+  const removed = clonePathToNode(state, node.parentId, (p) => {
+    const newChildren = p.children.filter((c) => c.id !== nodeId);
+    return reindexArrayChildren({ ...p, children: newChildren });
+  });
+  return clonePathToNode(removed, newParentId, (p) => {
+    const parentPath = p.path === "/" ? "" : p.path;
+    const nodesById = /* @__PURE__ */ new Map();
+    const newChild = buildSubtree(
+      p.type === "array" ? String(index ?? p.children.length) : node.key,
+      nodeValue,
+      parentPath,
+      p.id,
+      nodesById
+    );
+    const newChildren = [...p.children];
+    const insertAt = index ?? newChildren.length;
+    newChildren.splice(insertAt, 0, newChild);
+    return reindexArrayChildren({ ...p, children: newChildren });
+  });
+}
+function reorderChildren(state, parentId, fromIndex, toIndex) {
+  const parent = state.nodesById.get(parentId);
+  if (!parent) return state;
+  return clonePathToNode(state, parentId, (p) => {
+    const newChildren = [...p.children];
+    const [item] = newChildren.splice(fromIndex, 1);
+    newChildren.splice(toIndex, 0, item);
+    return reindexArrayChildren({ ...p, children: newChildren });
+  });
+}
+function convertValue(current, newType) {
+  switch (newType) {
+    case "string":
+      if (current === null || current === void 0) return "";
+      if (typeof current === "object") return JSON.stringify(current);
+      return String(current);
+    case "number": {
+      const n = Number(current);
+      return isNaN(n) ? 0 : n;
+    }
+    case "boolean":
+      return Boolean(current);
+    case "null":
+      return null;
+    case "object":
+      if (current !== null && typeof current === "object" && !Array.isArray(current))
+        return current;
+      if (Array.isArray(current)) {
+        const obj = {};
+        current.forEach((item, i) => {
+          obj[String(i)] = item;
+        });
+        return obj;
+      }
+      return {};
+    case "array":
+      if (Array.isArray(current)) return current;
+      if (current !== null && typeof current === "object")
+        return Object.values(current);
+      return current === null || current === void 0 ? [] : [current];
+    default:
+      return current;
+  }
+}
+function changeType(state, nodeId, newType) {
+  const node = state.nodesById.get(nodeId);
+  if (!node) return state;
+  const currentValue = toJson(node);
+  const newValue = convertValue(currentValue, newType);
+  return setValue(state, nodeId, newValue);
+}
+function duplicateNode(state, nodeId) {
+  const node = state.nodesById.get(nodeId);
+  if (!node || !node.parentId) return state;
+  const parent = state.nodesById.get(node.parentId);
+  if (!parent) return state;
+  const nodeValue = toJson(node);
+  return clonePathToNode(state, node.parentId, (p) => {
+    const idx = p.children.findIndex((c) => c.id === nodeId);
+    const parentPath = p.path === "/" ? "" : p.path;
+    const newKey = p.type === "array" ? String(idx + 1) : `${node.key}_copy`;
+    const nodesById = /* @__PURE__ */ new Map();
+    const newChild = buildSubtree(
+      newKey,
+      structuredClone(nodeValue),
+      parentPath,
+      p.id,
+      nodesById
+    );
+    const newChildren = [...p.children];
+    newChildren.splice(idx + 1, 0, newChild);
+    return reindexArrayChildren({ ...p, children: newChildren });
+  });
+}
+
+// src/history.ts
+var MAX_HISTORY = 100;
+var History = class {
+  constructor() {
+    this.stack = [];
+    this.cursor = -1;
+  }
+  push(state) {
+    this.stack = this.stack.slice(0, this.cursor + 1);
+    this.stack.push(state);
+    if (this.stack.length > MAX_HISTORY) {
+      this.stack.shift();
+    } else {
+      this.cursor++;
+    }
+  }
+  undo() {
+    if (!this.canUndo) return null;
+    this.cursor--;
+    return this.stack[this.cursor];
+  }
+  redo() {
+    if (!this.canRedo) return null;
+    this.cursor++;
+    return this.stack[this.cursor];
+  }
+  get canUndo() {
+    return this.cursor > 0;
+  }
+  get canRedo() {
+    return this.cursor < this.stack.length - 1;
+  }
+  get current() {
+    return this.stack[this.cursor] ?? null;
+  }
+};
+
+// src/schema.ts
+var KNOWN_SCHEMAS = {
+  "package.json": "https://json.schemastore.org/package.json",
+  "tsconfig.json": "https://json.schemastore.org/tsconfig",
+  "tsconfig.base.json": "https://json.schemastore.org/tsconfig",
+  ".eslintrc.json": "https://json.schemastore.org/eslintrc",
+  ".prettierrc": "https://json.schemastore.org/prettierrc",
+  ".prettierrc.json": "https://json.schemastore.org/prettierrc",
+  "turbo.json": "https://turborepo.dev/schema.json",
+  ".babelrc": "https://json.schemastore.org/babelrc",
+  "nest-cli.json": "https://json.schemastore.org/nest-cli",
+  "vercel.json": "https://openapi.vercel.sh/vercel.json",
+  ".swcrc": "https://json.schemastore.org/swcrc"
+};
+var MAX_SCHEMA_CACHE = 50;
+var schemaCache = /* @__PURE__ */ new Map();
+async function fetchSchema(url) {
+  if (schemaCache.has(url)) {
+    return schemaCache.get(url);
+  }
+  try {
+    const res = await fetch(url);
+    if (!res.ok) return null;
+    const schema = await res.json();
+    if (schemaCache.size >= MAX_SCHEMA_CACHE) {
+      const oldest = schemaCache.keys().next().value;
+      if (oldest !== void 0) schemaCache.delete(oldest);
+    }
+    schemaCache.set(url, schema);
+    return schema;
+  } catch {
+    return null;
+  }
+}
+async function resolveSchema(json, filename) {
+  if (json !== null && typeof json === "object" && !Array.isArray(json) && typeof json["$schema"] === "string") {
+    const url = json["$schema"];
+    const schema = await fetchSchema(url);
+    if (schema) return schema;
+  }
+  if (filename) {
+    const base = filename.split("/").pop() ?? filename;
+    const knownUrl = KNOWN_SCHEMAS[base];
+    if (knownUrl) {
+      return fetchSchema(knownUrl);
+    }
+  }
+  return null;
+}
+function findDefinition(root, refPath) {
+  if (!refPath.startsWith("#/")) return void 0;
+  const segments = refPath.slice(2).split("/");
+  let current = root;
+  for (const seg of segments) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[seg];
+  }
+  return current;
+}
+function resolveRef(prop, root, visited) {
+  const seen = visited ?? /* @__PURE__ */ new Set();
+  if (prop.$ref) {
+    if (seen.has(prop.$ref)) return prop;
+    seen.add(prop.$ref);
+    const resolved = findDefinition(root, prop.$ref);
+    if (resolved) {
+      return resolveRef(resolved, root, seen);
+    }
+    return prop;
+  }
+  if (prop.allOf && prop.allOf.length > 0) {
+    return mergeAllOf(prop, root, seen);
+  }
+  return prop;
+}
+function mergeAllOf(prop, root, visited) {
+  const merged = { ...prop };
+  delete merged.allOf;
+  for (const sub of prop.allOf) {
+    const resolved = resolveRef(sub, root, new Set(visited));
+    if (resolved.type && !merged.type) merged.type = resolved.type;
+    if (resolved.properties) {
+      merged.properties = { ...merged.properties, ...resolved.properties };
+    }
+    if (resolved.required) {
+      merged.required = [
+        .../* @__PURE__ */ new Set([...merged.required ?? [], ...resolved.required])
+      ];
+    }
+    if (resolved.additionalProperties !== void 0 && merged.additionalProperties === void 0) {
+      merged.additionalProperties = resolved.additionalProperties;
+    }
+    if (resolved.items && !merged.items) merged.items = resolved.items;
+    if (resolved.description && !merged.description)
+      merged.description = resolved.description;
+    if (resolved.title && !merged.title) merged.title = resolved.title;
+    if (resolved.enum && !merged.enum) merged.enum = resolved.enum;
+    if (resolved.minimum !== void 0 && merged.minimum === void 0)
+      merged.minimum = resolved.minimum;
+    if (resolved.maximum !== void 0 && merged.maximum === void 0)
+      merged.maximum = resolved.maximum;
+    if (resolved.minLength !== void 0 && merged.minLength === void 0)
+      merged.minLength = resolved.minLength;
+    if (resolved.maxLength !== void 0 && merged.maxLength === void 0)
+      merged.maxLength = resolved.maxLength;
+    if (resolved.pattern && !merged.pattern) merged.pattern = resolved.pattern;
+    if (resolved.format && !merged.format) merged.format = resolved.format;
+  }
+  return merged;
+}
+function getPropertySchema(schema, path, rootSchema) {
+  const root = rootSchema ?? schema;
+  const segments = path.split("/").filter(Boolean);
+  let current = resolveRef(schema, root);
+  for (const seg of segments) {
+    if (!current) return void 0;
+    current = resolveRef(current, root);
+    if (current.properties?.[seg]) {
+      current = resolveRef(current.properties[seg], root);
+      continue;
+    }
+    if (current.patternProperties) {
+      const match = Object.entries(current.patternProperties).find(
+        ([pattern]) => {
+          try {
+            return new RegExp(pattern).test(seg);
+          } catch {
+            return false;
+          }
+        }
+      );
+      if (match) {
+        current = resolveRef(match[1], root);
+        continue;
+      }
+    }
+    if (current.additionalProperties && typeof current.additionalProperties === "object") {
+      current = resolveRef(current.additionalProperties, root);
+      continue;
+    }
+    if (current.items) {
+      if (Array.isArray(current.items)) {
+        const idx = Number(seg);
+        if (!isNaN(idx) && current.items[idx]) {
+          current = resolveRef(current.items[idx], root);
+          continue;
+        }
+      } else {
+        current = resolveRef(current.items, root);
+        continue;
+      }
+    }
+    if (current.anyOf || current.oneOf) {
+      const variants = current.anyOf ?? current.oneOf ?? [];
+      let found;
+      for (const variant of variants) {
+        const resolved = resolveRef(variant, root);
+        found = getPropertySchema(resolved, seg, root);
+        if (found) break;
+      }
+      if (found) {
+        current = found;
+        continue;
+      }
+      return void 0;
+    }
+    return void 0;
+  }
+  return current;
+}
+function clearSchemaCache() {
+  schemaCache.clear();
+}
+
+// src/validate.ts
+function schemaTypeMatches(nodeType, schemaType) {
+  if (!schemaType) return true;
+  const types = Array.isArray(schemaType) ? schemaType : [schemaType];
+  if (nodeType === "number" && types.includes("integer")) return true;
+  return types.includes(nodeType);
+}
+var FORMAT_PATTERNS = {
+  email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  uri: /^https?:\/\/.+/,
+  "uri-reference": /^(https?:\/\/|\/|\.\.?\/|#).*/,
+  "date-time": /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/,
+  date: /^\d{4}-\d{2}-\d{2}$/,
+  time: /^\d{2}:\d{2}:\d{2}/,
+  ipv4: /^(\d{1,3}\.){3}\d{1,3}$/,
+  ipv6: /^([0-9a-fA-F]{0,4}:){2,7}[0-9a-fA-F]{0,4}$/,
+  uuid: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+  hostname: /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*$/
+};
+function validateNode(node, schema) {
+  const errors = [];
+  if (!schema) {
+    return { valid: true, errors };
+  }
+  if (schema.type && !schemaTypeMatches(node.type, schema.type)) {
+    const expected = Array.isArray(schema.type) ? schema.type.join(" | ") : schema.type;
+    errors.push(`Expected type "${expected}", got "${node.type}"`);
+  }
+  if (schema.enum && schema.enum.length > 0 && node.value !== void 0) {
+    const match = schema.enum.some(
+      (v) => JSON.stringify(v) === JSON.stringify(node.value)
+    );
+    if (!match) {
+      errors.push(
+        `Value must be one of: ${schema.enum.map((v) => JSON.stringify(v)).join(", ")}`
+      );
+    }
+  }
+  if (schema.const !== void 0 && node.value !== void 0) {
+    if (JSON.stringify(node.value) !== JSON.stringify(schema.const)) {
+      errors.push(`Value must be ${JSON.stringify(schema.const)}`);
+    }
+  }
+  if (schema.required && (node.type === "object" || node.type === "array")) {
+    const childKeys = new Set(node.children.map((c) => c.key));
+    for (const req of schema.required) {
+      if (!childKeys.has(req)) {
+        errors.push(`Missing required property "${req}"`);
+      }
+    }
+  }
+  if (node.type === "number" && typeof node.value === "number") {
+    const val = node.value;
+    if (schema.minimum !== void 0 && val < schema.minimum) {
+      errors.push(`Value must be >= ${schema.minimum}`);
+    }
+    if (schema.maximum !== void 0 && val > schema.maximum) {
+      errors.push(`Value must be <= ${schema.maximum}`);
+    }
+    if (schema.exclusiveMinimum !== void 0) {
+      const bound = typeof schema.exclusiveMinimum === "number" ? schema.exclusiveMinimum : schema.minimum;
+      if (bound !== void 0 && val <= bound) {
+        errors.push(`Value must be > ${bound}`);
+      }
+    }
+    if (schema.exclusiveMaximum !== void 0) {
+      const bound = typeof schema.exclusiveMaximum === "number" ? schema.exclusiveMaximum : schema.maximum;
+      if (bound !== void 0 && val >= bound) {
+        errors.push(`Value must be < ${bound}`);
+      }
+    }
+    if (schema.multipleOf !== void 0) {
+      const remainder = Math.abs(val % schema.multipleOf);
+      if (remainder > 1e-10 && Math.abs(remainder - schema.multipleOf) > 1e-10) {
+        errors.push(`Value must be a multiple of ${schema.multipleOf}`);
+      }
+    }
+  }
+  if (node.type === "string" && typeof node.value === "string") {
+    const val = node.value;
+    if (schema.minLength !== void 0 && val.length < schema.minLength) {
+      errors.push(`Must be at least ${schema.minLength} characters`);
+    }
+    if (schema.maxLength !== void 0 && val.length > schema.maxLength) {
+      errors.push(`Must be at most ${schema.maxLength} characters`);
+    }
+    if (schema.pattern) {
+      try {
+        if (!new RegExp(schema.pattern).test(val)) {
+          errors.push(`Must match pattern: ${schema.pattern}`);
+        }
+      } catch {
+      }
+    }
+    if (schema.format && FORMAT_PATTERNS[schema.format]) {
+      if (!FORMAT_PATTERNS[schema.format].test(val)) {
+        errors.push(`Invalid ${schema.format} format`);
+      }
+    }
+  }
+  if (node.type === "array") {
+    if (schema.minItems !== void 0 && node.children.length < schema.minItems) {
+      errors.push(`Must have at least ${schema.minItems} items`);
+    }
+    if (schema.maxItems !== void 0 && node.children.length > schema.maxItems) {
+      errors.push(`Must have at most ${schema.maxItems} items`);
+    }
+  }
+  if (node.type === "object") {
+    if (schema.minProperties !== void 0 && node.children.length < schema.minProperties) {
+      errors.push(`Must have at least ${schema.minProperties} properties`);
+    }
+    if (schema.maxProperties !== void 0 && node.children.length > schema.maxProperties) {
+      errors.push(`Must have at most ${schema.maxProperties} properties`);
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/search.ts
+function searchNodes(tree, query) {
+  if (!query.trim()) return [];
+  const matches = [];
+  const lower = query.toLowerCase();
+  function walk(node) {
+    if (node.key && node.key.toLowerCase().includes(lower)) {
+      matches.push({ nodeId: node.id, field: "key" });
+    }
+    if (node.value !== void 0 && node.value !== null && String(node.value).toLowerCase().includes(lower)) {
+      matches.push({ nodeId: node.id, field: "value" });
+    }
+    for (const child of node.children) {
+      walk(child);
+    }
+  }
+  walk(tree.root);
+  return matches;
+}
+function getAncestorIds(tree, nodeIds) {
+  const ancestors = /* @__PURE__ */ new Set();
+  for (const nodeId of nodeIds) {
+    let current = tree.nodesById.get(nodeId);
+    while (current && current.parentId) {
+      ancestors.add(current.parentId);
+      current = tree.nodesById.get(current.parentId);
+    }
+  }
+  return ancestors;
+}
+
+// src/diff.ts
+function computeDiff(original, current, path = "") {
+  const entries = [];
+  if (original === current) {
+    return entries;
+  }
+  if (original === null || current === null || typeof original !== typeof current || Array.isArray(original) !== Array.isArray(current)) {
+    if (path) {
+      entries.push({
+        path,
+        type: "changed",
+        oldValue: original,
+        newValue: current
+      });
+    } else {
+      diffObject(original, current, path, entries);
+    }
+    return entries;
+  }
+  if (typeof original !== "object") {
+    if (original !== current) {
+      entries.push({
+        path: path || "/",
+        type: "changed",
+        oldValue: original,
+        newValue: current
+      });
+    }
+    return entries;
+  }
+  if (Array.isArray(original) && Array.isArray(current)) {
+    const maxLen = Math.max(original.length, current.length);
+    for (let i = 0; i < maxLen; i++) {
+      const childPath = path ? `${path}/${i}` : `/${i}`;
+      if (i >= original.length) {
+        entries.push({ path: childPath, type: "added", newValue: current[i] });
+      } else if (i >= current.length) {
+        entries.push({
+          path: childPath,
+          type: "removed",
+          oldValue: original[i]
+        });
+      } else {
+        entries.push(...computeDiff(original[i], current[i], childPath));
+      }
+    }
+    return entries;
+  }
+  diffObject(original, current, path, entries);
+  return entries;
+}
+function diffObject(original, current, path, entries) {
+  const origObj = original !== null && typeof original === "object" && !Array.isArray(original) ? original : {};
+  const currObj = current !== null && typeof current === "object" && !Array.isArray(current) ? current : {};
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(origObj), ...Object.keys(currObj)]);
+  for (const key of allKeys) {
+    const childPath = path ? `${path}/${key}` : `/${key}`;
+    const inOriginal = key in origObj;
+    const inCurrent = key in currObj;
+    if (!inOriginal && inCurrent) {
+      entries.push({ path: childPath, type: "added", newValue: currObj[key] });
+    } else if (inOriginal && !inCurrent) {
+      entries.push({
+        path: childPath,
+        type: "removed",
+        oldValue: origObj[key]
+      });
+    } else {
+      entries.push(...computeDiff(origObj[key], currObj[key], childPath));
+    }
+  }
+}
+function getDiffPaths(entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    map.set(entry.path, entry.type);
+  }
+  return map;
+}
+export {
+  History,
+  addProperty,
+  buildSubtree,
+  changeType,
+  clearSchemaCache,
+  computeDiff,
+  duplicateNode,
+  findNode,
+  findNodeByPath,
+  fromJson,
+  generateId,
+  getAncestorIds,
+  getDiffPaths,
+  getNodeType,
+  getPropertySchema,
+  moveNode,
+  removeNode,
+  reorderChildren,
+  resetIdCounter,
+  resolveRef,
+  resolveSchema,
+  searchNodes,
+  setKey,
+  setValue,
+  toJson,
+  validateNode
+};
+//# sourceMappingURL=index.mjs.map