@portabletext/editor 7.3.2 → 7.3.3

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

@@ -1 +1 @@
-{"version":3,"file":"get-path-sub-schema.js","sources":["../../src/traversal/get-ancestors.ts","../../src/traversal/has-node.ts","../../src/schema/resolve-container-at.ts","../../src/schema/is-editable-container.ts","../../src/traversal/is-object.ts","../../src/engine/path/compare-paths.ts","../../src/engine/point/compare-points.ts","../../src/engine/point/is-after-point.ts","../../src/engine/range/is-backward-range.ts","../../src/engine/range/range-edges.ts","../../src/engine/node/is-text-block-node.ts","../../src/engine/path/is-ancestor-path.ts","../../src/traversal/get-nodes.ts","../../src/traversal/get-sibling.ts","../../src/engine/node/is-span-node.ts","../../src/traversal/is-block.ts","../../src/traversal/is-inline.ts","../../src/traversal/get-enclosing-block.ts","../../src/traversal/compare-points.ts","../../src/schema/descend-to-parent.ts","../../src/schema/get-enclosing-container.ts","../../src/traversal/get-path-sub-schema.ts"],"sourcesContent":["import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport {getNodeChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get all ancestors of the node at a given path, from nearest to furthest.\n *\n * For a path like [{_key:'t1'}, 'rows', {_key:'r1'}, 'cells', {_key:'c1'}],\n * the ancestors are (nearest first):\n *   [{_key:'t1'}, 'rows', {_key:'r1'}]\n *   [{_key:'t1'}]\n *\n * Walks from root to the target in a single pass collecting each ancestor\n * as it goes.\n *\n * Every ancestor is a `PortableTextBlock` — only text blocks and object\n * nodes can contain children.\n *\n * @beta\n */\nexport function getAncestors(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): Array<{node: PortableTextBlock; path: Path}> {\n  // Collect keyed-segment indices to know where each ancestor's path ends.\n  const keyedIndices: Array<number> = []\n  for (let i = 0; i < path.length; i++) {\n    if (isKeyedSegment(path[i])) {\n      keyedIndices.push(i)\n    }\n  }\n\n  // Need at least 2 keyed segments to have an ancestor (the last is self).\n  if (keyedIndices.length <= 1) {\n    return []\n  }\n\n  const {context, blockIndexMap} = snapshot\n  let currentChildren: Array<Node> = context.value\n  let isRootLevel = true\n  let currentParent:\n    | import('../schema/resolve-containers').RegisteredContainer\n    | undefined\n\n  const ancestorsByDepth: Array<{node: PortableTextBlock; path: Path}> = []\n  const resolvedPath: Path = []\n\n  // Descend once. We walk only as far as the second-to-last keyed segment;\n  // the last keyed segment is the target itself, which is not an ancestor.\n  const targetKeyedIndex = keyedIndices[keyedIndices.length - 1]!\n\n  let segmentIndex = 0\n  while (segmentIndex < targetKeyedIndex) {\n    const segment = path[segmentIndex]!\n\n    if (typeof segment === 'string') {\n      resolvedPath.push(segment)\n      segmentIndex++\n      continue\n    }\n\n    let node: Node | undefined\n    if (isKeyedSegment(segment)) {\n      // Production snapshots maintain `blockIndexMap` in lockstep with\n      // `context.value` so this fast path always fires. Some test\n      // fixtures still pass empty or stale maps, which is the debt this\n      // size check is working around - see /specs/snapshot-invariants.md.\n      // When the fixtures are aligned, drop the guard and use the map\n      // directly.\n      if (isRootLevel && blockIndexMap.size === currentChildren.length) {\n        const index = blockIndexMap.get(segment._key)\n        node =\n          index !== undefined\n            ? currentChildren[index]\n            : currentChildren.find((child) => child._key === segment._key)\n      } else {\n        node = currentChildren.find((child) => child._key === segment._key)\n      }\n      resolvedPath.push(segment)\n      isRootLevel = false\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 []\n    }\n\n    if (!node) {\n      return []\n    }\n\n    // Descend with positional awareness. `getNodeChildren` checks the\n    // current parent's `of` for a positional override before falling\n    // back to the top-level `containers` map - so same-`_type`\n    // registered under different parents with different `field`\n    // resolves to the right entry at this position.\n    const next = getNodeChildren(context, node, currentParent)\n    if (!next) {\n      return []\n    }\n\n    // An ancestor has children, so it is never a span. The narrowing\n    // from `Node` to `PortableTextBlock` (text block | object) is safe.\n    ancestorsByDepth.push({\n      node: node as PortableTextBlock,\n      path: resolvedPath.slice(),\n    })\n\n    currentChildren = next.children\n    currentParent = next.parent\n    segmentIndex++\n  }\n\n  // Return nearest-first (reverse of document order at the call site).\n  return ancestorsByDepth.reverse()\n}\n","import type {Path} from '../engine/interfaces/path'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Check if a node exists at a given path.\n *\n * @beta\n */\nexport function hasNode(snapshot: TraversalSnapshot, path: Path): boolean {\n  return getNode(snapshot, path) !== undefined\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport type {\n  Containers,\n  RegisteredContainer,\n  RegisteredPositional,\n} from './container-types'\n\n/**\n * Walk the editor value following `path` and return the\n * {@link RegisteredContainer} or {@link RegisteredPositional} that applies\n * at `path`'s target position.\n *\n * Resolution rules at each step:\n *\n * 1. **Positional override.** If the current parent declares the\n *    child's `_type` in its `of`, the positional entry wins.\n *    Used to resolve same-`_type` registered under different\n *    parents with different `field` values.\n *\n * 2. **Global fallback.** If the parent has no positional override,\n *    fall back to the top-level entry for `_type` in\n *    `containers`.\n *\n * 3. **Chain validity.** If any ancestor along the path has no\n *    resolved container entry (unregistered or not reachable as a\n *    container at its position), return `undefined`.\n *\n * Returns `undefined` when the target's `_type` is not registered\n * at this position. Returns a {@link RegisteredPositional} when the target\n * resolves to a leaf in a positional `of` (terminal node with no\n * editable children).\n *\n * @alpha\n */\nexport function resolveContainerAt(\n  containers: Containers,\n  value: ReadonlyArray<Node>,\n  path: Path,\n): RegisteredContainer | RegisteredPositional | undefined {\n  const keyedIndices: Array<number> = []\n  for (let index = 0; index < path.length; index++) {\n    if (isKeyedSegment(path[index])) {\n      keyedIndices.push(index)\n    }\n  }\n  if (keyedIndices.length === 0) {\n    return undefined\n  }\n\n  let currentChildren: ReadonlyArray<Node> = value\n  let parent: RegisteredContainer | undefined\n  let resolved: RegisteredContainer | RegisteredPositional | undefined\n  const targetKeyedIndex = keyedIndices[keyedIndices.length - 1]!\n\n  let segmentIndex = 0\n  while (segmentIndex <= targetKeyedIndex) {\n    const segment = path[segmentIndex]!\n    if (typeof segment === 'string') {\n      segmentIndex++\n      continue\n    }\n\n    let node: Node | undefined\n    if (isKeyedSegment(segment)) {\n      node = currentChildren.find((child) => child._key === segment._key)\n    } else if (typeof segment === 'number') {\n      node = currentChildren.at(segment)\n    } else {\n      return undefined\n    }\n    if (!node) {\n      return undefined\n    }\n\n    resolved = resolveNodeEntry(containers, parent, node)\n    if (!resolved) {\n      return undefined\n    }\n\n    if (segmentIndex < targetKeyedIndex) {\n      // Walk one more level. The resolved entry must be a container\n      // (have children) for descent to continue.\n      if (!('field' in resolved)) {\n        return undefined\n      }\n      const fieldValue = (node as Record<string, unknown>)[resolved.field.name]\n      if (!Array.isArray(fieldValue)) {\n        return undefined\n      }\n      parent = resolved\n      currentChildren = fieldValue as Array<Node>\n    }\n    segmentIndex++\n  }\n\n  return resolved\n}\n\nfunction resolveNodeEntry(\n  containers: Containers,\n  parent: RegisteredContainer | undefined,\n  node: Node,\n): RegisteredContainer | RegisteredPositional | undefined {\n  if (parent?.of) {\n    for (const entry of parent.of) {\n      if (entry.type === node._type) {\n        return entry\n      }\n    }\n  }\n  return containers.get(node._type)\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport type {TraversalSnapshot} from '../traversal/traversal-snapshot'\nimport {resolveContainerAt} from './resolve-container-at'\n\n/**\n * Check if a node at the given path is a registered editable container.\n *\n * Position-aware: {@link resolveContainerAt} descends from the editor\n * root threading the resolved parent at each step, so positionally-\n * registered containers (e.g. `cell` registered only inside\n * `table.of`) are recognized when reached through their declared\n * parent.\n */\nexport function isEditableContainer(\n  snapshot: TraversalSnapshot,\n  _node: Node,\n  path: Path,\n): boolean {\n  if (snapshot.context.containers.size === 0) {\n    return false\n  }\n\n  // `resolveContainerAt` aborts on the first unregistered object-node\n  // ancestor (chain validity falls out of the single descent), so the\n  // single call below answers both \"is the node here a container?\" and\n  // \"is the ancestor chain valid?\" in one walk.\n  const resolved = resolveContainerAt(\n    snapshot.context.containers,\n    snapshot.context.value,\n    path,\n  )\n  return !!(resolved && 'field' in resolved)\n}\n","import type {PortableTextObject} from '@portabletext/schema'\nimport {isTypedObject} from '../utils/asserters'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Check if a node is an object node (not a text block or span).\n *\n * @beta\n */\nexport function isObject(\n  snapshot: TraversalSnapshot,\n  node: unknown,\n): node is PortableTextObject {\n  return (\n    isTypedObject(node) &&\n    node._type !== snapshot.context.schema.block.name &&\n    node._type !== snapshot.context.schema.span.name\n  )\n}\n","import {isKeyedSegment} from '../../utils/util.is-keyed-segment'\nimport type {Node} from '../interfaces/node'\nimport type {Path} from '../interfaces/path'\n\n/**\n * Compare two paths in document order.\n *\n * When paths contain keyed segments, the root node tree is needed to\n * resolve document order. Without a root, keyed segments are compared\n * by _key string (consistent but not necessarily document order).\n */\nexport function comparePaths(\n  path: Path,\n  another: Path,\n  root: {value: Array<Node>},\n): -1 | 0 | 1 {\n  const min = Math.min(path.length, another.length)\n  let currentChildren: Array<Node> | undefined = root?.value\n  let currentNode: Node | undefined\n\n  for (let i = 0; i < min; i++) {\n    const segment = path[i]!\n    const otherSegment = another[i]!\n\n    if (isKeyedSegment(segment) && isKeyedSegment(otherSegment)) {\n      if (segment._key === otherSegment._key) {\n        if (currentChildren) {\n          currentNode = currentChildren.find((c) => c._key === segment._key)\n          currentChildren = undefined\n        }\n        continue\n      }\n\n      if (currentChildren) {\n        const segmentIndex = currentChildren.findIndex(\n          (c) => c._key === segment._key,\n        )\n        const otherSegmentIndex = currentChildren.findIndex(\n          (c) => c._key === otherSegment._key,\n        )\n        if (segmentIndex !== -1 && otherSegmentIndex !== -1) {\n          return segmentIndex < otherSegmentIndex ? -1 : 1\n        }\n      }\n\n      // Fallback: compare by _key string\n      if (segment._key < otherSegment._key) {\n        return -1\n      }\n      if (segment._key > otherSegment._key) {\n        return 1\n      }\n      continue\n    }\n\n    if (typeof segment === 'string' && typeof otherSegment === 'string') {\n      if (segment === otherSegment) {\n        if (currentNode) {\n          const fieldValue = (currentNode as Record<string, unknown>)[segment]\n          currentChildren = Array.isArray(fieldValue)\n            ? (fieldValue as Array<Node>)\n            : undefined\n          currentNode = undefined\n        }\n        continue\n      }\n      if (segment < otherSegment) {\n        return -1\n      }\n      if (segment > otherSegment) {\n        return 1\n      }\n      continue\n    }\n\n    if (typeof segment === 'number' && typeof otherSegment === 'number') {\n      if (segment < otherSegment) {\n        return -1\n      }\n      if (segment > otherSegment) {\n        return 1\n      }\n      continue\n    }\n\n    break\n  }\n\n  return 0\n}\n","import type {Node} from '../interfaces/node'\nimport type {Point} from '../interfaces/point'\nimport {comparePaths} from '../path/compare-paths'\n\nexport function comparePoints(\n  point: Point,\n  another: Point,\n  root: {value: Array<Node>},\n): -1 | 0 | 1 {\n  const result = comparePaths(point.path, another.path, root)\n  if (result === 0) {\n    if (point.offset < another.offset) {\n      return -1\n    }\n    if (point.offset > another.offset) {\n      return 1\n    }\n    return 0\n  }\n  return result\n}\n","import type {Node} from '../interfaces/node'\nimport type {Point} from '../interfaces/point'\nimport {comparePoints} from './compare-points'\n\nexport function isAfterPoint(\n  point: Point,\n  another: Point,\n  root: {value: Array<Node>},\n): boolean {\n  return comparePoints(point, another, root) === 1\n}\n","import type {Node} from '../interfaces/node'\nimport type {Range} from '../interfaces/range'\nimport {isAfterPoint} from '../point/is-after-point'\n\nexport function isBackwardRange(\n  range: Range,\n  root: {value: Array<Node>},\n): boolean {\n  const {anchor, focus} = range\n  return isAfterPoint(anchor, focus, root)\n}\n","import type {Node} from '../interfaces/node'\nimport type {Point} from '../interfaces/point'\nimport type {Range} from '../interfaces/range'\nimport {isBackwardRange} from './is-backward-range'\n\nexport function rangeEdges(\n  range: Range,\n  root: {value: Array<Node>},\n): [Point, Point] {\n  const {anchor, focus} = range\n  return isBackwardRange(range, root) ? [focus, anchor] : [anchor, focus]\n}\n","import type {PortableTextObject, PortableTextSpan} from '@portabletext/schema'\nimport type {EditorSchema} from '../../editor/editor-schema'\nimport {isTypedObject} from '../../utils/asserters'\n\ntype TextBlockNode = {\n  _type: string\n  _key: string\n  children?: Array<PortableTextSpan | PortableTextObject>\n  markDefs?: Array<PortableTextObject>\n  style?: string\n  listItem?: string\n  level?: number\n}\n\n/**\n * Checks if a node is a text block based on `_type` alone, without requiring\n * `children` to be present. This is needed to identify text blocks before\n * normalization has had a chance to add the missing `children` property.\n */\nexport function isTextBlockNode(\n  context: {schema: EditorSchema},\n  node: unknown,\n): node is TextBlockNode {\n  return isTypedObject(node) && node._type === context.schema.block.name\n}\n","import {isKeyedSegment} from '../../utils/util.is-keyed-segment'\nimport type {Path} from '../interfaces/path'\n\nexport function isAncestorPath(path: Path, another: Path): boolean {\n  if (path.length >= another.length) {\n    return false\n  }\n\n  for (let i = 0; i < path.length; i++) {\n    const segment = path[i]\n    const otherSegment = another[i]\n\n    if (isKeyedSegment(segment) && isKeyedSegment(otherSegment)) {\n      if (segment._key !== otherSegment._key) {\n        return false\n      }\n    } else if (segment !== otherSegment) {\n      return false\n    }\n  }\n\n  return true\n}\n","import type {EditorSchema} from '../editor/editor-schema'\nimport type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {isAncestorPath} from '../engine/path/is-ancestor-path'\nimport type {\n  Containers,\n  RegisteredContainer,\n} from '../schema/resolve-containers'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport {getChildren, getNodeChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the descendant nodes of the node at a given path.\n *\n * When `from` and `to` are provided, performs a range-bounded DFS traversal,\n * yielding only nodes between `from` and `to` (inclusive). Both paths are\n * always in document order: `from` is the earlier path, `to` is the later\n * path. The `reverse` flag controls iteration direction within that range.\n *\n * When `match` is provided, only yields nodes where the predicate returns true.\n * The traversal still visits all nodes in range - `match` is a filter, not a\n * traversal control.\n *\n * When `at` is provided, traverses descendants of the node at that path\n * instead of the root.\n */\nexport function* getNodes(\n  snapshot: TraversalSnapshot,\n  options: {\n    at?: Path\n    from?: Path\n    to?: Path\n    match?: (node: Node, path: Path) => boolean\n    reverse?: boolean\n  } = {},\n): Generator<{node: Node; path: Path}, void, undefined> {\n  const {at = [], from, to, match, reverse = false} = options\n\n  if (from === undefined && to === undefined) {\n    yield* getNodesSimple(snapshot, at, {match, reverse})\n    return\n  }\n\n  yield* getNodesInRange(snapshot, at, {from, to, match, reverse})\n}\n\n/**\n * Get descendant nodes of a standalone node (not in the editor tree).\n * Used for cases like getDirtyPaths where the node hasn't been inserted yet.\n */\nexport function* getNodeDescendants(\n  context: {\n    schema: EditorSchema\n    containers: Containers\n  },\n  node: Node | {value: Array<Node>},\n): Generator<{node: Node; path: Path}, void, undefined> {\n  // The editor root wrapper ({value: [...]}) is not a real node, so its field\n  // name is not part of paths. For standalone nodes (a real {_key, _type, ...}\n  // passed in by callers like getDirtyPaths), the field name IS part of the\n  // path.\n  const isRoot = !('_key' in node) && !('_type' in node)\n  yield* walkStandalone(context, node, [], isRoot)\n}\n\nfunction* walkStandalone(\n  context: {\n    schema: EditorSchema\n    containers: Containers\n  },\n  node: Node | {value: Array<Node>},\n  path: Path,\n  isRoot: boolean,\n  parent?: RegisteredContainer,\n): Generator<{node: Node; path: Path}, void, undefined> {\n  const next = getNodeChildren(context, node, parent)\n  if (!next) {\n    return\n  }\n\n  for (const child of next.children) {\n    const childPath: Path = isRoot\n      ? [{_key: child._key}]\n      : [...path, next.fieldName, {_key: child._key}]\n    yield {node: child, path: childPath}\n    yield* walkStandalone(context, child, childPath, false, next.parent)\n  }\n}\n\n/**\n * Simple recursive DFS - the original behavior.\n * Yields all descendants of the node at `path`.\n */\nfunction* getNodesSimple(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    match?: (node: Node, path: Path) => boolean\n    reverse?: boolean\n  },\n): Generator<{node: Node; path: Path}, void, undefined> {\n  const {match, reverse = false} = options\n\n  const children = getChildren(snapshot, path)\n\n  const entries = reverse ? [...children].reverse() : children\n\n  for (const entry of entries) {\n    if (!match || match(entry.node, entry.path)) {\n      yield entry\n    }\n\n    yield* getNodesSimple(snapshot, entry.path, options)\n  }\n}\n\n/**\n * Compare two keyed paths in document order. Returns -1, 0, or 1.\n *\n * Descends both paths from the root in a single pass, advancing\n * `currentNode` and `currentChildren` together so each level costs\n * one keyed-segment scan instead of an O(depth) walk from root.\n *\n * Uses `blockIndexMap` for O(1) lookup at the root level. Deeper\n * levels fall back to a linear scan of the current sibling array.\n */\nfunction comparePathsInTree(\n  snapshot: TraversalSnapshot,\n  pathA: Path,\n  pathB: Path,\n): -1 | 0 | 1 {\n  const keysA = pathA.filter(isKeyedSegment)\n  const keysB = pathB.filter(isKeyedSegment)\n\n  const {context} = snapshot\n  let currentChildren: Array<Node> = context.value\n  let currentParent: RegisteredContainer | undefined\n  let isRootLevel = true\n\n  const minDepth = Math.min(keysA.length, keysB.length)\n\n  for (let depth = 0; depth < minDepth; depth++) {\n    const keyA = keysA[depth]!\n    const keyB = keysB[depth]!\n\n    if (keyA._key === keyB._key) {\n      // Same node at this depth: descend into its children for the next\n      // iteration. The root level can short-circuit via blockIndexMap;\n      // deeper levels scan the current sibling array.\n      let matchedNode: Node | undefined\n      if (isRootLevel && snapshot.blockIndexMap.has(keyA._key)) {\n        const index = snapshot.blockIndexMap.get(keyA._key)\n        if (index !== undefined) {\n          matchedNode = currentChildren[index]\n        }\n      } else {\n        matchedNode = currentChildren.find((c) => c._key === keyA._key)\n      }\n      if (!matchedNode) {\n        return 0\n      }\n      const next = getNodeChildren(context, matchedNode, currentParent)\n      if (!next) {\n        return 0\n      }\n      currentChildren = next.children\n      currentParent = next.parent\n\n      isRootLevel = false\n      continue\n    }\n\n    if (isRootLevel) {\n      const indexA = snapshot.blockIndexMap.get(keyA._key) ?? -1\n      const indexB = snapshot.blockIndexMap.get(keyB._key) ?? -1\n      if (indexA !== -1 && indexB !== -1) {\n        if (indexA < indexB) {\n          return -1\n        }\n        if (indexA > indexB) {\n          return 1\n        }\n        return 0\n      }\n    }\n\n    let indexA = -1\n    let indexB = -1\n    for (let i = 0; i < currentChildren.length; i++) {\n      const sibling = currentChildren[i]!\n      if (sibling._key === keyA._key) {\n        indexA = i\n      }\n      if (sibling._key === keyB._key) {\n        indexB = i\n      }\n      if (indexA !== -1 && indexB !== -1) {\n        break\n      }\n    }\n\n    if (indexA < indexB) {\n      return -1\n    }\n    if (indexA > indexB) {\n      return 1\n    }\n\n    return 0\n  }\n\n  // One path is a prefix of the other (ancestor relationship)\n  // In DFS order, shorter path (ancestor) comes first\n  if (keysA.length < keysB.length) {\n    return -1\n  }\n  if (keysA.length > keysB.length) {\n    return 1\n  }\n\n  return 0\n}\n\n/**\n * Range-bounded recursive DFS traversal.\n *\n * `from` and `to` are always in document order (from is earlier, to is\n * later), regardless of traversal direction.\n */\nfunction* getNodesInRange(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    from?: Path\n    to?: Path\n    match?: (node: Node, path: Path) => boolean\n    reverse?: boolean\n  },\n): Generator<{node: Node; path: Path}, void, undefined> {\n  const {from, to, match, reverse = false} = options\n\n  const children = getChildren(snapshot, path)\n  const entries = reverse ? [...children].reverse() : children\n\n  for (const entry of entries) {\n    if (canStopTraversal(snapshot, entry.path, from, to, reverse)) {\n      return\n    }\n\n    if (!couldContainInRangeNodes(snapshot, entry.path, from, to)) {\n      continue\n    }\n\n    if (isInRange(snapshot, entry.path, from, to)) {\n      if (!match || match(entry.node, entry.path)) {\n        yield entry\n      }\n    }\n\n    yield* getNodesInRange(snapshot, entry.path, options)\n  }\n}\n\n/**\n * Check if a node is within the [from, to] range in document order.\n * Both bounds are inclusive. Ancestor nodes of from or to are also\n * considered in range since they contain the range boundary.\n */\nfunction isInRange(\n  snapshot: TraversalSnapshot,\n  nodePath: Path,\n  from: Path | undefined,\n  to: Path | undefined,\n): boolean {\n  if (\n    from !== undefined &&\n    comparePathsInTree(snapshot, nodePath, from) === -1\n  ) {\n    if (!isAncestorPath(nodePath, from)) {\n      return false\n    }\n  }\n\n  if (to !== undefined && comparePathsInTree(snapshot, nodePath, to) === 1) {\n    if (!isAncestorPath(nodePath, to)) {\n      return false\n    }\n  }\n\n  return true\n}\n\n/**\n * Check if a subtree rooted at `nodePath` could contain any nodes in the\n * [from, to] range.\n */\nfunction couldContainInRangeNodes(\n  snapshot: TraversalSnapshot,\n  nodePath: Path,\n  from: Path | undefined,\n  to: Path | undefined,\n): boolean {\n  if (isInRange(snapshot, nodePath, from, to)) {\n    return true\n  }\n\n  if (from !== undefined && isAncestorPath(nodePath, from)) {\n    return true\n  }\n\n  if (to !== undefined && isAncestorPath(nodePath, to)) {\n    return true\n  }\n\n  return false\n}\n\n/**\n * Check if all remaining nodes in iteration order will be outside the range.\n */\nfunction canStopTraversal(\n  snapshot: TraversalSnapshot,\n  nodePath: Path,\n  from: Path | undefined,\n  to: Path | undefined,\n  reverse: boolean,\n): boolean {\n  if (reverse) {\n    if (from === undefined) {\n      return false\n    }\n\n    return (\n      comparePathsInTree(snapshot, nodePath, from) === -1 &&\n      !isAncestorPath(nodePath, from)\n    )\n  }\n\n  if (to === undefined) {\n    return false\n  }\n\n  return comparePathsInTree(snapshot, nodePath, to) === 1\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {parentPath} from '../engine/path/parent-path'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport {getChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get a sibling of the node at a given path.\n *\n * Without `match`, returns the immediate next or previous sibling.\n * With `match`, returns the first sibling in `direction` that satisfies\n * the predicate.\n *\n * When `match` is a type predicate, the returned `node` narrows to that type.\n *\n * @beta\n */\nexport function getSibling<TMatch extends Node>(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    direction: 'next' | 'previous'\n    match: (node: Node, path: Path) => node is TMatch\n  },\n): {node: TMatch; path: Path} | undefined\n/**\n * @beta\n */\nexport function getSibling(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    direction: 'next' | 'previous'\n    match?: (node: Node, path: Path) => boolean\n  },\n): {node: Node; path: Path} | undefined\nexport function getSibling(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    direction: 'next' | 'previous'\n    match?: (node: Node, path: Path) => boolean\n  },\n): {node: Node; path: Path} | undefined {\n  const {direction, match} = options\n\n  if (path.length === 0) {\n    return undefined\n  }\n\n  const lastSegment = path.at(-1)\n\n  if (!isKeyedSegment(lastSegment)) {\n    return undefined\n  }\n\n  const parent = parentPath(path)\n  const children = getChildren(snapshot, parent)\n\n  const currentIndex = children.findIndex(\n    (child) => child.node._key === lastSegment._key,\n  )\n\n  if (currentIndex === -1) {\n    return undefined\n  }\n\n  if (!match) {\n    const siblingIndex =\n      direction === 'next' ? currentIndex + 1 : currentIndex - 1\n\n    if (siblingIndex < 0 || siblingIndex >= children.length) {\n      return undefined\n    }\n\n    return children[siblingIndex]\n  }\n\n  const candidates =\n    direction === 'next'\n      ? children.slice(currentIndex + 1)\n      : children.slice(0, currentIndex).reverse()\n\n  return candidates.find((child) => match(child.node, child.path))\n}\n","import type {EditorSchema} from '../../editor/editor-schema'\nimport {isTypedObject} from '../../utils/asserters'\n\nexport type SpanNode = {\n  _type: string\n  _key: string\n  text?: string\n  marks?: Array<string>\n}\n\n/**\n * Checks if a node is a span based on `_type` alone, without requiring `text`\n * to be present. This is needed to identify spans before normalization has had\n * a chance to add the missing `text` property.\n */\nexport function isSpanNode(\n  context: {schema: EditorSchema},\n  node: unknown,\n): node is SpanNode {\n  return isTypedObject(node) && node._type === context.schema.span.name\n}\n","import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {isSpanNode} from '../engine/node/is-span-node'\nimport {isTextBlockNode} from '../engine/node/is-text-block-node'\nimport {getNode} from './get-node'\nimport {getParent} from './get-parent'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Determine if a node at the given path is a block.\n *\n * A node is a block if its parent is not a text block. Top-level nodes\n * (direct children of the editor) are always blocks. Children of text blocks\n * (spans and inline objects) are not blocks. Children of containers are\n * blocks within that container.\n *\n * @beta\n */\nexport function isBlock(snapshot: TraversalSnapshot, path: Path): boolean {\n  const parent = getParent(snapshot, path)\n\n  if (!parent) {\n    return true\n  }\n\n  return !isTextBlockNode({schema: snapshot.context.schema}, parent.node)\n}\n\n/**\n * Get the node at the given path if it is a block.\n *\n * Returns the node narrowed to PortableTextBlock, or undefined if the node\n * doesn't exist or is not a block.\n *\n * @beta\n */\nexport function getBlock(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: PortableTextBlock; path: Path} | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (!isBlock(snapshot, path)) {\n    return undefined\n  }\n\n  if (isSpanNode({schema: snapshot.context.schema}, entry.node)) {\n    return undefined\n  }\n\n  return {node: entry.node, path: entry.path}\n}\n","import type {Path} from '../engine/interfaces/path'\nimport {isBlock} from './is-block'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Determine if a node at the given path is inline.\n *\n * A node is inline if its parent is a text block. This is the inverse of\n * `isBlock`. Top-level nodes are never inline.\n *\n * @beta\n */\nexport function isInline(snapshot: TraversalSnapshot, path: Path): boolean {\n  return !isBlock(snapshot, path)\n}\n","import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getAncestors} from './get-ancestors'\nimport {getBlock} from './is-block'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Walk up from a path to find the nearest enclosing block.\n *\n * Returns the node at the path if it is a block, otherwise the first ancestor\n * that is a block. Works at any depth — inside a container this returns the\n * container-internal block, not the outer container.\n *\n * With `match`, returns the first enclosing block that also satisfies the\n * predicate. When `match` is a type predicate, the returned `node` narrows\n * to that type.\n *\n * `mode: 'lowest'` (default) returns the innermost enclosing block; the node\n * at the path itself counts. `mode: 'highest'` returns the outermost\n * ancestor that matches, falling back to the node at the path only if no\n * ancestor does.\n *\n * @beta\n */\nexport function getEnclosingBlock<TMatch extends PortableTextBlock>(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    match: (node: PortableTextBlock, path: Path) => node is TMatch\n    mode?: 'lowest' | 'highest'\n  },\n): {node: TMatch; path: Path} | undefined\n/**\n * @beta\n */\nexport function getEnclosingBlock(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options?: {\n    match?: (node: PortableTextBlock, path: Path) => boolean\n    mode?: 'lowest' | 'highest'\n  },\n): {node: PortableTextBlock; path: Path} | undefined\nexport function getEnclosingBlock(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options?: {\n    match?: (node: PortableTextBlock, path: Path) => boolean\n    mode?: 'lowest' | 'highest'\n  },\n): {node: PortableTextBlock; path: Path} | undefined {\n  const match = options?.match\n  const mode = options?.mode ?? 'lowest'\n\n  if (mode === 'highest') {\n    const ancestors = getAncestors(snapshot, path)\n\n    for (const ancestor of [...ancestors].reverse()) {\n      if (!match || match(ancestor.node, ancestor.path)) {\n        return ancestor\n      }\n    }\n\n    const direct = getBlock(snapshot, path)\n\n    if (direct && (!match || match(direct.node, direct.path))) {\n      return direct\n    }\n\n    return undefined\n  }\n\n  const direct = getBlock(snapshot, path)\n\n  if (direct && (!match || match(direct.node, direct.path))) {\n    return direct\n  }\n\n  for (const ancestor of getAncestors(snapshot, path)) {\n    if (!match || match(ancestor.node, ancestor.path)) {\n      return ancestor\n    }\n  }\n\n  return undefined\n}\n","import {comparePaths} from '../engine/path/compare-paths'\nimport type {EditorSelectionPoint} from '../types/editor'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Returns:\n *\n * - `-1` if `pointA` is before `pointB`\n * - `0` if `pointA` and `pointB` are equal\n * - `1` if `pointA` is after `pointB`.\n *\n * Compares the two points by document order, resolved at any depth. When\n * the paths are equal, compares offsets.\n *\n * @beta\n */\nexport function comparePoints(\n  snapshot: TraversalSnapshot,\n  pointA: EditorSelectionPoint,\n  pointB: EditorSelectionPoint,\n): -1 | 0 | 1 {\n  const pathComparison = comparePaths(pointA.path, pointB.path, {\n    value: snapshot.context.value,\n  })\n\n  if (pathComparison !== 0) {\n    return pathComparison\n  }\n\n  if (pointA.offset < pointB.offset) {\n    return -1\n  }\n\n  if (pointA.offset > pointB.offset) {\n    return 1\n  }\n\n  return 0\n}\n","import type {Path} from '../engine/interfaces/path'\nimport {getAncestors} from '../traversal/get-ancestors'\nimport {isObject} from '../traversal/is-object'\nimport type {TraversalSnapshot} from '../traversal/traversal-snapshot'\nimport type {RegisteredContainer} from './container-types'\nimport {resolveContainerAt} from './resolve-container-at'\n\n/**\n * Descent primitive: return the immediate parent\n * {@link RegisteredContainer} of the node at `path` (and that parent's\n * path), or `undefined` when the target's immediate parent is the\n * editor root, when no object-node ancestor is a registered container,\n * or when descent hits an ancestor whose `_type` is not registered.\n *\n * Walks ancestors and resolves each object-node ancestor positionally\n * via {@link resolveContainerAt}. Text-block and span ancestors are\n * skipped - \"container\" here means the enclosing object container,\n * not the text-block holding spans.\n */\nexport function descendToParent(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {parent: RegisteredContainer; parentPath: Path} | undefined {\n  const ancestors = getAncestors(snapshot, path)\n  for (const ancestor of ancestors) {\n    if (!isObject(snapshot, ancestor.node)) {\n      continue\n    }\n    const resolved = resolveContainerAt(\n      snapshot.context.containers,\n      snapshot.context.value,\n      ancestor.path,\n    )\n    if (!resolved || !('field' in resolved)) {\n      return undefined\n    }\n    return {parent: resolved, parentPath: ancestor.path}\n  }\n  return undefined\n}\n","import type {OfDefinition} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport type {TraversalSnapshot} from '../traversal/traversal-snapshot'\nimport {descendToParent} from './descend-to-parent'\n\n/**\n * Return the immediate registered-container ancestor of `path` along\n * with its `of` array (the schema definitions accepted at this position).\n *\n * Position-aware: nested-only registrations (e.g. `cell` registered\n * only inside `table.row.of`) are recognized via the same descent\n * primitive used by all parent-aware traversal.\n *\n * Returns `undefined` when `path` has no registered-container ancestor\n * (i.e. is at the document root) or when descent hits a leaf-resolved\n * ancestor.\n */\nexport function getEnclosingContainer(\n  snapshot: TraversalSnapshot,\n  path: Path,\n):\n  | {\n      of: ReadonlyArray<OfDefinition>\n      path: Path\n    }\n  | undefined {\n  const descent = descendToParent(snapshot, path)\n  if (!descent) {\n    return undefined\n  }\n  return {\n    of: descent.parent.field.of,\n    path: descent.parentPath,\n  }\n}\n","import {getSubSchema, type Schema} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getEnclosingContainer} from '../schema/get-enclosing-container'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Return the `Schema` view that applies at a given path.\n *\n * For paths at the root of the document, or for paths where no ancestor is\n * a registered container, returns the top-level schema. For paths inside a\n * container, walks ancestors to find the nearest container and returns the\n * sub-schema derived from its `of` declaration.\n *\n * @beta\n */\nexport function getPathSubSchema(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): Schema {\n  const enclosing = getEnclosingContainer(snapshot, path)\n\n  if (!enclosing) {\n    return snapshot.context.schema\n  }\n\n  return getSubSchema(snapshot.context.schema, enclosing.of)\n}\n"],"names":["getAncestors","snapshot","path","keyedIndices","i","length","isKeyedSegment","push","context","blockIndexMap","currentChildren","value","isRootLevel","currentParent","ancestorsByDepth","resolvedPath","targetKeyedIndex","segmentIndex","segment","node","size","index","get","_key","undefined","find","child","at","next","getNodeChildren","slice","children","parent","reverse","hasNode","getNode","resolveContainerAt","containers","resolved","resolveNodeEntry","fieldValue","field","name","Array","isArray","of","entry","type","_type","isEditableContainer","_node","isObject","isTypedObject","schema","block","span","comparePaths","another","root","min","Math","currentNode","otherSegment","c","findIndex","otherSegmentIndex","comparePoints","point","result","offset","isAfterPoint","isBackwardRange","range","anchor","focus","rangeEdges","isTextBlockNode","isAncestorPath","getNodes","options","from","to","match","getNodesSimple","getNodesInRange","getChildren","entries","comparePathsInTree","pathA","pathB","keysA","filter","keysB","minDepth","depth","keyA","keyB","matchedNode","has","indexA","indexB","sibling","canStopTraversal","couldContainInRangeNodes","isInRange","nodePath","getSibling","direction","lastSegment","parentPath","currentIndex","siblingIndex","isSpanNode","isBlock","getParent","getBlock","isInline","getEnclosingBlock","mode","ancestors","ancestor","direct","pointA","pointB","pathComparison","descendToParent","getEnclosingContainer","descent","getPathSubSchema","enclosing","getSubSchema"],"mappings":";;AAuBO,SAASA,aACdC,UACAC,MAC8C;AAE9C,QAAMC,eAA8B,CAAA;AACpC,WAASC,IAAI,GAAGA,IAAIF,KAAKG,QAAQD;AAC3BE,mBAAeJ,KAAKE,CAAC,CAAC,KACxBD,aAAaI,KAAKH,CAAC;AAKvB,MAAID,aAAaE,UAAU;AACzB,WAAO,CAAA;AAGT,QAAM;AAAA,IAACG;AAAAA,IAASC;AAAAA,EAAAA,IAAiBR;AACjC,MAAIS,kBAA+BF,QAAQG,OACvCC,cAAc,IACdC;AAIJ,QAAMC,mBAAiE,IACjEC,eAAqB,CAAA,GAIrBC,mBAAmBb,aAAaA,aAAaE,SAAS,CAAC;AAE7D,MAAIY,eAAe;AACnB,SAAOA,eAAeD,oBAAkB;AACtC,UAAME,UAAUhB,KAAKe,YAAY;AAEjC,QAAI,OAAOC,WAAY,UAAU;AAC/BH,mBAAaR,KAAKW,OAAO,GACzBD;AACA;AAAA,IACF;AAEA,QAAIE;AACJ,QAAIb,eAAeY,OAAO,GAAG;AAO3B,UAAIN,eAAeH,cAAcW,SAASV,gBAAgBL,QAAQ;AAChE,cAAMgB,QAAQZ,cAAca,IAAIJ,QAAQK,IAAI;AAC5CJ,eACEE,UAAUG,SACNd,gBAAgBW,KAAK,IACrBX,gBAAgBe,KAAMC,CAAAA,UAAUA,MAAMH,SAASL,QAAQK,IAAI;AAAA,MACnE;AACEJ,eAAOT,gBAAgBe,KAAMC,CAAAA,UAAUA,MAAMH,SAASL,QAAQK,IAAI;AAEpER,mBAAaR,KAAKW,OAAO,GACzBN,cAAc;AAAA,IAChB,WAAW,OAAOM,WAAY;AAC5BC,aAAOT,gBAAgBiB,GAAGT,OAAO,GAC7BC,QACFJ,aAAaR,KAAK;AAAA,QAACgB,MAAMJ,KAAKI;AAAAA,MAAAA,CAAK;AAAA;AAGrC,aAAO,CAAA;AAGT,QAAI,CAACJ;AACH,aAAO,CAAA;AAQT,UAAMS,OAAOC,gBAAgBrB,SAASW,MAAMN,aAAa;AACzD,QAAI,CAACe;AACH,aAAO,CAAA;AAKTd,qBAAiBP,KAAK;AAAA,MACpBY;AAAAA,MACAjB,MAAMa,aAAae,MAAAA;AAAAA,IAAM,CAC1B,GAEDpB,kBAAkBkB,KAAKG,UACvBlB,gBAAgBe,KAAKI,QACrBf;AAAAA,EACF;AAGA,SAAOH,iBAAiBmB,QAAAA;AAC1B;AC/GO,SAASC,QAAQjC,UAA6BC,MAAqB;AACxE,SAAOiC,QAAQlC,UAAUC,IAAI,MAAMsB;AACrC;ACyBO,SAASY,mBACdC,YACA1B,OACAT,MACwD;AACxD,QAAMC,eAA8B,CAAA;AACpC,WAASkB,QAAQ,GAAGA,QAAQnB,KAAKG,QAAQgB;AACnCf,mBAAeJ,KAAKmB,KAAK,CAAC,KAC5BlB,aAAaI,KAAKc,KAAK;AAG3B,MAAIlB,aAAaE,WAAW;AAC1B;AAGF,MAAIK,kBAAuCC,OACvCqB,QACAM;AACJ,QAAMtB,mBAAmBb,aAAaA,aAAaE,SAAS,CAAC;AAE7D,MAAIY,eAAe;AACnB,SAAOA,gBAAgBD,oBAAkB;AACvC,UAAME,UAAUhB,KAAKe,YAAY;AACjC,QAAI,OAAOC,WAAY,UAAU;AAC/BD;AACA;AAAA,IACF;AAEA,QAAIE;AACJ,QAAIb,eAAeY,OAAO;AACxBC,aAAOT,gBAAgBe,KAAMC,CAAAA,UAAUA,MAAMH,SAASL,QAAQK,IAAI;AAAA,aACzD,OAAOL,WAAY;AAC5BC,aAAOT,gBAAgBiB,GAAGT,OAAO;AAAA;AAEjC;AAOF,QALI,CAACC,SAILmB,WAAWC,iBAAiBF,YAAYL,QAAQb,IAAI,GAChD,CAACmB;AACH;AAGF,QAAIrB,eAAeD,kBAAkB;AAGnC,UAAI,EAAE,WAAWsB;AACf;AAEF,YAAME,aAAcrB,KAAiCmB,SAASG,MAAMC,IAAI;AACxE,UAAI,CAACC,MAAMC,QAAQJ,UAAU;AAC3B;AAEFR,eAASM,UACT5B,kBAAkB8B;AAAAA,IACpB;AACAvB;AAAAA,EACF;AAEA,SAAOqB;AACT;AAEA,SAASC,iBACPF,YACAL,QACAb,MACwD;AACxD,MAAIa,QAAQa;AACV,eAAWC,SAASd,OAAOa;AACzB,UAAIC,MAAMC,SAAS5B,KAAK6B;AACtB,eAAOF;AAAAA;AAIb,SAAOT,WAAWf,IAAIH,KAAK6B,KAAK;AAClC;ACnGO,SAASC,oBACdhD,UACAiD,OACAhD,MACS;AACT,MAAID,SAASO,QAAQ6B,WAAWjB,SAAS;AACvC,WAAO;AAOT,QAAMkB,WAAWF,mBACfnC,SAASO,QAAQ6B,YACjBpC,SAASO,QAAQG,OACjBT,IACF;AACA,SAAO,CAAC,EAAEoC,YAAY,WAAWA;AACnC;ACxBO,SAASa,SACdlD,UACAkB,MAC4B;AAC5B,SACEiC,cAAcjC,IAAI,KAClBA,KAAK6B,UAAU/C,SAASO,QAAQ6C,OAAOC,MAAMZ,QAC7CvB,KAAK6B,UAAU/C,SAASO,QAAQ6C,OAAOE,KAAKb;AAEhD;ACPO,SAASc,aACdtD,MACAuD,SACAC,MACY;AACZ,QAAMC,MAAMC,KAAKD,IAAIzD,KAAKG,QAAQoD,QAAQpD,MAAM;AAChD,MAAIK,kBAA2CgD,MAAM/C,OACjDkD;AAEJ,WAASzD,IAAI,GAAGA,IAAIuD,KAAKvD,KAAK;AAC5B,UAAMc,UAAUhB,KAAKE,CAAC,GAChB0D,eAAeL,QAAQrD,CAAC;AAE9B,QAAIE,eAAeY,OAAO,KAAKZ,eAAewD,YAAY,GAAG;AAC3D,UAAI5C,QAAQK,SAASuC,aAAavC,MAAM;AAClCb,4BACFmD,cAAcnD,gBAAgBe,KAAMsC,CAAAA,MAAMA,EAAExC,SAASL,QAAQK,IAAI,GACjEb,kBAAkBc;AAEpB;AAAA,MACF;AAEA,UAAId,iBAAiB;AACnB,cAAMO,eAAeP,gBAAgBsD,UAClCD,CAAAA,MAAMA,EAAExC,SAASL,QAAQK,IAC5B,GACM0C,oBAAoBvD,gBAAgBsD,UACvCD,CAAAA,MAAMA,EAAExC,SAASuC,aAAavC,IACjC;AACA,YAAIN,iBAAiB,MAAMgD,sBAAsB;AAC/C,iBAAOhD,eAAegD,oBAAoB,KAAK;AAAA,MAEnD;AAGA,UAAI/C,QAAQK,OAAOuC,aAAavC;AAC9B,eAAO;AAET,UAAIL,QAAQK,OAAOuC,aAAavC;AAC9B,eAAO;AAET;AAAA,IACF;AAEA,QAAI,OAAOL,WAAY,YAAY,OAAO4C,gBAAiB,UAAU;AACnE,UAAI5C,YAAY4C,cAAc;AAC5B,YAAID,aAAa;AACf,gBAAMrB,aAAcqB,YAAwC3C,OAAO;AACnER,4BAAkBiC,MAAMC,QAAQJ,UAAU,IACrCA,aACDhB,QACJqC,cAAcrC;AAAAA,QAChB;AACA;AAAA,MACF;AACA,UAAIN,UAAU4C;AACZ,eAAO;AAET,UAAI5C,UAAU4C;AACZ,eAAO;AAET;AAAA,IACF;AAEA,QAAI,OAAO5C,WAAY,YAAY,OAAO4C,gBAAiB,UAAU;AACnE,UAAI5C,UAAU4C;AACZ,eAAO;AAET,UAAI5C,UAAU4C;AACZ,eAAO;AAET;AAAA,IACF;AAEA;AAAA,EACF;AAEA,SAAO;AACT;ACrFO,SAASI,gBACdC,OACAV,SACAC,MACY;AACZ,QAAMU,SAASZ,aAAaW,MAAMjE,MAAMuD,QAAQvD,MAAMwD,IAAI;AAC1D,SAAIU,WAAW,IACTD,MAAME,SAASZ,QAAQY,SAClB,KAELF,MAAME,SAASZ,QAAQY,SAClB,IAEF,IAEFD;AACT;AChBO,SAASE,aACdH,OACAV,SACAC,MACS;AACT,SAAOQ,gBAAcC,OAAOV,SAASC,IAAI,MAAM;AACjD;ACNO,SAASa,gBACdC,OACAd,MACS;AACT,QAAM;AAAA,IAACe;AAAAA,IAAQC;AAAAA,EAAAA,IAASF;AACxB,SAAOF,aAAaG,QAAQC,OAAOhB,IAAI;AACzC;ACLO,SAASiB,WACdH,OACAd,MACgB;AAChB,QAAM;AAAA,IAACe;AAAAA,IAAQC;AAAAA,EAAAA,IAASF;AACxB,SAAOD,gBAAgBC,OAAOd,IAAI,IAAI,CAACgB,OAAOD,MAAM,IAAI,CAACA,QAAQC,KAAK;AACxE;ACQO,SAASE,gBACdpE,SACAW,MACuB;AACvB,SAAOiC,cAAcjC,IAAI,KAAKA,KAAK6B,UAAUxC,QAAQ6C,OAAOC,MAAMZ;AACpE;ACrBO,SAASmC,eAAe3E,MAAYuD,SAAwB;AACjE,MAAIvD,KAAKG,UAAUoD,QAAQpD;AACzB,WAAO;AAGT,WAASD,IAAI,GAAGA,IAAIF,KAAKG,QAAQD,KAAK;AACpC,UAAMc,UAAUhB,KAAKE,CAAC,GAChB0D,eAAeL,QAAQrD,CAAC;AAE9B,QAAIE,eAAeY,OAAO,KAAKZ,eAAewD,YAAY;AACxD,UAAI5C,QAAQK,SAASuC,aAAavC;AAChC,eAAO;AAAA,eAEAL,YAAY4C;AACrB,aAAO;AAAA,EAEX;AAEA,SAAO;AACT;ACKO,UAAUgB,SACf7E,UACA8E,UAMI,IACkD;AACtD,QAAM;AAAA,IAACpD,KAAK,CAAA;AAAA,IAAIqD;AAAAA,IAAMC;AAAAA,IAAIC;AAAAA,IAAOjD,UAAU;AAAA,EAAA,IAAS8C;AAEpD,MAAIC,SAASxD,UAAayD,OAAOzD,QAAW;AAC1C,WAAO2D,eAAelF,UAAU0B,IAAI;AAAA,MAACuD;AAAAA,MAAOjD;AAAAA,IAAAA,CAAQ;AACpD;AAAA,EACF;AAEA,SAAOmD,gBAAgBnF,UAAU0B,IAAI;AAAA,IAACqD;AAAAA,IAAMC;AAAAA,IAAIC;AAAAA,IAAOjD;AAAAA,EAAAA,CAAQ;AACjE;AAiDA,UAAUkD,eACRlF,UACAC,MACA6E,SAIsD;AACtD,QAAM;AAAA,IAACG;AAAAA,IAAOjD,UAAU;AAAA,EAAA,IAAS8C,SAE3BhD,WAAWsD,YAAYpF,UAAUC,IAAI,GAErCoF,UAAUrD,UAAU,CAAC,GAAGF,QAAQ,EAAEE,YAAYF;AAEpD,aAAWe,SAASwC;AAClB,KAAI,CAACJ,SAASA,MAAMpC,MAAM3B,MAAM2B,MAAM5C,IAAI,OACxC,MAAM4C,QAGR,OAAOqC,eAAelF,UAAU6C,MAAM5C,MAAM6E,OAAO;AAEvD;AAYA,SAASQ,mBACPtF,UACAuF,OACAC,OACY;AACZ,QAAMC,QAAQF,MAAMG,OAAOrF,cAAc,GACnCsF,QAAQH,MAAME,OAAOrF,cAAc,GAEnC;AAAA,IAACE;AAAAA,EAAAA,IAAWP;AAClB,MAAIS,kBAA+BF,QAAQG,OACvCE,eACAD,cAAc;AAElB,QAAMiF,WAAWjC,KAAKD,IAAI+B,MAAMrF,QAAQuF,MAAMvF,MAAM;AAEpD,WAASyF,QAAQ,GAAGA,QAAQD,UAAUC,SAAS;AAC7C,UAAMC,OAAOL,MAAMI,KAAK,GAClBE,OAAOJ,MAAME,KAAK;AAExB,QAAIC,KAAKxE,SAASyE,KAAKzE,MAAM;AAI3B,UAAI0E;AACJ,UAAIrF,eAAeX,SAASQ,cAAcyF,IAAIH,KAAKxE,IAAI,GAAG;AACxD,cAAMF,QAAQpB,SAASQ,cAAca,IAAIyE,KAAKxE,IAAI;AAC9CF,kBAAUG,WACZyE,cAAcvF,gBAAgBW,KAAK;AAAA,MAEvC;AACE4E,sBAAcvF,gBAAgBe,KAAMsC,CAAAA,MAAMA,EAAExC,SAASwE,KAAKxE,IAAI;AAEhE,UAAI,CAAC0E;AACH,eAAO;AAET,YAAMrE,OAAOC,gBAAgBrB,SAASyF,aAAapF,aAAa;AAChE,UAAI,CAACe;AACH,eAAO;AAETlB,wBAAkBkB,KAAKG,UACvBlB,gBAAgBe,KAAKI,QAErBpB,cAAc;AACd;AAAA,IACF;AAEA,QAAIA,aAAa;AACf,YAAMuF,UAASlG,SAASQ,cAAca,IAAIyE,KAAKxE,IAAI,KAAK,IAClD6E,UAASnG,SAASQ,cAAca,IAAI0E,KAAKzE,IAAI,KAAK;AACxD,UAAI4E,YAAW,MAAMC,YAAW;AAC9B,eAAID,UAASC,UACJ,KAELD,UAASC,UACJ,IAEF;AAAA,IAEX;AAEA,QAAID,SAAS,IACTC,SAAS;AACb,aAAShG,IAAI,GAAGA,IAAIM,gBAAgBL,QAAQD,KAAK;AAC/C,YAAMiG,UAAU3F,gBAAgBN,CAAC;AAOjC,UANIiG,QAAQ9E,SAASwE,KAAKxE,SACxB4E,SAAS/F,IAEPiG,QAAQ9E,SAASyE,KAAKzE,SACxB6E,SAAShG,IAEP+F,WAAW,MAAMC,WAAW;AAC9B;AAAA,IAEJ;AAEA,WAAID,SAASC,SACJ,KAELD,SAASC,SACJ,IAGF;AAAA,EACT;AAIA,SAAIV,MAAMrF,SAASuF,MAAMvF,SAChB,KAELqF,MAAMrF,SAASuF,MAAMvF,SAChB,IAGF;AACT;AAQA,UAAU+E,gBACRnF,UACAC,MACA6E,SAMsD;AACtD,QAAM;AAAA,IAACC;AAAAA,IAAMC;AAAAA,IAAIC;AAAAA,IAAOjD,UAAU;AAAA,EAAA,IAAS8C,SAErChD,WAAWsD,YAAYpF,UAAUC,IAAI,GACrCoF,UAAUrD,UAAU,CAAC,GAAGF,QAAQ,EAAEE,YAAYF;AAEpD,aAAWe,SAASwC,SAAS;AAC3B,QAAIgB,iBAAiBrG,UAAU6C,MAAM5C,MAAM8E,MAAMC,IAAIhD,OAAO;AAC1D;AAGGsE,6BAAyBtG,UAAU6C,MAAM5C,MAAM8E,MAAMC,EAAE,MAIxDuB,UAAUvG,UAAU6C,MAAM5C,MAAM8E,MAAMC,EAAE,MACtC,CAACC,SAASA,MAAMpC,MAAM3B,MAAM2B,MAAM5C,IAAI,OACxC,MAAM4C,QAIV,OAAOsC,gBAAgBnF,UAAU6C,MAAM5C,MAAM6E,OAAO;AAAA,EACtD;AACF;AAOA,SAASyB,UACPvG,UACAwG,UACAzB,MACAC,IACS;AAUT,SARED,EAAAA,SAASxD,UACT+D,mBAAmBtF,UAAUwG,UAAUzB,IAAI,MAAM,MAE7C,CAACH,eAAe4B,UAAUzB,IAAI,KAKhCC,OAAOzD,UAAa+D,mBAAmBtF,UAAUwG,UAAUxB,EAAE,MAAM,KACjE,CAACJ,eAAe4B,UAAUxB,EAAE;AAMpC;AAMA,SAASsB,yBACPtG,UACAwG,UACAzB,MACAC,IACS;AAST,SARIuB,aAAUvG,UAAUwG,UAAUzB,MAAMC,EAAE,KAItCD,SAASxD,UAAaqD,eAAe4B,UAAUzB,IAAI,KAInDC,OAAOzD,UAAaqD,eAAe4B,UAAUxB,EAAE;AAKrD;AAKA,SAASqB,iBACPrG,UACAwG,UACAzB,MACAC,IACAhD,SACS;AACT,SAAIA,UACE+C,SAASxD,SACJ,KAIP+D,mBAAmBtF,UAAUwG,UAAUzB,IAAI,MAAM,MACjD,CAACH,eAAe4B,UAAUzB,IAAI,IAI9BC,OAAOzD,SACF,KAGF+D,mBAAmBtF,UAAUwG,UAAUxB,EAAE,MAAM;AACxD;ACnTO,SAASyB,WACdzG,UACAC,MACA6E,SAIsC;AACtC,QAAM;AAAA,IAAC4B;AAAAA,IAAWzB;AAAAA,EAAAA,IAASH;AAE3B,MAAI7E,KAAKG,WAAW;AAClB;AAGF,QAAMuG,cAAc1G,KAAKyB,GAAG,EAAE;AAE9B,MAAI,CAACrB,eAAesG,WAAW;AAC7B;AAGF,QAAM5E,SAAS6E,WAAW3G,IAAI,GACxB6B,WAAWsD,YAAYpF,UAAU+B,MAAM,GAEvC8E,eAAe/E,SAASiC,UAC3BtC,CAAAA,UAAUA,MAAMP,KAAKI,SAASqF,YAAYrF,IAC7C;AAEA,MAAIuF,iBAAiB,IAIrB;AAAA,QAAI,CAAC5B,OAAO;AACV,YAAM6B,eACJJ,cAAc,SAASG,eAAe,IAAIA,eAAe;AAE3D,aAAIC,eAAe,KAAKA,gBAAgBhF,SAAS1B,SAC/C,SAGK0B,SAASgF,YAAY;AAAA,IAC9B;AAOA,YAJEJ,cAAc,SACV5E,SAASD,MAAMgF,eAAe,CAAC,IAC/B/E,SAASD,MAAM,GAAGgF,YAAY,EAAE7E,QAAAA,GAEpBR,KAAMC,CAAAA,UAAUwD,MAAMxD,MAAMP,MAAMO,MAAMxB,IAAI,CAAC;AAAA;AACjE;ACtEO,SAAS8G,WACdxG,SACAW,MACkB;AAClB,SAAOiC,cAAcjC,IAAI,KAAKA,KAAK6B,UAAUxC,QAAQ6C,OAAOE,KAAKb;AACnE;ACFO,SAASuE,QAAQhH,UAA6BC,MAAqB;AACxE,QAAM8B,SAASkF,UAAUjH,UAAUC,IAAI;AAEvC,SAAK8B,SAIE,CAAC4C,gBAAgB;AAAA,IAACvB,QAAQpD,SAASO,QAAQ6C;AAAAA,EAAAA,GAASrB,OAAOb,IAAI,IAH7D;AAIX;AAUO,SAASgG,SACdlH,UACAC,MACmD;AACnD,QAAM4C,QAAQX,QAAQlC,UAAUC,IAAI;AAEpC,MAAK4C,SAIAmE,QAAQhH,UAAUC,IAAI,KAIvB8G,CAAAA,WAAW;AAAA,IAAC3D,QAAQpD,SAASO,QAAQ6C;AAAAA,EAAAA,GAASP,MAAM3B,IAAI;AAI5D,WAAO;AAAA,MAACA,MAAM2B,MAAM3B;AAAAA,MAAMjB,MAAM4C,MAAM5C;AAAAA,IAAAA;AACxC;AC3CO,SAASkH,SAASnH,UAA6BC,MAAqB;AACzE,SAAO,CAAC+G,QAAQhH,UAAUC,IAAI;AAChC;AC6BO,SAASmH,kBACdpH,UACAC,MACA6E,SAImD;AACnD,QAAMG,QAAQH,SAASG;AAGvB,OAFaH,SAASuC,QAAQ,cAEjB,WAAW;AACtB,UAAMC,YAAYvH,aAAaC,UAAUC,IAAI;AAE7C,eAAWsH,YAAY,CAAC,GAAGD,SAAS,EAAEtF,QAAAA;AACpC,UAAI,CAACiD,SAASA,MAAMsC,SAASrG,MAAMqG,SAAStH,IAAI;AAC9C,eAAOsH;AAIX,UAAMC,UAASN,SAASlH,UAAUC,IAAI;AAEtC,WAAIuH,YAAW,CAACvC,SAASA,MAAMuC,QAAOtG,MAAMsG,QAAOvH,IAAI,KAC9CuH,UAGT;AAAA,EACF;AAEA,QAAMA,SAASN,SAASlH,UAAUC,IAAI;AAEtC,MAAIuH,WAAW,CAACvC,SAASA,MAAMuC,OAAOtG,MAAMsG,OAAOvH,IAAI;AACrD,WAAOuH;AAGT,aAAWD,YAAYxH,aAAaC,UAAUC,IAAI;AAChD,QAAI,CAACgF,SAASA,MAAMsC,SAASrG,MAAMqG,SAAStH,IAAI;AAC9C,aAAOsH;AAKb;ACrEO,SAAStD,cACdjE,UACAyH,QACAC,QACY;AACZ,QAAMC,iBAAiBpE,aAAakE,OAAOxH,MAAMyH,OAAOzH,MAAM;AAAA,IAC5DS,OAAOV,SAASO,QAAQG;AAAAA,EAAAA,CACzB;AAED,SAAIiH,mBAAmB,IACdA,iBAGLF,OAAOrD,SAASsD,OAAOtD,SAClB,KAGLqD,OAAOrD,SAASsD,OAAOtD,SAClB,IAGF;AACT;ACnBO,SAASwD,gBACd5H,UACAC,MAC6D;AAC7D,QAAMqH,YAAYvH,aAAaC,UAAUC,IAAI;AAC7C,aAAWsH,YAAYD,WAAW;AAChC,QAAI,CAACpE,SAASlD,UAAUuH,SAASrG,IAAI;AACnC;AAEF,UAAMmB,WAAWF,mBACfnC,SAASO,QAAQ6B,YACjBpC,SAASO,QAAQG,OACjB6G,SAAStH,IACX;AACA,WAAI,CAACoC,YAAY,EAAE,WAAWA,YAC5B,SAEK;AAAA,MAACN,QAAQM;AAAAA,MAAUuE,YAAYW,SAAStH;AAAAA,IAAAA;AAAAA,EACjD;AAEF;ACtBO,SAAS4H,sBACd7H,UACAC,MAMY;AACZ,QAAM6H,UAAUF,gBAAgB5H,UAAUC,IAAI;AAC9C,MAAK6H;AAGL,WAAO;AAAA,MACLlF,IAAIkF,QAAQ/F,OAAOS,MAAMI;AAAAA,MACzB3C,MAAM6H,QAAQlB;AAAAA,IAAAA;AAElB;ACnBO,SAASmB,iBACd/H,UACAC,MACQ;AACR,QAAM+H,YAAYH,sBAAsB7H,UAAUC,IAAI;AAEtD,SAAK+H,YAIEC,aAAajI,SAASO,QAAQ6C,QAAQ4E,UAAUpF,EAAE,IAHhD5C,SAASO,QAAQ6C;AAI5B;"}
+{"version":3,"file":"get-path-sub-schema.js","sources":["../../src/traversal/get-ancestors.ts","../../src/traversal/has-node.ts","../../src/schema/resolve-container-at.ts","../../src/schema/is-editable-container.ts","../../src/traversal/is-object.ts","../../src/engine/path/compare-paths.ts","../../src/engine/point/compare-points.ts","../../src/engine/point/is-after-point.ts","../../src/engine/range/is-backward-range.ts","../../src/engine/range/range-edges.ts","../../src/engine/node/is-text-block-node.ts","../../src/engine/path/is-ancestor-path.ts","../../src/traversal/get-nodes.ts","../../src/traversal/get-sibling.ts","../../src/engine/node/is-span-node.ts","../../src/traversal/is-block.ts","../../src/traversal/is-inline.ts","../../src/traversal/get-enclosing-block.ts","../../src/traversal/compare-points.ts","../../src/schema/descend-to-parent.ts","../../src/schema/get-enclosing-container.ts","../../src/traversal/get-path-sub-schema.ts"],"sourcesContent":["import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport {getNodeChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get all ancestors of the node at a given path, from nearest to furthest.\n *\n * For a path like [{_key:'t1'}, 'rows', {_key:'r1'}, 'cells', {_key:'c1'}],\n * the ancestors are (nearest first):\n *   [{_key:'t1'}, 'rows', {_key:'r1'}]\n *   [{_key:'t1'}]\n *\n * Walks from root to the target in a single pass collecting each ancestor\n * as it goes.\n *\n * Every ancestor is a `PortableTextBlock` — only text blocks and object\n * nodes can contain children.\n *\n * @beta\n */\nexport function getAncestors(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): Array<{node: PortableTextBlock; path: Path}> {\n  // Collect keyed-segment indices to know where each ancestor's path ends.\n  const keyedIndices: Array<number> = []\n  for (let i = 0; i < path.length; i++) {\n    if (isKeyedSegment(path[i])) {\n      keyedIndices.push(i)\n    }\n  }\n\n  // Need at least 2 keyed segments to have an ancestor (the last is self).\n  if (keyedIndices.length <= 1) {\n    return []\n  }\n\n  const {context, blockIndexMap} = snapshot\n  let currentChildren: Array<Node> = context.value\n  let isRootLevel = true\n  let currentParent:\n    | import('../schema/resolve-containers').RegisteredContainer\n    | undefined\n\n  const ancestorsByDepth: Array<{node: PortableTextBlock; path: Path}> = []\n  const resolvedPath: Path = []\n\n  // Descend once. We walk only as far as the second-to-last keyed segment;\n  // the last keyed segment is the target itself, which is not an ancestor.\n  const targetKeyedIndex = keyedIndices[keyedIndices.length - 1]!\n\n  let segmentIndex = 0\n  while (segmentIndex < targetKeyedIndex) {\n    const segment = path[segmentIndex]!\n\n    if (typeof segment === 'string') {\n      resolvedPath.push(segment)\n      segmentIndex++\n      continue\n    }\n\n    let node: Node | undefined\n    if (isKeyedSegment(segment)) {\n      if (isRootLevel) {\n        const index = blockIndexMap.get(segment._key)\n        node =\n          index !== undefined\n            ? currentChildren[index]\n            : currentChildren.find((child) => child._key === segment._key)\n      } else {\n        node = currentChildren.find((child) => child._key === segment._key)\n      }\n      resolvedPath.push(segment)\n      isRootLevel = false\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 []\n    }\n\n    if (!node) {\n      return []\n    }\n\n    // Descend with positional awareness. `getNodeChildren` checks the\n    // current parent's `of` for a positional override before falling\n    // back to the top-level `containers` map - so same-`_type`\n    // registered under different parents with different `field`\n    // resolves to the right entry at this position.\n    const next = getNodeChildren(context, node, currentParent)\n    if (!next) {\n      return []\n    }\n\n    // An ancestor has children, so it is never a span. The narrowing\n    // from `Node` to `PortableTextBlock` (text block | object) is safe.\n    ancestorsByDepth.push({\n      node: node as PortableTextBlock,\n      path: resolvedPath.slice(),\n    })\n\n    currentChildren = next.children\n    currentParent = next.parent\n    segmentIndex++\n  }\n\n  // Return nearest-first (reverse of document order at the call site).\n  return ancestorsByDepth.reverse()\n}\n","import type {Path} from '../engine/interfaces/path'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Check if a node exists at a given path.\n *\n * @beta\n */\nexport function hasNode(snapshot: TraversalSnapshot, path: Path): boolean {\n  return getNode(snapshot, path) !== undefined\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport type {\n  Containers,\n  RegisteredContainer,\n  RegisteredPositional,\n} from './container-types'\n\n/**\n * Walk the editor value following `path` and return the\n * {@link RegisteredContainer} or {@link RegisteredPositional} that applies\n * at `path`'s target position.\n *\n * Resolution rules at each step:\n *\n * 1. **Positional override.** If the current parent declares the\n *    child's `_type` in its `of`, the positional entry wins.\n *    Used to resolve same-`_type` registered under different\n *    parents with different `field` values.\n *\n * 2. **Global fallback.** If the parent has no positional override,\n *    fall back to the top-level entry for `_type` in\n *    `containers`.\n *\n * 3. **Chain validity.** If any ancestor along the path has no\n *    resolved container entry (unregistered or not reachable as a\n *    container at its position), return `undefined`.\n *\n * Returns `undefined` when the target's `_type` is not registered\n * at this position. Returns a {@link RegisteredPositional} when the target\n * resolves to a leaf in a positional `of` (terminal node with no\n * editable children).\n *\n * @alpha\n */\nexport function resolveContainerAt(\n  containers: Containers,\n  value: ReadonlyArray<Node>,\n  path: Path,\n): RegisteredContainer | RegisteredPositional | undefined {\n  const keyedIndices: Array<number> = []\n  for (let index = 0; index < path.length; index++) {\n    if (isKeyedSegment(path[index])) {\n      keyedIndices.push(index)\n    }\n  }\n  if (keyedIndices.length === 0) {\n    return undefined\n  }\n\n  let currentChildren: ReadonlyArray<Node> = value\n  let parent: RegisteredContainer | undefined\n  let resolved: RegisteredContainer | RegisteredPositional | undefined\n  const targetKeyedIndex = keyedIndices[keyedIndices.length - 1]!\n\n  let segmentIndex = 0\n  while (segmentIndex <= targetKeyedIndex) {\n    const segment = path[segmentIndex]!\n    if (typeof segment === 'string') {\n      segmentIndex++\n      continue\n    }\n\n    let node: Node | undefined\n    if (isKeyedSegment(segment)) {\n      node = currentChildren.find((child) => child._key === segment._key)\n    } else if (typeof segment === 'number') {\n      node = currentChildren.at(segment)\n    } else {\n      return undefined\n    }\n    if (!node) {\n      return undefined\n    }\n\n    resolved = resolveNodeEntry(containers, parent, node)\n    if (!resolved) {\n      return undefined\n    }\n\n    if (segmentIndex < targetKeyedIndex) {\n      // Walk one more level. The resolved entry must be a container\n      // (have children) for descent to continue.\n      if (!('field' in resolved)) {\n        return undefined\n      }\n      const fieldValue = (node as Record<string, unknown>)[resolved.field.name]\n      if (!Array.isArray(fieldValue)) {\n        return undefined\n      }\n      parent = resolved\n      currentChildren = fieldValue as Array<Node>\n    }\n    segmentIndex++\n  }\n\n  return resolved\n}\n\nfunction resolveNodeEntry(\n  containers: Containers,\n  parent: RegisteredContainer | undefined,\n  node: Node,\n): RegisteredContainer | RegisteredPositional | undefined {\n  if (parent?.of) {\n    for (const entry of parent.of) {\n      if (entry.type === node._type) {\n        return entry\n      }\n    }\n  }\n  return containers.get(node._type)\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport type {TraversalSnapshot} from '../traversal/traversal-snapshot'\nimport {resolveContainerAt} from './resolve-container-at'\n\n/**\n * Check if a node at the given path is a registered editable container.\n *\n * Position-aware: {@link resolveContainerAt} descends from the editor\n * root threading the resolved parent at each step, so positionally-\n * registered containers (e.g. `cell` registered only inside\n * `table.of`) are recognized when reached through their declared\n * parent.\n */\nexport function isEditableContainer(\n  snapshot: TraversalSnapshot,\n  _node: Node,\n  path: Path,\n): boolean {\n  if (snapshot.context.containers.size === 0) {\n    return false\n  }\n\n  // `resolveContainerAt` aborts on the first unregistered object-node\n  // ancestor (chain validity falls out of the single descent), so the\n  // single call below answers both \"is the node here a container?\" and\n  // \"is the ancestor chain valid?\" in one walk.\n  const resolved = resolveContainerAt(\n    snapshot.context.containers,\n    snapshot.context.value,\n    path,\n  )\n  return !!(resolved && 'field' in resolved)\n}\n","import type {PortableTextObject} from '@portabletext/schema'\nimport {isTypedObject} from '../utils/asserters'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Check if a node is an object node (not a text block or span).\n *\n * @beta\n */\nexport function isObject(\n  snapshot: TraversalSnapshot,\n  node: unknown,\n): node is PortableTextObject {\n  return (\n    isTypedObject(node) &&\n    node._type !== snapshot.context.schema.block.name &&\n    node._type !== snapshot.context.schema.span.name\n  )\n}\n","import {isKeyedSegment} from '../../utils/util.is-keyed-segment'\nimport type {Node} from '../interfaces/node'\nimport type {Path} from '../interfaces/path'\n\n/**\n * Compare two paths in document order.\n *\n * When paths contain keyed segments, the root node tree is needed to\n * resolve document order. Without a root, keyed segments are compared\n * by _key string (consistent but not necessarily document order).\n */\nexport function comparePaths(\n  path: Path,\n  another: Path,\n  root: {value: Array<Node>},\n): -1 | 0 | 1 {\n  const min = Math.min(path.length, another.length)\n  let currentChildren: Array<Node> | undefined = root?.value\n  let currentNode: Node | undefined\n\n  for (let i = 0; i < min; i++) {\n    const segment = path[i]!\n    const otherSegment = another[i]!\n\n    if (isKeyedSegment(segment) && isKeyedSegment(otherSegment)) {\n      if (segment._key === otherSegment._key) {\n        if (currentChildren) {\n          currentNode = currentChildren.find((c) => c._key === segment._key)\n          currentChildren = undefined\n        }\n        continue\n      }\n\n      if (currentChildren) {\n        const segmentIndex = currentChildren.findIndex(\n          (c) => c._key === segment._key,\n        )\n        const otherSegmentIndex = currentChildren.findIndex(\n          (c) => c._key === otherSegment._key,\n        )\n        if (segmentIndex !== -1 && otherSegmentIndex !== -1) {\n          return segmentIndex < otherSegmentIndex ? -1 : 1\n        }\n      }\n\n      // Fallback: compare by _key string\n      if (segment._key < otherSegment._key) {\n        return -1\n      }\n      if (segment._key > otherSegment._key) {\n        return 1\n      }\n      continue\n    }\n\n    if (typeof segment === 'string' && typeof otherSegment === 'string') {\n      if (segment === otherSegment) {\n        if (currentNode) {\n          const fieldValue = (currentNode as Record<string, unknown>)[segment]\n          currentChildren = Array.isArray(fieldValue)\n            ? (fieldValue as Array<Node>)\n            : undefined\n          currentNode = undefined\n        }\n        continue\n      }\n      if (segment < otherSegment) {\n        return -1\n      }\n      if (segment > otherSegment) {\n        return 1\n      }\n      continue\n    }\n\n    if (typeof segment === 'number' && typeof otherSegment === 'number') {\n      if (segment < otherSegment) {\n        return -1\n      }\n      if (segment > otherSegment) {\n        return 1\n      }\n      continue\n    }\n\n    break\n  }\n\n  return 0\n}\n","import type {Node} from '../interfaces/node'\nimport type {Point} from '../interfaces/point'\nimport {comparePaths} from '../path/compare-paths'\n\nexport function comparePoints(\n  point: Point,\n  another: Point,\n  root: {value: Array<Node>},\n): -1 | 0 | 1 {\n  const result = comparePaths(point.path, another.path, root)\n  if (result === 0) {\n    if (point.offset < another.offset) {\n      return -1\n    }\n    if (point.offset > another.offset) {\n      return 1\n    }\n    return 0\n  }\n  return result\n}\n","import type {Node} from '../interfaces/node'\nimport type {Point} from '../interfaces/point'\nimport {comparePoints} from './compare-points'\n\nexport function isAfterPoint(\n  point: Point,\n  another: Point,\n  root: {value: Array<Node>},\n): boolean {\n  return comparePoints(point, another, root) === 1\n}\n","import type {Node} from '../interfaces/node'\nimport type {Range} from '../interfaces/range'\nimport {isAfterPoint} from '../point/is-after-point'\n\nexport function isBackwardRange(\n  range: Range,\n  root: {value: Array<Node>},\n): boolean {\n  const {anchor, focus} = range\n  return isAfterPoint(anchor, focus, root)\n}\n","import type {Node} from '../interfaces/node'\nimport type {Point} from '../interfaces/point'\nimport type {Range} from '../interfaces/range'\nimport {isBackwardRange} from './is-backward-range'\n\nexport function rangeEdges(\n  range: Range,\n  root: {value: Array<Node>},\n): [Point, Point] {\n  const {anchor, focus} = range\n  return isBackwardRange(range, root) ? [focus, anchor] : [anchor, focus]\n}\n","import type {PortableTextObject, PortableTextSpan} from '@portabletext/schema'\nimport type {EditorSchema} from '../../editor/editor-schema'\nimport {isTypedObject} from '../../utils/asserters'\n\ntype TextBlockNode = {\n  _type: string\n  _key: string\n  children?: Array<PortableTextSpan | PortableTextObject>\n  markDefs?: Array<PortableTextObject>\n  style?: string\n  listItem?: string\n  level?: number\n}\n\n/**\n * Checks if a node is a text block based on `_type` alone, without requiring\n * `children` to be present. This is needed to identify text blocks before\n * normalization has had a chance to add the missing `children` property.\n */\nexport function isTextBlockNode(\n  context: {schema: EditorSchema},\n  node: unknown,\n): node is TextBlockNode {\n  return isTypedObject(node) && node._type === context.schema.block.name\n}\n","import {isKeyedSegment} from '../../utils/util.is-keyed-segment'\nimport type {Path} from '../interfaces/path'\n\nexport function isAncestorPath(path: Path, another: Path): boolean {\n  if (path.length >= another.length) {\n    return false\n  }\n\n  for (let i = 0; i < path.length; i++) {\n    const segment = path[i]\n    const otherSegment = another[i]\n\n    if (isKeyedSegment(segment) && isKeyedSegment(otherSegment)) {\n      if (segment._key !== otherSegment._key) {\n        return false\n      }\n    } else if (segment !== otherSegment) {\n      return false\n    }\n  }\n\n  return true\n}\n","import type {EditorSchema} from '../editor/editor-schema'\nimport type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {isAncestorPath} from '../engine/path/is-ancestor-path'\nimport type {\n  Containers,\n  RegisteredContainer,\n} from '../schema/resolve-containers'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport {getChildren, getNodeChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the descendant nodes of the node at a given path.\n *\n * When `from` and `to` are provided, performs a range-bounded DFS traversal,\n * yielding only nodes between `from` and `to` (inclusive). Both paths are\n * always in document order: `from` is the earlier path, `to` is the later\n * path. The `reverse` flag controls iteration direction within that range.\n *\n * When `match` is provided, only yields nodes where the predicate returns true.\n * The traversal still visits all nodes in range - `match` is a filter, not a\n * traversal control.\n *\n * When `at` is provided, traverses descendants of the node at that path\n * instead of the root.\n */\nexport function* getNodes(\n  snapshot: TraversalSnapshot,\n  options: {\n    at?: Path\n    from?: Path\n    to?: Path\n    match?: (node: Node, path: Path) => boolean\n    reverse?: boolean\n  } = {},\n): Generator<{node: Node; path: Path}, void, undefined> {\n  const {at = [], from, to, match, reverse = false} = options\n\n  if (from === undefined && to === undefined) {\n    yield* getNodesSimple(snapshot, at, {match, reverse})\n    return\n  }\n\n  yield* getNodesInRange(snapshot, at, {from, to, match, reverse})\n}\n\n/**\n * Get descendant nodes of a standalone node (not in the editor tree).\n * Used for cases like getDirtyPaths where the node hasn't been inserted yet.\n */\nexport function* getNodeDescendants(\n  context: {\n    schema: EditorSchema\n    containers: Containers\n  },\n  node: Node | {value: Array<Node>},\n): Generator<{node: Node; path: Path}, void, undefined> {\n  // The editor root wrapper ({value: [...]}) is not a real node, so its field\n  // name is not part of paths. For standalone nodes (a real {_key, _type, ...}\n  // passed in by callers like getDirtyPaths), the field name IS part of the\n  // path.\n  const isRoot = !('_key' in node) && !('_type' in node)\n  yield* walkStandalone(context, node, [], isRoot)\n}\n\nfunction* walkStandalone(\n  context: {\n    schema: EditorSchema\n    containers: Containers\n  },\n  node: Node | {value: Array<Node>},\n  path: Path,\n  isRoot: boolean,\n  parent?: RegisteredContainer,\n): Generator<{node: Node; path: Path}, void, undefined> {\n  const next = getNodeChildren(context, node, parent)\n  if (!next) {\n    return\n  }\n\n  for (const child of next.children) {\n    const childPath: Path = isRoot\n      ? [{_key: child._key}]\n      : [...path, next.fieldName, {_key: child._key}]\n    yield {node: child, path: childPath}\n    yield* walkStandalone(context, child, childPath, false, next.parent)\n  }\n}\n\n/**\n * Simple recursive DFS - the original behavior.\n * Yields all descendants of the node at `path`.\n */\nfunction* getNodesSimple(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    match?: (node: Node, path: Path) => boolean\n    reverse?: boolean\n  },\n): Generator<{node: Node; path: Path}, void, undefined> {\n  const {match, reverse = false} = options\n\n  const children = getChildren(snapshot, path)\n\n  const entries = reverse ? [...children].reverse() : children\n\n  for (const entry of entries) {\n    if (!match || match(entry.node, entry.path)) {\n      yield entry\n    }\n\n    yield* getNodesSimple(snapshot, entry.path, options)\n  }\n}\n\n/**\n * Compare two keyed paths in document order. Returns -1, 0, or 1.\n *\n * Descends both paths from the root in a single pass, advancing\n * `currentNode` and `currentChildren` together so each level costs\n * one keyed-segment scan instead of an O(depth) walk from root.\n *\n * Uses `blockIndexMap` for O(1) lookup at the root level. Deeper\n * levels fall back to a linear scan of the current sibling array.\n */\nfunction comparePathsInTree(\n  snapshot: TraversalSnapshot,\n  pathA: Path,\n  pathB: Path,\n): -1 | 0 | 1 {\n  const keysA = pathA.filter(isKeyedSegment)\n  const keysB = pathB.filter(isKeyedSegment)\n\n  const {context} = snapshot\n  let currentChildren: Array<Node> = context.value\n  let currentParent: RegisteredContainer | undefined\n  let isRootLevel = true\n\n  const minDepth = Math.min(keysA.length, keysB.length)\n\n  for (let depth = 0; depth < minDepth; depth++) {\n    const keyA = keysA[depth]!\n    const keyB = keysB[depth]!\n\n    if (keyA._key === keyB._key) {\n      // Same node at this depth: descend into its children for the next\n      // iteration. The root level can short-circuit via blockIndexMap;\n      // deeper levels scan the current sibling array.\n      let matchedNode: Node | undefined\n      if (isRootLevel && snapshot.blockIndexMap.has(keyA._key)) {\n        const index = snapshot.blockIndexMap.get(keyA._key)\n        if (index !== undefined) {\n          matchedNode = currentChildren[index]\n        }\n      } else {\n        matchedNode = currentChildren.find((c) => c._key === keyA._key)\n      }\n      if (!matchedNode) {\n        return 0\n      }\n      const next = getNodeChildren(context, matchedNode, currentParent)\n      if (!next) {\n        return 0\n      }\n      currentChildren = next.children\n      currentParent = next.parent\n\n      isRootLevel = false\n      continue\n    }\n\n    if (isRootLevel) {\n      const indexA = snapshot.blockIndexMap.get(keyA._key) ?? -1\n      const indexB = snapshot.blockIndexMap.get(keyB._key) ?? -1\n      if (indexA !== -1 && indexB !== -1) {\n        if (indexA < indexB) {\n          return -1\n        }\n        if (indexA > indexB) {\n          return 1\n        }\n        return 0\n      }\n    }\n\n    let indexA = -1\n    let indexB = -1\n    for (let i = 0; i < currentChildren.length; i++) {\n      const sibling = currentChildren[i]!\n      if (sibling._key === keyA._key) {\n        indexA = i\n      }\n      if (sibling._key === keyB._key) {\n        indexB = i\n      }\n      if (indexA !== -1 && indexB !== -1) {\n        break\n      }\n    }\n\n    if (indexA < indexB) {\n      return -1\n    }\n    if (indexA > indexB) {\n      return 1\n    }\n\n    return 0\n  }\n\n  // One path is a prefix of the other (ancestor relationship)\n  // In DFS order, shorter path (ancestor) comes first\n  if (keysA.length < keysB.length) {\n    return -1\n  }\n  if (keysA.length > keysB.length) {\n    return 1\n  }\n\n  return 0\n}\n\n/**\n * Range-bounded recursive DFS traversal.\n *\n * `from` and `to` are always in document order (from is earlier, to is\n * later), regardless of traversal direction.\n */\nfunction* getNodesInRange(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    from?: Path\n    to?: Path\n    match?: (node: Node, path: Path) => boolean\n    reverse?: boolean\n  },\n): Generator<{node: Node; path: Path}, void, undefined> {\n  const {from, to, match, reverse = false} = options\n\n  const children = getChildren(snapshot, path)\n  const entries = reverse ? [...children].reverse() : children\n\n  for (const entry of entries) {\n    if (canStopTraversal(snapshot, entry.path, from, to, reverse)) {\n      return\n    }\n\n    if (!couldContainInRangeNodes(snapshot, entry.path, from, to)) {\n      continue\n    }\n\n    if (isInRange(snapshot, entry.path, from, to)) {\n      if (!match || match(entry.node, entry.path)) {\n        yield entry\n      }\n    }\n\n    yield* getNodesInRange(snapshot, entry.path, options)\n  }\n}\n\n/**\n * Check if a node is within the [from, to] range in document order.\n * Both bounds are inclusive. Ancestor nodes of from or to are also\n * considered in range since they contain the range boundary.\n */\nfunction isInRange(\n  snapshot: TraversalSnapshot,\n  nodePath: Path,\n  from: Path | undefined,\n  to: Path | undefined,\n): boolean {\n  if (\n    from !== undefined &&\n    comparePathsInTree(snapshot, nodePath, from) === -1\n  ) {\n    if (!isAncestorPath(nodePath, from)) {\n      return false\n    }\n  }\n\n  if (to !== undefined && comparePathsInTree(snapshot, nodePath, to) === 1) {\n    if (!isAncestorPath(nodePath, to)) {\n      return false\n    }\n  }\n\n  return true\n}\n\n/**\n * Check if a subtree rooted at `nodePath` could contain any nodes in the\n * [from, to] range.\n */\nfunction couldContainInRangeNodes(\n  snapshot: TraversalSnapshot,\n  nodePath: Path,\n  from: Path | undefined,\n  to: Path | undefined,\n): boolean {\n  if (isInRange(snapshot, nodePath, from, to)) {\n    return true\n  }\n\n  if (from !== undefined && isAncestorPath(nodePath, from)) {\n    return true\n  }\n\n  if (to !== undefined && isAncestorPath(nodePath, to)) {\n    return true\n  }\n\n  return false\n}\n\n/**\n * Check if all remaining nodes in iteration order will be outside the range.\n */\nfunction canStopTraversal(\n  snapshot: TraversalSnapshot,\n  nodePath: Path,\n  from: Path | undefined,\n  to: Path | undefined,\n  reverse: boolean,\n): boolean {\n  if (reverse) {\n    if (from === undefined) {\n      return false\n    }\n\n    return (\n      comparePathsInTree(snapshot, nodePath, from) === -1 &&\n      !isAncestorPath(nodePath, from)\n    )\n  }\n\n  if (to === undefined) {\n    return false\n  }\n\n  return comparePathsInTree(snapshot, nodePath, to) === 1\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {parentPath} from '../engine/path/parent-path'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\nimport {getChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get a sibling of the node at a given path.\n *\n * Without `match`, returns the immediate next or previous sibling.\n * With `match`, returns the first sibling in `direction` that satisfies\n * the predicate.\n *\n * When `match` is a type predicate, the returned `node` narrows to that type.\n *\n * @beta\n */\nexport function getSibling<TMatch extends Node>(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    direction: 'next' | 'previous'\n    match: (node: Node, path: Path) => node is TMatch\n  },\n): {node: TMatch; path: Path} | undefined\n/**\n * @beta\n */\nexport function getSibling(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    direction: 'next' | 'previous'\n    match?: (node: Node, path: Path) => boolean\n  },\n): {node: Node; path: Path} | undefined\nexport function getSibling(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    direction: 'next' | 'previous'\n    match?: (node: Node, path: Path) => boolean\n  },\n): {node: Node; path: Path} | undefined {\n  const {direction, match} = options\n\n  if (path.length === 0) {\n    return undefined\n  }\n\n  const lastSegment = path.at(-1)\n\n  if (!isKeyedSegment(lastSegment)) {\n    return undefined\n  }\n\n  const parent = parentPath(path)\n  const children = getChildren(snapshot, parent)\n\n  const currentIndex = children.findIndex(\n    (child) => child.node._key === lastSegment._key,\n  )\n\n  if (currentIndex === -1) {\n    return undefined\n  }\n\n  if (!match) {\n    const siblingIndex =\n      direction === 'next' ? currentIndex + 1 : currentIndex - 1\n\n    if (siblingIndex < 0 || siblingIndex >= children.length) {\n      return undefined\n    }\n\n    return children[siblingIndex]\n  }\n\n  const candidates =\n    direction === 'next'\n      ? children.slice(currentIndex + 1)\n      : children.slice(0, currentIndex).reverse()\n\n  return candidates.find((child) => match(child.node, child.path))\n}\n","import type {EditorSchema} from '../../editor/editor-schema'\nimport {isTypedObject} from '../../utils/asserters'\n\nexport type SpanNode = {\n  _type: string\n  _key: string\n  text?: string\n  marks?: Array<string>\n}\n\n/**\n * Checks if a node is a span based on `_type` alone, without requiring `text`\n * to be present. This is needed to identify spans before normalization has had\n * a chance to add the missing `text` property.\n */\nexport function isSpanNode(\n  context: {schema: EditorSchema},\n  node: unknown,\n): node is SpanNode {\n  return isTypedObject(node) && node._type === context.schema.span.name\n}\n","import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {isSpanNode} from '../engine/node/is-span-node'\nimport {isTextBlockNode} from '../engine/node/is-text-block-node'\nimport {getNode} from './get-node'\nimport {getParent} from './get-parent'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Determine if a node at the given path is a block.\n *\n * A node is a block if its parent is not a text block. Top-level nodes\n * (direct children of the editor) are always blocks. Children of text blocks\n * (spans and inline objects) are not blocks. Children of containers are\n * blocks within that container.\n *\n * @beta\n */\nexport function isBlock(snapshot: TraversalSnapshot, path: Path): boolean {\n  const parent = getParent(snapshot, path)\n\n  if (!parent) {\n    return true\n  }\n\n  return !isTextBlockNode({schema: snapshot.context.schema}, parent.node)\n}\n\n/**\n * Get the node at the given path if it is a block.\n *\n * Returns the node narrowed to PortableTextBlock, or undefined if the node\n * doesn't exist or is not a block.\n *\n * @beta\n */\nexport function getBlock(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: PortableTextBlock; path: Path} | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (!isBlock(snapshot, path)) {\n    return undefined\n  }\n\n  if (isSpanNode({schema: snapshot.context.schema}, entry.node)) {\n    return undefined\n  }\n\n  return {node: entry.node, path: entry.path}\n}\n","import type {Path} from '../engine/interfaces/path'\nimport {isBlock} from './is-block'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Determine if a node at the given path is inline.\n *\n * A node is inline if its parent is a text block. This is the inverse of\n * `isBlock`. Top-level nodes are never inline.\n *\n * @beta\n */\nexport function isInline(snapshot: TraversalSnapshot, path: Path): boolean {\n  return !isBlock(snapshot, path)\n}\n","import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getAncestors} from './get-ancestors'\nimport {getBlock} from './is-block'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Walk up from a path to find the nearest enclosing block.\n *\n * Returns the node at the path if it is a block, otherwise the first ancestor\n * that is a block. Works at any depth — inside a container this returns the\n * container-internal block, not the outer container.\n *\n * With `match`, returns the first enclosing block that also satisfies the\n * predicate. When `match` is a type predicate, the returned `node` narrows\n * to that type.\n *\n * `mode: 'lowest'` (default) returns the innermost enclosing block; the node\n * at the path itself counts. `mode: 'highest'` returns the outermost\n * ancestor that matches, falling back to the node at the path only if no\n * ancestor does.\n *\n * @beta\n */\nexport function getEnclosingBlock<TMatch extends PortableTextBlock>(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {\n    match: (node: PortableTextBlock, path: Path) => node is TMatch\n    mode?: 'lowest' | 'highest'\n  },\n): {node: TMatch; path: Path} | undefined\n/**\n * @beta\n */\nexport function getEnclosingBlock(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options?: {\n    match?: (node: PortableTextBlock, path: Path) => boolean\n    mode?: 'lowest' | 'highest'\n  },\n): {node: PortableTextBlock; path: Path} | undefined\nexport function getEnclosingBlock(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options?: {\n    match?: (node: PortableTextBlock, path: Path) => boolean\n    mode?: 'lowest' | 'highest'\n  },\n): {node: PortableTextBlock; path: Path} | undefined {\n  const match = options?.match\n  const mode = options?.mode ?? 'lowest'\n\n  if (mode === 'highest') {\n    const ancestors = getAncestors(snapshot, path)\n\n    for (const ancestor of [...ancestors].reverse()) {\n      if (!match || match(ancestor.node, ancestor.path)) {\n        return ancestor\n      }\n    }\n\n    const direct = getBlock(snapshot, path)\n\n    if (direct && (!match || match(direct.node, direct.path))) {\n      return direct\n    }\n\n    return undefined\n  }\n\n  const direct = getBlock(snapshot, path)\n\n  if (direct && (!match || match(direct.node, direct.path))) {\n    return direct\n  }\n\n  for (const ancestor of getAncestors(snapshot, path)) {\n    if (!match || match(ancestor.node, ancestor.path)) {\n      return ancestor\n    }\n  }\n\n  return undefined\n}\n","import {comparePaths} from '../engine/path/compare-paths'\nimport type {EditorSelectionPoint} from '../types/editor'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Returns:\n *\n * - `-1` if `pointA` is before `pointB`\n * - `0` if `pointA` and `pointB` are equal\n * - `1` if `pointA` is after `pointB`.\n *\n * Compares the two points by document order, resolved at any depth. When\n * the paths are equal, compares offsets.\n *\n * @beta\n */\nexport function comparePoints(\n  snapshot: TraversalSnapshot,\n  pointA: EditorSelectionPoint,\n  pointB: EditorSelectionPoint,\n): -1 | 0 | 1 {\n  const pathComparison = comparePaths(pointA.path, pointB.path, {\n    value: snapshot.context.value,\n  })\n\n  if (pathComparison !== 0) {\n    return pathComparison\n  }\n\n  if (pointA.offset < pointB.offset) {\n    return -1\n  }\n\n  if (pointA.offset > pointB.offset) {\n    return 1\n  }\n\n  return 0\n}\n","import type {Path} from '../engine/interfaces/path'\nimport {getAncestors} from '../traversal/get-ancestors'\nimport {isObject} from '../traversal/is-object'\nimport type {TraversalSnapshot} from '../traversal/traversal-snapshot'\nimport type {RegisteredContainer} from './container-types'\nimport {resolveContainerAt} from './resolve-container-at'\n\n/**\n * Descent primitive: return the immediate parent\n * {@link RegisteredContainer} of the node at `path` (and that parent's\n * path), or `undefined` when the target's immediate parent is the\n * editor root, when no object-node ancestor is a registered container,\n * or when descent hits an ancestor whose `_type` is not registered.\n *\n * Walks ancestors and resolves each object-node ancestor positionally\n * via {@link resolveContainerAt}. Text-block and span ancestors are\n * skipped - \"container\" here means the enclosing object container,\n * not the text-block holding spans.\n */\nexport function descendToParent(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {parent: RegisteredContainer; parentPath: Path} | undefined {\n  const ancestors = getAncestors(snapshot, path)\n  for (const ancestor of ancestors) {\n    if (!isObject(snapshot, ancestor.node)) {\n      continue\n    }\n    const resolved = resolveContainerAt(\n      snapshot.context.containers,\n      snapshot.context.value,\n      ancestor.path,\n    )\n    if (!resolved || !('field' in resolved)) {\n      return undefined\n    }\n    return {parent: resolved, parentPath: ancestor.path}\n  }\n  return undefined\n}\n","import type {OfDefinition} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport type {TraversalSnapshot} from '../traversal/traversal-snapshot'\nimport {descendToParent} from './descend-to-parent'\n\n/**\n * Return the immediate registered-container ancestor of `path` along\n * with its `of` array (the schema definitions accepted at this position).\n *\n * Position-aware: nested-only registrations (e.g. `cell` registered\n * only inside `table.row.of`) are recognized via the same descent\n * primitive used by all parent-aware traversal.\n *\n * Returns `undefined` when `path` has no registered-container ancestor\n * (i.e. is at the document root) or when descent hits a leaf-resolved\n * ancestor.\n */\nexport function getEnclosingContainer(\n  snapshot: TraversalSnapshot,\n  path: Path,\n):\n  | {\n      of: ReadonlyArray<OfDefinition>\n      path: Path\n    }\n  | undefined {\n  const descent = descendToParent(snapshot, path)\n  if (!descent) {\n    return undefined\n  }\n  return {\n    of: descent.parent.field.of,\n    path: descent.parentPath,\n  }\n}\n","import {getSubSchema, type Schema} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getEnclosingContainer} from '../schema/get-enclosing-container'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Return the `Schema` view that applies at a given path.\n *\n * For paths at the root of the document, or for paths where no ancestor is\n * a registered container, returns the top-level schema. For paths inside a\n * container, walks ancestors to find the nearest container and returns the\n * sub-schema derived from its `of` declaration.\n *\n * @beta\n */\nexport function getPathSubSchema(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): Schema {\n  const enclosing = getEnclosingContainer(snapshot, path)\n\n  if (!enclosing) {\n    return snapshot.context.schema\n  }\n\n  return getSubSchema(snapshot.context.schema, enclosing.of)\n}\n"],"names":["getAncestors","snapshot","path","keyedIndices","i","length","isKeyedSegment","push","context","blockIndexMap","currentChildren","value","isRootLevel","currentParent","ancestorsByDepth","resolvedPath","targetKeyedIndex","segmentIndex","segment","node","index","get","_key","undefined","find","child","at","next","getNodeChildren","slice","children","parent","reverse","hasNode","getNode","resolveContainerAt","containers","resolved","resolveNodeEntry","fieldValue","field","name","Array","isArray","of","entry","type","_type","isEditableContainer","_node","size","isObject","isTypedObject","schema","block","span","comparePaths","another","root","min","Math","currentNode","otherSegment","c","findIndex","otherSegmentIndex","comparePoints","point","result","offset","isAfterPoint","isBackwardRange","range","anchor","focus","rangeEdges","isTextBlockNode","isAncestorPath","getNodes","options","from","to","match","getNodesSimple","getNodesInRange","getChildren","entries","comparePathsInTree","pathA","pathB","keysA","filter","keysB","minDepth","depth","keyA","keyB","matchedNode","has","indexA","indexB","sibling","canStopTraversal","couldContainInRangeNodes","isInRange","nodePath","getSibling","direction","lastSegment","parentPath","currentIndex","siblingIndex","isSpanNode","isBlock","getParent","getBlock","isInline","getEnclosingBlock","mode","ancestors","ancestor","direct","pointA","pointB","pathComparison","descendToParent","getEnclosingContainer","descent","getPathSubSchema","enclosing","getSubSchema"],"mappings":"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"}