@portabletext/editor 7.10.15 → 7.10.17

package/lib/_chunks-es/get-parent.js

@@ -1,195 +0,0 @@
-import { isTextBlock } from "@portabletext/schema";
-function isKeyedSegment(segment) {
-  return typeof segment == "object" && segment !== null && "_key" in segment;
-}
-function serializePath(path) {
-  return path.reduce((result, segment, index) => isKeyedSegment(segment) ? `${result}[_key=="${segment._key}"]` : `${result}${index === 0 ? "" : "."}${segment}`, "");
-}
-function isTypedObject(object) {
-  return isRecord(object) && typeof object._type == "string";
-}
-function isRecord(value) {
-  return !!value && (typeof value == "object" || typeof value == "function");
-}
-function getContainerChildren(containers, node, parent) {
-  const resolved = resolveNodeContainer(containers, parent, node);
-  if (!resolved)
-    return;
-  const fieldValue = node[resolved.field.name];
-  if (Array.isArray(fieldValue))
-    return {
-      children: fieldValue,
-      container: resolved
-    };
-}
-function resolveNodeContainer(containers, parent, node) {
-  if (parent?.of) {
-    for (const entry of parent.of)
-      if (entry.type === node._type)
-        return "field" in entry ? entry : void 0;
-  }
-  return containers.get(node._type);
-}
-function getChildren(snapshot, path) {
-  let currentChildren = snapshot.context.value, currentFieldName = "value", currentPath = [], isRoot = !0, currentParent;
-  for (const segment of path) {
-    if (typeof segment == "string")
-      continue;
-    let node;
-    if (isKeyedSegment(segment)) {
-      const candidatePath = isRoot ? [{
-        _key: segment._key
-      }] : [...currentPath, currentFieldName, {
-        _key: segment._key
-      }], index = snapshot.blockIndexMap.get(serializePath(candidatePath));
-      node = index !== void 0 && currentChildren[index]?._key === segment._key ? currentChildren[index] : currentChildren.find((child) => child._key === segment._key);
-    } else typeof segment == "number" && (node = currentChildren.at(segment));
-    if (!node)
-      return [];
-    currentPath = isRoot ? [{
-      _key: node._key
-    }] : [...currentPath, currentFieldName, {
-      _key: node._key
-    }], isRoot = !1;
-    const next = getNodeChildren(snapshot.context, node, currentParent);
-    if (!next)
-      return [];
-    currentChildren = next.children, currentFieldName = next.fieldName, currentParent = next.parent;
-  }
-  return currentChildren.map((child) => ({
-    node: child,
-    path: isRoot ? [{
-      _key: child._key
-    }] : [...currentPath, currentFieldName, {
-      _key: child._key
-    }]
-  }));
-}
-function getNodeChildren(context, node, parent) {
-  if (isTextBlock(context, node))
-    return {
-      children: node.children,
-      fieldName: "children",
-      parent: void 0
-    };
-  if (isTypedObject(node)) {
-    const result = getContainerChildren(context.containers, node, parent);
-    if (result)
-      return {
-        children: result.children,
-        fieldName: result.container.field.name,
-        parent: result.container
-      };
-  }
-  if ("value" in node && Array.isArray(node.value) && !("_key" in node) && !("_type" in node))
-    return {
-      children: node.value,
-      fieldName: "value",
-      parent: void 0
-    };
-}
-function getNode(snapshot, path) {
-  if (path.length === 0)
-    return;
-  const {
-    context,
-    blockIndexMap
-  } = snapshot;
-  let currentChildren = context.value, currentFieldName, node, currentParent;
-  const resolvedPath = [];
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i];
-    if (typeof segment == "string") {
-      if (currentFieldName !== void 0 && segment === currentFieldName) {
-        resolvedPath.push(segment);
-        continue;
-      }
-      for (let j = i + 1; j < path.length; j++) {
-        const s = path[j];
-        if (isKeyedSegment(s) || typeof s == "number")
-          return;
-      }
-      break;
-    }
-    if (isKeyedSegment(segment)) {
-      resolvedPath.push(segment);
-      const index = blockIndexMap.get(serializePath(resolvedPath));
-      index !== void 0 && currentChildren[index]?._key === segment._key ? node = currentChildren[index] : (node = currentChildren.find((child) => child._key === segment._key), node && node._key !== void 0 && (resolvedPath[resolvedPath.length - 1] = {
-        _key: node._key
-      }));
-    } else if (typeof segment == "number")
-      node = currentChildren.at(segment), node && resolvedPath.push({
-        _key: node._key
-      });
-    else
-      return;
-    if (!node)
-      return;
-    let hasMoreSegments = !1;
-    for (let j = i + 1; j < path.length; j++) {
-      const s = path[j];
-      if (isKeyedSegment(s) || typeof s == "number") {
-        hasMoreSegments = !0;
-        break;
-      }
-    }
-    if (hasMoreSegments) {
-      const next = getNodeChildren(context, node, currentParent);
-      if (!next)
-        return;
-      currentChildren = next.children, currentFieldName = next.fieldName, currentParent = next.parent;
-    } else
-      currentFieldName = void 0;
-  }
-  if (node) {
-    for (; resolvedPath.length > 0 && typeof resolvedPath[resolvedPath.length - 1] == "string"; )
-      resolvedPath.pop();
-    return {
-      node,
-      path: resolvedPath
-    };
-  }
-}
-function parentPath(path) {
-  if (path.length === 0)
-    throw new Error(`Cannot get the parent path of the root path [${path}].`);
-  let lastNodeIndex = -1;
-  for (let i = path.length - 1; i >= 0; i--)
-    if (isKeyedSegment(path[i]) || typeof path[i] == "number") {
-      lastNodeIndex = i;
-      break;
-    }
-  if (lastNodeIndex === -1)
-    return [];
-  const result = path.slice(0, lastNodeIndex);
-  return result.length > 0 && typeof result[result.length - 1] == "string" ? result.slice(0, -1) : result;
-}
-function getParent(snapshot, path, options) {
-  if (path.length === 0)
-    return;
-  const parent = parentPath(path);
-  if (parent.length === 0)
-    return;
-  const entry = getNode(snapshot, parent);
-  if (!entry)
-    return;
-  const result = {
-    node: entry.node,
-    path: entry.path
-  };
-  if (!(options?.match && !options.match(result.node, result.path)))
-    return result;
-}
-export {
-  getChildren,
-  getContainerChildren,
-  getNode,
-  getNodeChildren,
-  getParent,
-  isKeyedSegment,
-  isRecord,
-  isTypedObject,
-  parentPath,
-  serializePath
-};
-//# sourceMappingURL=get-parent.js.map

package/lib/_chunks-es/get-parent.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-parent.js","sources":["../../src/utils/util.is-keyed-segment.ts","../../src/paths/serialize-path.ts","../../src/utils/asserters.ts","../../src/traversal/get-container-children.ts","../../src/traversal/get-children.ts","../../src/traversal/get-node.ts","../../src/engine/path/parent-path.ts","../../src/traversal/get-parent.ts"],"sourcesContent":["import type {KeyedSegment} from '../types/paths'\n\n/**\n * @public\n */\nexport function isKeyedSegment(segment: unknown): segment is KeyedSegment {\n  return typeof segment === 'object' && segment !== null && '_key' in segment\n}\n","import type {Path} from '../types/paths'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\n\n/**\n * Serialize a keyed path to a string using Sanity's bracket notation.\n *\n * - `[{_key: 'k0'}]` -> `[_key==\"k0\"]`\n * - `[{_key: 'k0'}, 'children', {_key: 's0'}]` -> `[_key==\"k0\"].children[_key==\"s0\"]`\n * - `[{_key: 't0'}, 'rows', {_key: 'r0'}, 'cells', {_key: 'c0'}, 'content', {_key: 'b0'}, 'children', {_key: 's0'}]` -> `[_key==\"t0\"].rows[_key==\"r0\"].cells[_key==\"c0\"].content[_key==\"b0\"].children[_key==\"s0\"]`\n */\nexport function serializePath(path: Path): string {\n  return path.reduce<string>((result, segment, index) => {\n    if (isKeyedSegment(segment)) {\n      return `${result}[_key==\"${segment._key}\"]`\n    }\n\n    const separator = index === 0 ? '' : '.'\n    return `${result}${separator}${segment}`\n  }, '')\n}\n","import type {TypedObject} from '@portabletext/schema'\n\nexport function isTypedObject(object: unknown): object is TypedObject {\n  return isRecord(object) && typeof object['_type'] === 'string'\n}\n\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return !!value && (typeof value === 'object' || typeof value === 'function')\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {\n  Containers,\n  RegisteredContainer,\n} from '../schema/resolve-containers'\n\n/**\n * Resolve a container node's editable child array.\n *\n * Returns `{children, container}` for a node registered as a container:\n * `children` is the node's editable child array, and `container` is the\n * node's own container registration. Read `container.field.name` for the\n * path segment that reaches `children`, and thread `container` back in as\n * `parent` when descending into them.\n *\n * Returns `undefined` for anything that is not a container: text blocks,\n * spans, leaves, and unregistered objects. It is node-based and resolves\n * in one step with no path re-walk, so recursive descent over containers\n * is linear in nesting depth. The caller seeds the document root from\n * `context.value` itself.\n *\n * @beta\n */\nexport function getContainerChildren(\n  containers: Containers,\n  node: Node,\n  parent?: RegisteredContainer,\n):\n  | {\n      children: Array<Node>\n      container: RegisteredContainer\n    }\n  | undefined {\n  const resolved = resolveNodeContainer(containers, parent, node)\n\n  if (!resolved) {\n    return undefined\n  }\n\n  const fieldValue = (node as Record<string, unknown>)[resolved.field.name]\n\n  if (!Array.isArray(fieldValue)) {\n    return undefined\n  }\n\n  return {\n    children: fieldValue as Array<Node>,\n    container: resolved,\n  }\n}\n\n/**\n * Pick the positional override from `parent.of` if present; fall back\n * to the top-level entry. Returns only `RegisteredContainer` entries\n * since leaves do not have editable children.\n */\nfunction resolveNodeContainer(\n  containers: Containers,\n  parent: RegisteredContainer | undefined,\n  node: Node,\n): RegisteredContainer | undefined {\n  if (parent?.of) {\n    for (const entry of parent.of) {\n      if (entry.type === node._type) {\n        // Only return container entries; leaves have no editable children.\n        if ('field' in entry) {\n          return entry\n        }\n        return undefined\n      }\n    }\n  }\n  return containers.get(node._type)\n}\n","import {isTextBlock} from '@portabletext/schema'\nimport type {EditorSchema} from '../editor/editor-schema'\nimport type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {serializePath} from '../paths/serialize-path'\nimport type {\n  Containers,\n  RegisteredContainer,\n} from '../schema/resolve-containers'\nimport {isTypedObject} from '../utils/asserters'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport {getContainerChildren} from './get-container-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the children of a node at a given path.\n *\n * @beta\n */\nexport function getChildren(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): Array<{node: Node; path: Path}> {\n  let currentChildren: Array<Node> = snapshot.context.value\n  let currentFieldName = 'value'\n  let currentPath: Path = []\n  let isRoot = true\n  let currentParent: RegisteredContainer | undefined\n\n  for (const segment of path) {\n    if (typeof segment === 'string') {\n      continue\n    }\n\n    let node: Node | undefined\n    if (isKeyedSegment(segment)) {\n      // Resolve via `blockIndexMap` (O(1)) and fall back to a linear scan on a\n      // miss or when the snapshot's map disagrees with the value, mirroring\n      // `getNode`. The candidate path is this segment's full keyed path.\n      const candidatePath: Path = isRoot\n        ? [{_key: segment._key}]\n        : [...currentPath, currentFieldName, {_key: segment._key}]\n      const index = snapshot.blockIndexMap.get(serializePath(candidatePath))\n      node =\n        index !== undefined && currentChildren[index]?._key === segment._key\n          ? currentChildren[index]\n          : currentChildren.find((child) => child._key === segment._key)\n    } else if (typeof segment === 'number') {\n      node = currentChildren.at(segment)\n    }\n\n    if (!node) {\n      return []\n    }\n\n    currentPath = isRoot\n      ? [{_key: node._key}]\n      : [...currentPath, currentFieldName, {_key: node._key}]\n    isRoot = false\n\n    const next = getNodeChildren(snapshot.context, node, currentParent)\n\n    if (!next) {\n      return []\n    }\n\n    currentChildren = next.children\n    currentFieldName = next.fieldName\n    currentParent = next.parent\n  }\n\n  return currentChildren.map((child) => ({\n    node: child,\n    path: isRoot\n      ? [{_key: child._key}]\n      : [...currentPath, currentFieldName, {_key: child._key}],\n  }))\n}\n\n/**\n * Resolve a node's editable child array.\n *\n * When `parent` is provided and its `of` declares a positional entry\n * matching `node._type`, that positional entry's `field` is used.\n * Otherwise the top-level `containers.get(node._type)` provides the\n * fallback.\n *\n * The returned `parent` is the resolved container entry for `node`\n * itself (used by the caller to thread further descent).\n *\n * Internal descent kernel shared by the positional traversal utilities\n * (`getChildren`, `getNode`, `getNodes`, `getAncestors`); it folds the\n * text-block, container, and root-document cases. Public consumers that\n * only need to descend containers use {@link getContainerChildren}.\n */\nexport function getNodeChildren(\n  context: {\n    schema: EditorSchema\n    containers: Containers\n  },\n  node: Node | {value: Array<Node>},\n  parent?: RegisteredContainer,\n):\n  | {\n      children: Array<Node>\n      fieldName: string\n      parent: RegisteredContainer | undefined\n    }\n  | undefined {\n  // Text blocks store children in .children\n  if (isTextBlock(context, node)) {\n    return {\n      children: node.children,\n      fieldName: 'children',\n      parent: undefined,\n    }\n  }\n\n  if (isTypedObject(node)) {\n    const result = getContainerChildren(context.containers, node, parent)\n\n    if (result) {\n      return {\n        children: result.children,\n        fieldName: result.container.field.name,\n        parent: result.container,\n      }\n    }\n  }\n\n  // Root context: has .value array but no _key or _type\n  if (\n    'value' in node &&\n    Array.isArray(node['value']) &&\n    !('_key' in node) &&\n    !('_type' in node)\n  ) {\n    return {\n      children: node['value'] as Array<Node>,\n      fieldName: 'value',\n      parent: undefined,\n    }\n  }\n\n  return undefined\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {serializePath} from '../paths/serialize-path'\nimport type {RegisteredContainer} from '../schema/resolve-containers'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport {getNodeChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the node at a given path.\n *\n * The path can be either keyed (KeyedSegment + field name strings) or\n * indexed (numbers). Keyed segments are resolved by matching `_key`,\n * field name strings name a structural descent into the previous\n * node's children, and numbers are resolved by index.\n *\n * The returned `path` always identifies the returned node: it's fully\n * keyed (numeric indices are converted to `KeyedSegment`s) and any\n * trailing segments in the input that point outside the value tree —\n * e.g. an object node's primitive field, or an annotation reached via\n * `'markDefs'` on a text block — are stripped so that\n * `getNode(snapshot, entry.path).node === entry.node`.\n *\n * The walk stops when a string segment names a field that isn't the\n * current node's structural child array. Annotations live in\n * `markDefs` on a text block, alongside `children` rather than inside\n * it, so `getNode` resolves an annotation path to the enclosing text\n * block. Use `getAnnotation` to resolve the annotation itself.\n *\n * @beta\n */\nexport function getNode(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; path: Path} | undefined {\n  if (path.length === 0) {\n    return undefined\n  }\n\n  const {context, blockIndexMap} = snapshot\n  let currentChildren: Array<Node> = context.value\n  let currentFieldName: string | undefined\n  let node: Node | undefined\n  let currentParent: RegisteredContainer | undefined\n  const resolvedPath: Path = []\n\n  for (let i = 0; i < path.length; i++) {\n    const segment = path[i]\n\n    if (typeof segment === 'string') {\n      // A string segment names a structural descent. If it matches the\n      // field name produced by the previous node's `getNodeChildren`,\n      // it's part of the value-tree descent — push it and continue.\n      // Otherwise the string names a sidecar field (markDefs on a text\n      // block, a primitive field on an object). If the input keeps\n      // digging past it with more keyed/numeric segments, the caller\n      // wanted a node inside the sidecar and `getNode` can't reach it\n      // (use `getAnnotation` for annotations); return undefined.\n      // Otherwise the rest is just trailing field names — let the loop\n      // exit and the post-loop strip remove them.\n      if (currentFieldName !== undefined && segment === currentFieldName) {\n        resolvedPath.push(segment)\n        continue\n      }\n      for (let j = i + 1; j < path.length; j++) {\n        const s = path[j]\n        if (isKeyedSegment(s) || typeof s === 'number') {\n          return undefined\n        }\n      }\n      break\n    }\n\n    if (isKeyedSegment(segment)) {\n      resolvedPath.push(segment)\n      const index = blockIndexMap.get(serializePath(resolvedPath))\n      if (\n        index !== undefined &&\n        currentChildren[index]?._key === segment._key\n      ) {\n        node = currentChildren[index]\n      } else {\n        // The map can miss (unkeyed transient nodes, e.g. `{_type:'table'}`\n        // inserted by a remote patch before normalize mints a key) or\n        // disagree with the traversed value (snapshots that pair the live\n        // map with a pre-apply value, e.g. `textPatch`). Fall back to a\n        // linear scan in both cases.\n        node = currentChildren.find((child) => child._key === segment._key)\n        if (node && node._key !== undefined) {\n          resolvedPath[resolvedPath.length - 1] = {_key: node._key}\n        }\n      }\n    } else if (typeof segment === 'number') {\n      node = currentChildren.at(segment)\n      if (node) {\n        resolvedPath.push({_key: node._key})\n      }\n    } else {\n      return undefined\n    }\n\n    if (!node) {\n      return undefined\n    }\n\n    let hasMoreSegments = false\n    for (let j = i + 1; j < path.length; j++) {\n      const s = path[j]\n      if (isKeyedSegment(s) || typeof s === 'number') {\n        hasMoreSegments = true\n        break\n      }\n    }\n\n    if (hasMoreSegments) {\n      const next = getNodeChildren(context, node, currentParent)\n\n      if (!next) {\n        return undefined\n      }\n\n      currentChildren = next.children\n      currentFieldName = next.fieldName\n      currentParent = next.parent\n    } else {\n      currentFieldName = undefined\n    }\n  }\n\n  if (!node) {\n    return undefined\n  }\n\n  // Strip trailing field-name segments. The walker may have pushed\n  // matching field names during structural descent; if the deepest\n  // reached keyed segment was the last keyed segment in the input,\n  // any further field names that followed are part of the input but\n  // don't identify the returned node.\n  while (\n    resolvedPath.length > 0 &&\n    typeof resolvedPath[resolvedPath.length - 1] === 'string'\n  ) {\n    resolvedPath.pop()\n  }\n\n  return {node, path: resolvedPath}\n}\n","import {isKeyedSegment} from '../../utils/util.is-keyed-segment'\nimport type {Path} from '../interfaces/path'\n\n/**\n * Get the parent path of a path.\n *\n * Drops the last node segment (keyed or numeric) and the preceding field\n * name string.\n *\n * [{_key:'b1'}, 'children', {_key:'s1'}] → [{_key:'b1'}]\n * [{_key:'b1'}, 'children', 0]           → [{_key:'b1'}]\n * [{_key:'b1'}]                           → []\n */\nexport function parentPath(path: Path): Path {\n  if (path.length === 0) {\n    throw new Error(`Cannot get the parent path of the root path [${path}].`)\n  }\n\n  let lastNodeIndex = -1\n  for (let i = path.length - 1; i >= 0; i--) {\n    if (isKeyedSegment(path[i]) || typeof path[i] === 'number') {\n      lastNodeIndex = i\n      break\n    }\n  }\n\n  if (lastNodeIndex === -1) {\n    return []\n  }\n\n  const result = path.slice(0, lastNodeIndex)\n\n  if (result.length > 0 && typeof result[result.length - 1] === 'string') {\n    return result.slice(0, -1)\n  }\n\n  return result\n}\n","import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {parentPath} from '../engine/path/parent-path'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the parent of a node at a given path.\n *\n * A parent has children, so it is always a `PortableTextBlock` (text block\n * or object node).\n *\n * When `match` is provided and the parent does not satisfy it, returns\n * `undefined`.\n *\n * @beta\n */\nexport function getParent<TMatch extends PortableTextBlock>(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    match: (node: PortableTextBlock, path: Path) => node is TMatch\n  },\n): {node: TMatch; path: Path} | undefined\n/**\n * @beta\n */\nexport function getParent(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options?: {\n    match?: (node: PortableTextBlock, path: Path) => boolean\n  },\n): {node: PortableTextBlock; path: Path} | undefined\nexport function getParent(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options?: {\n    match?: (node: PortableTextBlock, path: Path) => boolean\n  },\n): {node: PortableTextBlock; path: Path} | undefined {\n  if (path.length === 0) {\n    return undefined\n  }\n\n  const parent = parentPath(path)\n\n  if (parent.length === 0) {\n    return undefined\n  }\n\n  const entry = getNode(snapshot, parent)\n\n  if (!entry) {\n    return undefined\n  }\n\n  const result = {node: entry.node as PortableTextBlock, path: entry.path}\n\n  if (options?.match && !options.match(result.node, result.path)) {\n    return undefined\n  }\n\n  return result\n}\n"],"names":["isKeyedSegment","segment","serializePath","path","reduce","result","index","_key","isTypedObject","object","isRecord","value","getContainerChildren","containers","node","parent","resolved","resolveNodeContainer","fieldValue","field","name","Array","isArray","children","container","of","entry","type","_type","get","getChildren","snapshot","currentChildren","context","currentFieldName","currentPath","isRoot","currentParent","candidatePath","blockIndexMap","undefined","find","child","at","next","getNodeChildren","fieldName","map","isTextBlock","getNode","length","resolvedPath","i","push","j","s","hasMoreSegments","pop","parentPath","Error","lastNodeIndex","slice","getParent","options","match"],"mappings":";AAKO,SAASA,eAAeC,SAA2C;AACxE,SAAO,OAAOA,WAAY,YAAYA,YAAY,QAAQ,UAAUA;AACtE;ACGO,SAASC,cAAcC,MAAoB;AAChD,SAAOA,KAAKC,OAAe,CAACC,QAAQJ,SAASK,UACvCN,eAAeC,OAAO,IACjB,GAAGI,MAAM,WAAWJ,QAAQM,IAAI,OAIlC,GAAGF,MAAM,GADEC,UAAU,IAAI,KAAK,GACT,GAAGL,OAAO,IACrC,EAAE;AACP;ACjBO,SAASO,cAAcC,QAAwC;AACpE,SAAOC,SAASD,MAAM,KAAK,OAAOA,OAAO,SAAa;AACxD;AAEO,SAASC,SAASC,OAAkD;AACzE,SAAO,CAAC,CAACA,UAAU,OAAOA,SAAU,YAAY,OAAOA,SAAU;AACnE;ACeO,SAASC,qBACdC,YACAC,MACAC,QAMY;AACZ,QAAMC,WAAWC,qBAAqBJ,YAAYE,QAAQD,IAAI;AAE9D,MAAI,CAACE;AACH;AAGF,QAAME,aAAcJ,KAAiCE,SAASG,MAAMC,IAAI;AAExE,MAAKC,MAAMC,QAAQJ,UAAU;AAI7B,WAAO;AAAA,MACLK,UAAUL;AAAAA,MACVM,WAAWR;AAAAA,IAAAA;AAEf;AAOA,SAASC,qBACPJ,YACAE,QACAD,MACiC;AACjC,MAAIC,QAAQU;AACV,eAAWC,SAASX,OAAOU;AACzB,UAAIC,MAAMC,SAASb,KAAKc;AAEtB,eAAI,WAAWF,QACNA,QAET;AAAA;AAIN,SAAOb,WAAWgB,IAAIf,KAAKc,KAAK;AAClC;ACtDO,SAASE,YACdC,UACA5B,MACiC;AACjC,MAAI6B,kBAA+BD,SAASE,QAAQtB,OAChDuB,mBAAmB,SACnBC,cAAoB,CAAA,GACpBC,SAAS,IACTC;AAEJ,aAAWpC,WAAWE,MAAM;AAC1B,QAAI,OAAOF,WAAY;AACrB;AAGF,QAAIa;AACJ,QAAId,eAAeC,OAAO,GAAG;AAI3B,YAAMqC,gBAAsBF,SACxB,CAAC;AAAA,QAAC7B,MAAMN,QAAQM;AAAAA,MAAAA,CAAK,IACrB,CAAC,GAAG4B,aAAaD,kBAAkB;AAAA,QAAC3B,MAAMN,QAAQM;AAAAA,MAAAA,CAAK,GACrDD,QAAQyB,SAASQ,cAAcV,IAAI3B,cAAcoC,aAAa,CAAC;AACrExB,aACER,UAAUkC,UAAaR,gBAAgB1B,KAAK,GAAGC,SAASN,QAAQM,OAC5DyB,gBAAgB1B,KAAK,IACrB0B,gBAAgBS,KAAMC,WAAUA,MAAMnC,SAASN,QAAQM,IAAI;AAAA,IACnE,MAAW,QAAON,WAAY,aAC5Ba,OAAOkB,gBAAgBW,GAAG1C,OAAO;AAGnC,QAAI,CAACa;AACH,aAAO,CAAA;AAGTqB,kBAAcC,SACV,CAAC;AAAA,MAAC7B,MAAMO,KAAKP;AAAAA,IAAAA,CAAK,IAClB,CAAC,GAAG4B,aAAaD,kBAAkB;AAAA,MAAC3B,MAAMO,KAAKP;AAAAA,IAAAA,CAAK,GACxD6B,SAAS;AAET,UAAMQ,OAAOC,gBAAgBd,SAASE,SAASnB,MAAMuB,aAAa;AAElE,QAAI,CAACO;AACH,aAAO,CAAA;AAGTZ,sBAAkBY,KAAKrB,UACvBW,mBAAmBU,KAAKE,WACxBT,gBAAgBO,KAAK7B;AAAAA,EACvB;AAEA,SAAOiB,gBAAgBe,IAAKL,CAAAA,WAAW;AAAA,IACrC5B,MAAM4B;AAAAA,IACNvC,MAAMiC,SACF,CAAC;AAAA,MAAC7B,MAAMmC,MAAMnC;AAAAA,IAAAA,CAAK,IACnB,CAAC,GAAG4B,aAAaD,kBAAkB;AAAA,MAAC3B,MAAMmC,MAAMnC;AAAAA,IAAAA,CAAK;AAAA,EAAA,EACzD;AACJ;AAkBO,SAASsC,gBACdZ,SAIAnB,MACAC,QAOY;AAEZ,MAAIiC,YAAYf,SAASnB,IAAI;AAC3B,WAAO;AAAA,MACLS,UAAUT,KAAKS;AAAAA,MACfuB,WAAW;AAAA,MACX/B,QAAQyB;AAAAA,IAAAA;AAIZ,MAAIhC,cAAcM,IAAI,GAAG;AACvB,UAAMT,SAASO,qBAAqBqB,QAAQpB,YAAYC,MAAMC,MAAM;AAEpE,QAAIV;AACF,aAAO;AAAA,QACLkB,UAAUlB,OAAOkB;AAAAA,QACjBuB,WAAWzC,OAAOmB,UAAUL,MAAMC;AAAAA,QAClCL,QAAQV,OAAOmB;AAAAA,MAAAA;AAAAA,EAGrB;AAGA,MACE,WAAWV,QACXO,MAAMC,QAAQR,KAAK,KAAQ,KAC3B,EAAE,UAAUA,SACZ,EAAE,WAAWA;AAEb,WAAO;AAAA,MACLS,UAAUT,KAAK;AAAA,MACfgC,WAAW;AAAA,MACX/B,QAAQyB;AAAAA,IAAAA;AAKd;AClHO,SAASS,QACdlB,UACA5B,MACsC;AACtC,MAAIA,KAAK+C,WAAW;AAClB;AAGF,QAAM;AAAA,IAACjB;AAAAA,IAASM;AAAAA,EAAAA,IAAiBR;AACjC,MAAIC,kBAA+BC,QAAQtB,OACvCuB,kBACApB,MACAuB;AACJ,QAAMc,eAAqB,CAAA;AAE3B,WAASC,IAAI,GAAGA,IAAIjD,KAAK+C,QAAQE,KAAK;AACpC,UAAMnD,UAAUE,KAAKiD,CAAC;AAEtB,QAAI,OAAOnD,WAAY,UAAU;AAW/B,UAAIiC,qBAAqBM,UAAavC,YAAYiC,kBAAkB;AAClEiB,qBAAaE,KAAKpD,OAAO;AACzB;AAAA,MACF;AACA,eAASqD,IAAIF,IAAI,GAAGE,IAAInD,KAAK+C,QAAQI,KAAK;AACxC,cAAMC,IAAIpD,KAAKmD,CAAC;AAChB,YAAItD,eAAeuD,CAAC,KAAK,OAAOA,KAAM;AACpC;AAAA,MAEJ;AACA;AAAA,IACF;AAEA,QAAIvD,eAAeC,OAAO,GAAG;AAC3BkD,mBAAaE,KAAKpD,OAAO;AACzB,YAAMK,QAAQiC,cAAcV,IAAI3B,cAAciD,YAAY,CAAC;AAEzD7C,gBAAUkC,UACVR,gBAAgB1B,KAAK,GAAGC,SAASN,QAAQM,OAEzCO,OAAOkB,gBAAgB1B,KAAK,KAO5BQ,OAAOkB,gBAAgBS,KAAMC,CAAAA,UAAUA,MAAMnC,SAASN,QAAQM,IAAI,GAC9DO,QAAQA,KAAKP,SAASiC,WACxBW,aAAaA,aAAaD,SAAS,CAAC,IAAI;AAAA,QAAC3C,MAAMO,KAAKP;AAAAA,MAAAA;AAAAA,IAG1D,WAAW,OAAON,WAAY;AAC5Ba,aAAOkB,gBAAgBW,GAAG1C,OAAO,GAC7Ba,QACFqC,aAAaE,KAAK;AAAA,QAAC9C,MAAMO,KAAKP;AAAAA,MAAAA,CAAK;AAAA;AAGrC;AAGF,QAAI,CAACO;AACH;AAGF,QAAI0C,kBAAkB;AACtB,aAASF,IAAIF,IAAI,GAAGE,IAAInD,KAAK+C,QAAQI,KAAK;AACxC,YAAMC,IAAIpD,KAAKmD,CAAC;AAChB,UAAItD,eAAeuD,CAAC,KAAK,OAAOA,KAAM,UAAU;AAC9CC,0BAAkB;AAClB;AAAA,MACF;AAAA,IACF;AAEA,QAAIA,iBAAiB;AACnB,YAAMZ,OAAOC,gBAAgBZ,SAASnB,MAAMuB,aAAa;AAEzD,UAAI,CAACO;AACH;AAGFZ,wBAAkBY,KAAKrB,UACvBW,mBAAmBU,KAAKE,WACxBT,gBAAgBO,KAAK7B;AAAAA,IACvB;AACEmB,yBAAmBM;AAAAA,EAEvB;AAEA,MAAK1B,MASL;AAAA,WACEqC,aAAaD,SAAS,KACtB,OAAOC,aAAaA,aAAaD,SAAS,CAAC,KAAM;AAEjDC,mBAAaM,IAAAA;AAGf,WAAO;AAAA,MAAC3C;AAAAA,MAAMX,MAAMgD;AAAAA,IAAAA;AAAAA,EAAY;AAClC;ACrIO,SAASO,WAAWvD,MAAkB;AAC3C,MAAIA,KAAK+C,WAAW;AAClB,UAAM,IAAIS,MAAM,gDAAgDxD,IAAI,IAAI;AAG1E,MAAIyD,gBAAgB;AACpB,WAASR,IAAIjD,KAAK+C,SAAS,GAAGE,KAAK,GAAGA;AACpC,QAAIpD,eAAeG,KAAKiD,CAAC,CAAC,KAAK,OAAOjD,KAAKiD,CAAC,KAAM,UAAU;AAC1DQ,sBAAgBR;AAChB;AAAA,IACF;AAGF,MAAIQ,kBAAkB;AACpB,WAAO,CAAA;AAGT,QAAMvD,SAASF,KAAK0D,MAAM,GAAGD,aAAa;AAE1C,SAAIvD,OAAO6C,SAAS,KAAK,OAAO7C,OAAOA,OAAO6C,SAAS,CAAC,KAAM,WACrD7C,OAAOwD,MAAM,GAAG,EAAE,IAGpBxD;AACT;ACHO,SAASyD,UACd/B,UACA5B,MACA4D,SAGmD;AACnD,MAAI5D,KAAK+C,WAAW;AAClB;AAGF,QAAMnC,SAAS2C,WAAWvD,IAAI;AAE9B,MAAIY,OAAOmC,WAAW;AACpB;AAGF,QAAMxB,QAAQuB,QAAQlB,UAAUhB,MAAM;AAEtC,MAAI,CAACW;AACH;AAGF,QAAMrB,SAAS;AAAA,IAACS,MAAMY,MAAMZ;AAAAA,IAA2BX,MAAMuB,MAAMvB;AAAAA,EAAAA;AAEnE,MAAI4D,EAAAA,SAASC,SAAS,CAACD,QAAQC,MAAM3D,OAAOS,MAAMT,OAAOF,IAAI;AAI7D,WAAOE;AACT;"}

package/lib/_chunks-es/get-path-sub-schema.js

@@ -1,399 +0,0 @@
-import { isKeyedSegment, serializePath, getNodeChildren, getNode, isTypedObject, getChildren, parentPath, getParent } from "./get-parent.js";
-import { getSubSchema } from "@portabletext/schema";
-function getAncestors(snapshot, path) {
-  const keyedIndices = [];
-  for (let i = 0; i < path.length; i++)
-    isKeyedSegment(path[i]) && keyedIndices.push(i);
-  if (keyedIndices.length <= 1)
-    return [];
-  const {
-    context,
-    blockIndexMap
-  } = snapshot;
-  let currentChildren = context.value, currentParent;
-  const ancestorsByDepth = [], resolvedPath = [], targetKeyedIndex = keyedIndices[keyedIndices.length - 1];
-  let segmentIndex = 0;
-  for (; segmentIndex < targetKeyedIndex; ) {
-    const segment = path[segmentIndex];
-    if (typeof segment == "string") {
-      resolvedPath.push(segment), segmentIndex++;
-      continue;
-    }
-    let node;
-    if (isKeyedSegment(segment)) {
-      resolvedPath.push(segment);
-      const index = blockIndexMap.get(serializePath(resolvedPath));
-      index !== void 0 && currentChildren[index]?._key === segment._key ? node = currentChildren[index] : (node = currentChildren.find((child) => child._key === segment._key), node && node._key !== void 0 && (resolvedPath[resolvedPath.length - 1] = {
-        _key: node._key
-      }));
-    } else if (typeof segment == "number")
-      node = currentChildren.at(segment), node && resolvedPath.push({
-        _key: node._key
-      });
-    else
-      return [];
-    if (!node)
-      return [];
-    const next = getNodeChildren(context, node, currentParent);
-    if (!next)
-      return [];
-    ancestorsByDepth.push({
-      node,
-      path: resolvedPath.slice()
-    }), currentChildren = next.children, currentParent = next.parent, segmentIndex++;
-  }
-  return ancestorsByDepth.reverse();
-}
-function hasNode(snapshot, path) {
-  return getNode(snapshot, path) !== void 0;
-}
-function resolveContainerAt(containers, value, path) {
-  const keyedIndices = [];
-  for (let index = 0; index < path.length; index++)
-    isKeyedSegment(path[index]) && keyedIndices.push(index);
-  if (keyedIndices.length === 0)
-    return;
-  let currentChildren = value, parent, resolved;
-  const targetKeyedIndex = keyedIndices[keyedIndices.length - 1];
-  let segmentIndex = 0;
-  for (; segmentIndex <= targetKeyedIndex; ) {
-    const segment = path[segmentIndex];
-    if (typeof segment == "string") {
-      segmentIndex++;
-      continue;
-    }
-    let node;
-    if (isKeyedSegment(segment))
-      node = currentChildren.find((child) => child._key === segment._key);
-    else if (typeof segment == "number")
-      node = currentChildren.at(segment);
-    else
-      return;
-    if (!node || (resolved = resolveNodeEntry(containers, parent, node), !resolved))
-      return;
-    if (segmentIndex < targetKeyedIndex) {
-      if (!("field" in resolved))
-        return;
-      const fieldValue = node[resolved.field.name];
-      if (!Array.isArray(fieldValue))
-        return;
-      parent = resolved, currentChildren = fieldValue;
-    }
-    segmentIndex++;
-  }
-  return resolved;
-}
-function resolveNodeEntry(containers, parent, node) {
-  if (parent?.of) {
-    for (const entry of parent.of)
-      if (entry.type === node._type)
-        return entry;
-  }
-  return containers.get(node._type);
-}
-function isEditableContainer(snapshot, _node, path) {
-  if (snapshot.context.containers.size === 0)
-    return !1;
-  const resolved = resolveContainerAt(snapshot.context.containers, snapshot.context.value, path);
-  return !!(resolved && "field" in resolved);
-}
-function isObject(snapshot, node) {
-  return isTypedObject(node) && node._type !== snapshot.context.schema.block.name && node._type !== snapshot.context.schema.span.name;
-}
-function comparePaths(path, another, root) {
-  const min = Math.min(path.length, another.length);
-  let currentChildren = root?.value, currentNode;
-  for (let i = 0; i < min; i++) {
-    const segment = path[i], otherSegment = another[i];
-    if (isKeyedSegment(segment) && isKeyedSegment(otherSegment)) {
-      if (segment._key === otherSegment._key) {
-        currentChildren && (currentNode = currentChildren.find((c) => c._key === segment._key), currentChildren = void 0);
-        continue;
-      }
-      if (currentChildren) {
-        const segmentIndex = currentChildren.findIndex((c) => c._key === segment._key), otherSegmentIndex = currentChildren.findIndex((c) => c._key === otherSegment._key);
-        if (segmentIndex !== -1 && otherSegmentIndex !== -1)
-          return segmentIndex < otherSegmentIndex ? -1 : 1;
-      }
-      if (segment._key < otherSegment._key)
-        return -1;
-      if (segment._key > otherSegment._key)
-        return 1;
-      continue;
-    }
-    if (typeof segment == "string" && typeof otherSegment == "string") {
-      if (segment === otherSegment) {
-        if (currentNode) {
-          const fieldValue = currentNode[segment];
-          currentChildren = Array.isArray(fieldValue) ? fieldValue : void 0, currentNode = void 0;
-        }
-        continue;
-      }
-      if (segment < otherSegment)
-        return -1;
-      if (segment > otherSegment)
-        return 1;
-      continue;
-    }
-    if (typeof segment == "number" && typeof otherSegment == "number") {
-      if (segment < otherSegment)
-        return -1;
-      if (segment > otherSegment)
-        return 1;
-      continue;
-    }
-    break;
-  }
-  return 0;
-}
-function comparePoints$1(point, another, root) {
-  const result = comparePaths(point.path, another.path, root);
-  return result === 0 ? point.offset < another.offset ? -1 : point.offset > another.offset ? 1 : 0 : result;
-}
-function isAfterPoint(point, another, root) {
-  return comparePoints$1(point, another, root) === 1;
-}
-function isBackwardRange(range, root) {
-  const {
-    anchor,
-    focus
-  } = range;
-  return isAfterPoint(anchor, focus, root);
-}
-function rangeEdges(range, root) {
-  const {
-    anchor,
-    focus
-  } = range;
-  return isBackwardRange(range, root) ? [focus, anchor] : [anchor, focus];
-}
-function isTextBlockNode(context, node) {
-  return isTypedObject(node) && node._type === context.schema.block.name;
-}
-function isAncestorPath(path, another) {
-  if (path.length >= another.length)
-    return !1;
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i], otherSegment = another[i];
-    if (isKeyedSegment(segment) && isKeyedSegment(otherSegment)) {
-      if (segment._key !== otherSegment._key)
-        return !1;
-    } else if (segment !== otherSegment)
-      return !1;
-  }
-  return !0;
-}
-function resolveChildEntryIndex(blockIndexMap, children, childPath) {
-  const lastSegment = childPath[childPath.length - 1];
-  if (typeof lastSegment == "number")
-    return lastSegment >= 0 && lastSegment < children.length ? lastSegment : -1;
-  if (!isKeyedSegment(lastSegment))
-    return -1;
-  let fullyKeyed = !0;
-  for (let segmentIndex = 0; segmentIndex < childPath.length - 1; segmentIndex++) {
-    const segment = childPath[segmentIndex];
-    if (typeof segment != "string" && !isKeyedSegment(segment)) {
-      fullyKeyed = !1;
-      break;
-    }
-  }
-  if (fullyKeyed) {
-    const mappedIndex = blockIndexMap.get(serializePath(childPath));
-    if (mappedIndex !== void 0 && children[mappedIndex]?.node._key === lastSegment._key)
-      return mappedIndex;
-  }
-  return children.findIndex((child) => child.node._key === lastSegment._key);
-}
-function* getNodes(snapshot, options = {}) {
-  const {
-    at = [],
-    from,
-    to,
-    match,
-    reverse = !1
-  } = options;
-  if (from === void 0 && to === void 0) {
-    yield* getNodesSimple(snapshot, at, {
-      match,
-      reverse
-    });
-    return;
-  }
-  yield* getNodesInRange(snapshot, at, {
-    from,
-    to,
-    match,
-    reverse
-  });
-}
-function* getNodesSimple(snapshot, path, options) {
-  const {
-    match,
-    reverse = !1
-  } = options, children = getChildren(snapshot, path), entries = reverse ? [...children].reverse() : children;
-  for (const entry of entries)
-    (!match || match(entry.node, entry.path)) && (yield entry), yield* getNodesSimple(snapshot, entry.path, options);
-}
-function comparePathsInTree(snapshot, pathA, pathB) {
-  const minLength = Math.min(pathA.length, pathB.length), prefix = [];
-  for (let i = 0; i < minLength; i++) {
-    const segA = pathA[i], segB = pathB[i];
-    if (typeof segA == "string" || typeof segB == "string" || typeof segA == "number" || typeof segB == "number" || Array.isArray(segA) || Array.isArray(segB)) {
-      prefix.push(segA);
-      continue;
-    }
-    if (segA._key === segB._key) {
-      prefix.push(segA);
-      continue;
-    }
-    const indexA = snapshot.blockIndexMap.get(serializePath([...prefix, segA])) ?? -1, indexB = snapshot.blockIndexMap.get(serializePath([...prefix, segB])) ?? -1;
-    return indexA < indexB ? -1 : indexA > indexB ? 1 : 0;
-  }
-  return pathA.length < pathB.length ? -1 : pathA.length > pathB.length ? 1 : 0;
-}
-function* getNodesInRange(snapshot, path, options) {
-  const {
-    from,
-    to,
-    match,
-    reverse = !1
-  } = options, children = getChildren(snapshot, path), startIndex = from === void 0 ? 0 : boundaryChildIndex(snapshot, children, from) ?? 0, endIndex = to === void 0 ? children.length - 1 : boundaryChildIndex(snapshot, children, to) ?? children.length - 1, window = children.slice(startIndex, endIndex + 1), entries = reverse ? window.reverse() : window;
-  for (const entry of entries) {
-    if (canStopTraversal(snapshot, entry.path, from, to, reverse))
-      return;
-    couldContainInRangeNodes(snapshot, entry.path, from, to) && (isInRange(snapshot, entry.path, from, to) && (!match || match(entry.node, entry.path)) && (yield entry), yield* getNodesInRange(snapshot, entry.path, options));
-  }
-}
-function boundaryChildIndex(snapshot, children, boundary) {
-  const firstChild = children[0];
-  if (!firstChild)
-    return;
-  const childPathLength = firstChild.path.length;
-  if (boundary.length < childPathLength)
-    return;
-  const sharedPrefix = firstChild.path.slice(0, -1);
-  if (sharedPrefix.length > 0 && !isAncestorPath(sharedPrefix, boundary))
-    return;
-  const resolvedIndex = resolveChildEntryIndex(snapshot.blockIndexMap, children, boundary.slice(0, childPathLength));
-  return resolvedIndex === -1 ? void 0 : resolvedIndex;
-}
-function isInRange(snapshot, nodePath, from, to) {
-  return !(from !== void 0 && comparePathsInTree(snapshot, nodePath, from) === -1 && !isAncestorPath(nodePath, from) || to !== void 0 && comparePathsInTree(snapshot, nodePath, to) === 1 && !isAncestorPath(nodePath, to));
-}
-function couldContainInRangeNodes(snapshot, nodePath, from, to) {
-  return !!(isInRange(snapshot, nodePath, from, to) || from !== void 0 && isAncestorPath(nodePath, from) || to !== void 0 && isAncestorPath(nodePath, to));
-}
-function canStopTraversal(snapshot, nodePath, from, to, reverse) {
-  return reverse ? from === void 0 ? !1 : comparePathsInTree(snapshot, nodePath, from) === -1 && !isAncestorPath(nodePath, from) : to === void 0 ? !1 : comparePathsInTree(snapshot, nodePath, to) === 1;
-}
-function getSibling(snapshot, path, options) {
-  const {
-    direction,
-    match
-  } = options;
-  if (path.length === 0)
-    return;
-  const parent = parentPath(path), children = getChildren(snapshot, parent), currentIndex = resolveChildEntryIndex(snapshot.blockIndexMap, children, path);
-  if (currentIndex !== -1) {
-    if (!match) {
-      const siblingIndex = direction === "next" ? currentIndex + 1 : currentIndex - 1;
-      return siblingIndex < 0 || siblingIndex >= children.length ? void 0 : children[siblingIndex];
-    }
-    return (direction === "next" ? children.slice(currentIndex + 1) : children.slice(0, currentIndex).reverse()).find((child) => match(child.node, child.path));
-  }
-}
-function isSpanNode(context, node) {
-  return isTypedObject(node) && node._type === context.schema.span.name;
-}
-function isBlock(snapshot, path) {
-  const parent = getParent(snapshot, path);
-  return parent ? !isTextBlockNode({
-    schema: snapshot.context.schema
-  }, parent.node) : !0;
-}
-function getBlock(snapshot, path) {
-  const entry = getNode(snapshot, path);
-  if (entry && isBlock(snapshot, path) && !isSpanNode({
-    schema: snapshot.context.schema
-  }, entry.node))
-    return {
-      node: entry.node,
-      path: entry.path
-    };
-}
-function isInline(snapshot, path) {
-  return !isBlock(snapshot, path);
-}
-function getEnclosingBlock(snapshot, path, options) {
-  const match = options?.match;
-  if ((options?.mode ?? "lowest") === "highest") {
-    const ancestors = getAncestors(snapshot, path);
-    for (const ancestor of [...ancestors].reverse())
-      if (!match || match(ancestor.node, ancestor.path))
-        return ancestor;
-    const direct2 = getBlock(snapshot, path);
-    return direct2 && (!match || match(direct2.node, direct2.path)) ? direct2 : void 0;
-  }
-  const direct = getBlock(snapshot, path);
-  if (direct && (!match || match(direct.node, direct.path)))
-    return direct;
-  for (const ancestor of getAncestors(snapshot, path))
-    if (!match || match(ancestor.node, ancestor.path))
-      return ancestor;
-}
-function comparePoints(snapshot, pointA, pointB) {
-  const pathComparison = comparePaths(pointA.path, pointB.path, {
-    value: snapshot.context.value
-  });
-  return pathComparison !== 0 ? pathComparison : pointA.offset < pointB.offset ? -1 : pointA.offset > pointB.offset ? 1 : 0;
-}
-function descendToParent(snapshot, path) {
-  const ancestors = getAncestors(snapshot, path);
-  for (const ancestor of ancestors) {
-    if (!isObject(snapshot, ancestor.node))
-      continue;
-    const resolved = resolveContainerAt(snapshot.context.containers, snapshot.context.value, ancestor.path);
-    return !resolved || !("field" in resolved) ? void 0 : {
-      parent: resolved,
-      parentPath: ancestor.path
-    };
-  }
-}
-function getEnclosingContainer(snapshot, path) {
-  const descent = descendToParent(snapshot, path);
-  if (descent)
-    return {
-      of: descent.parent.field.of,
-      path: descent.parentPath
-    };
-}
-function getPathSubSchema(snapshot, path) {
-  const enclosing = getEnclosingContainer(snapshot, path);
-  return enclosing ? getSubSchema(snapshot.context.schema, enclosing.of) : snapshot.context.schema;
-}
-export {
-  comparePaths,
-  comparePoints,
-  comparePoints$1,
-  getAncestors,
-  getBlock,
-  getEnclosingBlock,
-  getEnclosingContainer,
-  getNodes,
-  getPathSubSchema,
-  getSibling,
-  hasNode,
-  isAfterPoint,
-  isAncestorPath,
-  isBackwardRange,
-  isBlock,
-  isEditableContainer,
-  isInline,
-  isObject,
-  isSpanNode,
-  isTextBlockNode,
-  rangeEdges,
-  resolveChildEntryIndex,
-  resolveContainerAt
-};
-//# sourceMappingURL=get-path-sub-schema.js.map