@portabletext/editor 8.1.1 → 8.1.3

package/README.md

@@ -13,14 +13,14 @@
 
 This library provides you with the building blocks to create a completely custom editor experience built on top of Portable Text. We recommend [checking out the official documentation](https://www.portabletext.org/). The following guide includes the basics to get your started.
 
-In order to set up an editor you'll need to:
+To set up an editor you need to:
 
 - Create a schema that defines the rich text and block content elements.
 - Create a toolbar to toggle and insert these elements.
 - Set up rendering for each element type in the editor, including text blocks and inline formatting.
 - Render the editor.
 
-Check out the [Portable Text Playground](../../apps/playground/) for a comprehensive example of the editor in action.
+The [Portable Text Playground](../../apps/playground/) is a complete editor built with this library. Use it as a reference.
 
 ### Add the library to your project
 
@@ -361,7 +361,7 @@ Extend the editor with [official plugins](../../#editor-plugins).
 
 ## End-user experience
 
-In order to provide a robust and consistent end-user experience, the editor is backed by an elaborate E2E test suite generated from a [human-readable Gherkin spec](./gherkin-spec/).
+A large E2E test suite, generated from a [human-readable Gherkin spec](./gherkin-spec/), guards the end-user experience: how selection, editing, and formatting behave under real keyboard and pointer input.
 
 ## Development
 

package/lib/{behavior.types.action-C0XDEQnB.d.ts → behavior.types.action-DbwK30_J.d.ts}

@@ -1417,6 +1417,10 @@ type InvalidValueResolution = {
 };
 /** @beta */
 type OnPasteResult = {
+  /**
+   * Delivered as-is to the `insert.blocks` Behavior event and validated
+   * against the schema when inserted.
+   */
   insert?: TypedObject[];
   path?: Path;
 } | undefined;
@@ -1639,6 +1643,10 @@ type SetSelectionOperation = {
  * @beta
  */
 type EngineOperation = InsertOperation | SetOperation | UnsetOperation | SetSelectionOperation | InsertTextOperation | RemoveTextOperation;
+type DecoratedRange = Range & {
+  rangeDecoration: RangeDecoration;
+  merge: (leaf: PortableTextSpan, decoration: object) => void;
+};
 /**
  * `RangeRef` objects keep a specific range in a document synced over time as new
  * operations are applied to the editor. You can access their `current` property
@@ -1892,22 +1900,36 @@ type OperationEvent = {
    * entry.
    */
   operationsInProgress: boolean;
-  isNormalizingNode: boolean;
   isPatching: boolean;
-  isProcessingRemoteChanges: boolean;
-  isUndoing: boolean;
-  isRedoing: boolean;
   withHistory: boolean;
   undoStepId: string | undefined;
   /**
-   * Derived from the engine flags above, for declarative filtering.
+   * Derived from `applyContext`, for declarative filtering.
    */
   origin: OperationOrigin;
+  /**
+   * A frozen snapshot of `editor.applyContext` at apply entry: the frame
+   * stack `origin` was derived from.
+   */
+  context: ReadonlyArray<ApplyContextFrame>;
 };
 type OperationListener = (event: OperationEvent) => void;
-type DecoratedRange = Range & {
-  rangeDecoration: RangeDecoration;
-  merge: (leaf: PortableTextSpan, decoration: object) => void;
+/**
+ * A frame pushed onto `editor.applyContext` for the duration of an
+ * attribution bracket (remote changes, undo, redo, normalization). Brackets
+ * nest, so a normalization that fires while replaying a remote patch pushes
+ * a `normalization` frame on top of the still-active `remote` one; both
+ * stay visible to `getOrigin` below instead of only the innermost.
+ */
+type ApplyContextFrame = {
+  kind: 'remote';
+  source: 'patches' | 'update-value' | 'initial-sync';
+} | {
+  kind: 'undo';
+} | {
+  kind: 'redo';
+} | {
+  kind: 'normalization';
 };
 type HistoryItem = {
   operations: EngineOperation[];
@@ -1926,6 +1948,13 @@ type RemotePatch = {
 interface PortableTextEditorEngine extends DOMEditor {
   _key: 'editor';
   _type: 'editor';
+  /**
+   * The attribution bracket stack: pushed on entry and popped in `finally`
+   * by `withRemoteChanges`, `pluginUndoing`, `pluginRedoing`, and the
+   * normalization brackets. `getOrigin` (`engine/core/apply-context.ts`)
+   * reduces it to an `OperationOrigin`.
+   */
+  applyContext: Array<ApplyContextFrame>;
   containers: ResolvedContainers;
   annotations: Map<string, AnnotationConfig>;
   blockObjects: Map<string, BlockObjectConfig>;
@@ -1963,26 +1992,24 @@ interface PortableTextEditorEngine extends DOMEditor {
   undoStepId: string | undefined;
   isDeferringMutations: boolean;
   /**
-   * The last host value written in by value sync. A pristine block equal
-   * to it is persisted content, not the local placeholder.
+   * The last host value recorded by a value sync that changed the engine. A
+   * pristine block equal to it is persisted content, not the local
+   * placeholder. Syncs that write nothing are not recorded: hosts mirror
+   * `mutation.value` back as `update value`, and such an echo of the
+   * editor's own state (its placeholder included) is not a claim that the
+   * value is persisted.
    */
   lastSyncedValue: Array<PortableTextBlock> | undefined;
-  isNormalizingNode: boolean;
-  isPatching: boolean;
-  isPerformingBehaviorOperation: boolean;
   /**
-   * True while the editor applies content that arrived from outside:
-   * remote `patches` and value sync.
-   *
-   * Normalization reads this flag to leave adopted content alone. While
-   * it is set, only repairs of invalid structure run (missing `_key` or
-   * `text`, empty blocks). Optional fix-ups (merging same-mark spans,
-   * filling in `style`/`marks`/`markDefs` defaults) wait until a local
-   * edit touches the block and then emit as part of that edit.
+   * True after patch generation emits a became-empty `unset([])`, until it
+   * emits the field's rebuild (`setIfMissing` plus the block `insert`).
+   * While true, the emitted stream has destroyed the field, so the next
+   * content-producing local edit must re-materialize it even if a synced
+   * value makes the placeholder look persisted.
    */
-  isProcessingRemoteChanges: boolean;
-  isRedoing: boolean;
-  isUndoing: boolean;
+  valueUnsetEmitted: boolean;
+  isPatching: boolean;
+  isPerformingBehaviorOperation: boolean;
   withHistory: boolean;
   /**
    * The current {@link EditorSnapshot}. Reassigned (new object reference)
@@ -3412,4 +3439,4 @@ type BehaviorActionSet<TBehaviorEvent, TGuardResponse> = (payload: {
   dom: EditorDom;
 }, guardResponse: TGuardResponse) => Array<BehaviorAction>;
 export { BehaviorGuard as $, defineBlockObject as $t, PortableTextSpan$1 as A, Annotation as At, usePortableTextEditor as B, DecoratorRender as Bt, ListDefinition as C, EditorSchema as Ct, PortableTextBlock$1 as D, RegisteredInlineObject as Dt, Patch$1 as E, RegisteredContainer as Et, defineSchema as F, BlockObjectRenderProps as Ft, Editor as G, RegistrableNode as Gt, useEditorSelector as H, InlineObject as Ht, BlockOffset as I, Container as It, EditorEmittedEvent as J, SpanRenderProps as Jt, EditorConfig as K, Span as Kt, useEditor as L, ContainerRender as Lt, SchemaDefinition$1 as M, AnnotationRenderProps as Mt, StyleDefinition as N, BlockObject as Nt, PortableTextChild$1 as O, RegisteredPositional as Ot, StyleSchemaType as P, BlockObjectRender as Pt, defineBehavior as Q, defineAnnotation as Qt, defaultKeyGenerator as R, ContainerRenderProps as Rt, InlineObjectSchemaType as S, Node$1 as St, OfDefinition$1 as T, RegisteredBlockObject as Tt, EditorProvider as U, InlineObjectRender as Ut, EditorSelector as V, DecoratorRenderProps as Vt, EditorProviderProps as W, InlineObjectRenderProps as Wt, Operation as X, TextBlockRender as Xt, MutationEvent as Y, TextBlock as Yt, Behavior as Z, TextBlockRenderProps as Zt, BlockObjectSchemaType as _, PortableTextEditable as _t, forward as a, AnnotationPath as an, EditorSelectionPoint as at, FieldDefinition$1 as b, PortableTextEditor as bt, CustomBehaviorEvent as c, KeyedSegment as cn, OnPasteFn as ct, SyntheticBehaviorEvent as d, PasteData as dt, defineContainer as en, EditorContext as et, PatchesEvent as f, RangeDecoration as ft, BlockObjectDefinition as g, ScrollSelectionIntoViewFunction as gt, BaseDefinition as h, RenderPlaceholderFunction as ht, execute as i, defineTextBlock as in, EditorSelection as it, PortableTextTextBlock$1 as j, AnnotationRender as jt, PortableTextObject$1 as k, RegisteredSpan as kt, InsertPlacement as l, Path as ln, OnPasteResult as lt, AnnotationSchemaType as m, RenderEditableFunction as mt, BehaviorActionSet as n, defineInlineObject as nn, AddedAnnotationPaths as nt, raise$1 as o, BlockPath as on, InvalidValueResolution as ot, AnnotationDefinition as p, RangeDecorationOnMovedDetails as pt, EditorEvent as q, SpanRender as qt, effect as r, defineSpan as rn, EditableAPIDeleteOptions as rt, BehaviorEvent as s, ChildPath as sn, OnCopyFn as st, BehaviorAction as t, defineDecorator as tn, EditorSnapshot as tt, NativeBehaviorEvent as u, PathSegment as un, OnPasteResultOrPromise as ut, DecoratorDefinition as v, PortableTextEditableProps as vt, ListSchemaType as w, Containers as wt, InlineObjectDefinition as x, TraversalSnapshot as xt, DecoratorSchemaType as y, HotkeyOptions as yt, usePortableTextEditorSelection as z, Decorator as zt };
-//# sourceMappingURL=behavior.types.action-C0XDEQnB.d.ts.map
+//# sourceMappingURL=behavior.types.action-DbwK30_J.d.ts.map

package/lib/behavior.types.action-DbwK30_J.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"behavior.types.action-DbwK30_J.d.ts","names":[],"sources":["../src/internal-utils/mime-type.ts","../src/type-utils.ts","../src/converters/converter.types.ts","../src/types/paths.ts","../src/renderers/renderer.types.ts","../src/schema/container-types.ts","../src/editor/editor-schema.ts","../src/engine/interfaces/node.ts","../src/traversal/traversal-snapshot.ts","../src/editor/PortableTextEditor.tsx","../src/types/options.ts","../src/editor/Editable.tsx","../src/types/editor.ts","../src/engine/types/types.ts","../src/engine/interfaces/point.ts","../src/engine/interfaces/range.ts","../src/engine/interfaces/operation.ts","../src/editor/range-decorations-machine.ts","../src/engine/interfaces/range-ref.ts","../src/engine/dom/utils/diff-text.ts","../src/engine/dom/utils/dom.ts","../src/engine/dom/plugin/dom-editor.ts","../src/engine/interfaces/location.ts","../src/engine/interfaces/path-ref.ts","../src/engine/interfaces/point-ref.ts","../src/engine/interfaces/editor.ts","../src/engine/core/operation-channel.ts","../src/engine/core/apply-context.ts","../src/types/editor-engine.ts","../src/editor/editor-snapshot.ts","../src/behaviors/behavior.types.guard.ts","../src/behaviors/behavior.types.behavior.ts","../src/types/operation.ts","../src/editor/relay.ts","../src/editor.ts","../src/editor/editor-provider.tsx","../src/editor/editor-selector.ts","../src/editor/usePortableTextEditor.ts","../src/editor/usePortableTextEditorSelection.tsx","../src/utils/key-generator.ts","../src/editor/use-editor.ts","../src/types/block-offset.ts","../src/priority/priority.types.ts","../src/behaviors/behavior.config.ts","../src/editor/editor-machine.ts","../src/internal-utils/event-position.ts","../src/types/block-with-optional-key.ts","../src/behaviors/behavior.types.event.ts","../src/editor/editor-dom.ts","../src/behaviors/behavior.types.action.ts"],"mappings":"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"}

package/lib/behaviors/index.d.ts

@@ -1,2 +1,2 @@
-import { $ as BehaviorGuard, Q as defineBehavior, Z as Behavior, a as forward, c as CustomBehaviorEvent, d as SyntheticBehaviorEvent, i as execute, l as InsertPlacement, n as BehaviorActionSet, o as raise, r as effect, s as BehaviorEvent, t as BehaviorAction, u as NativeBehaviorEvent } from "../behavior.types.action-C0XDEQnB.js";
+import { $ as BehaviorGuard, Q as defineBehavior, Z as Behavior, a as forward, c as CustomBehaviorEvent, d as SyntheticBehaviorEvent, i as execute, l as InsertPlacement, n as BehaviorActionSet, o as raise, r as effect, s as BehaviorEvent, t as BehaviorAction, u as NativeBehaviorEvent } from "../behavior.types.action-DbwK30_J.js";
 export { type Behavior, type BehaviorAction, type BehaviorActionSet, type BehaviorEvent, type BehaviorGuard, type CustomBehaviorEvent, type InsertPlacement, type NativeBehaviorEvent, type SyntheticBehaviorEvent, defineBehavior, effect, execute, forward, raise };

package/lib/{get-container-D2pN5Npr.js → get-container-CXdmRdiX.js}

@@ -1,5 +1,5 @@
-import { a as getChildren, d as isKeyedSegment, r as getNode } from "./get-parent-DgaKcy8-.js";
-import { C as getAncestors, _ as comparePoints, b as isEditableContainer, g as isAfterPoint, m as rangeEdges, r as comparePoints$1, u as getNodes, v as comparePaths, y as isObject$1 } from "./get-path-sub-schema-Dd0QYZ0m.js";
+import { a as getChildren, p as isKeyedSegment, r as getNode } from "./get-parent-BLzi7eLr.js";
+import { C as getAncestors, _ as comparePoints, b as isEditableContainer, g as isAfterPoint, m as rangeEdges, r as comparePoints$1, u as getNodes, v as comparePaths, y as isObject$1 } from "./get-path-sub-schema-DsN1qF_l.js";
 import { getSubSchema, isSpan, isTextBlock } from "@portabletext/schema";
 function getAncestor(snapshot, path, options) {
 	let { match, mode = "lowest" } = options, ancestors = getAncestors(snapshot, path);
@@ -219,4 +219,4 @@ function getContainer(snapshot, path) {
 }
 export { getAncestor as _, getTextBlock as a, pathContains as c, isRange as d, isPoint as f, isLeafObject as g, getLeaf as h, getFirstChild as i, getSpan as l, isPath as m, getUnionSchema as n, rangeIntersects as o, isObject as p, getLastChild as r, isBeforePoint as s, getContainer as t, getText as u };
 
-//# sourceMappingURL=get-container-D2pN5Npr.js.map
+//# sourceMappingURL=get-container-CXdmRdiX.js.map

package/lib/{get-container-D2pN5Npr.js.map → get-container-CXdmRdiX.js.map}

@@ -1 +1 @@
-{"version":3,"file":"get-container-D2pN5Npr.js","names":[],"sources":["../src/traversal/get-ancestor.ts","../src/traversal/is-leaf-object.ts","../src/traversal/get-leaf.ts","../src/engine/path/is-path.ts","../src/engine/utils/is-object.ts","../src/engine/point/is-point.ts","../src/engine/range/is-range.ts","../src/traversal/get-text.ts","../src/traversal/get-span.ts","../src/traversal/path-contains.ts","../src/engine/point/is-before-point.ts","../src/traversal/range-intersects.ts","../src/traversal/get-text-block.ts","../src/traversal/get-first-child.ts","../src/traversal/get-last-child.ts","../src/traversal/get-union-schema.ts","../src/traversal/get-container.ts"],"sourcesContent":["import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getAncestors} from './get-ancestors'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Find an ancestor of the node at a given path that matches a predicate.\n * Does not check the node at the path itself, only its ancestors.\n *\n * `mode: 'lowest'` (default) returns the nearest matching ancestor.\n * `mode: 'highest'` returns the outermost matching ancestor.\n *\n * When `match` is a type predicate, the returned `node` narrows to that type.\n *\n * @public\n */\nexport function getAncestor<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 * @public\n */\nexport function getAncestor(\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 getAncestor(\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, mode = 'lowest'} = options\n  const ancestors = getAncestors(snapshot, path)\n\n  if (mode === 'highest') {\n    for (const ancestor of [...ancestors].reverse()) {\n      if (match(ancestor.node, ancestor.path)) {\n        return ancestor\n      }\n    }\n    return undefined\n  }\n\n  for (const ancestor of ancestors) {\n    if (match(ancestor.node, ancestor.path)) {\n      return ancestor\n    }\n  }\n\n  return undefined\n}\n","import type {PortableTextObject} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {isEditableContainer} from '../schema/is-editable-container'\nimport {isObject} from './is-object'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Check if a node is a leaf object: an object node that has no editable\n * children (not a container).\n * Returns true for block objects and inline objects that don't have\n * registered editable content (containers).\n *\n * @public\n */\nexport function isLeafObject(\n  snapshot: TraversalSnapshot,\n  node: unknown,\n  path: Path,\n): node is PortableTextObject {\n  return isObject(snapshot, node) && !isEditableContainer(snapshot, node, path)\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {getChildren} from './get-children'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the deepest leaf node starting from a path, walking toward either the\n * start or end edge. A leaf is any node that has no children according to the\n * traversal context.\n *\n * @public\n */\nexport function getLeaf(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {edge: 'start' | 'end'},\n): {node: Node; path: Path} | undefined {\n  const {edge} = options\n\n  let currentPath = path\n\n  // If starting from root (empty path), descend into first/last child\n  if (currentPath.length === 0) {\n    const children = getChildren(snapshot, [])\n    if (children.length === 0) {\n      return undefined\n    }\n    const firstOrLast = edge === 'end' ? children.at(-1)! : children.at(0)!\n    const nodeChildren = getChildren(snapshot, firstOrLast.path)\n    if (nodeChildren.length === 0) {\n      return firstOrLast\n    }\n    currentPath = firstOrLast.path\n  } else {\n    // Check if the node at path is already a leaf\n    const entry = getNode(snapshot, currentPath)\n    if (!entry) {\n      return undefined\n    }\n    const children = getChildren(snapshot, currentPath)\n    if (children.length === 0) {\n      return entry\n    }\n  }\n\n  // Descend to deepest leaf\n  while (true) {\n    const children = getChildren(snapshot, currentPath)\n    if (children.length === 0) {\n      const entry = getNode(snapshot, currentPath)\n      return entry ?? undefined\n    }\n    const child = edge === 'end' ? children.at(-1)! : children.at(0)!\n    currentPath = child.path\n  }\n}\n","import {isKeyedSegment} from '../../utils/util.is-keyed-segment'\nimport type {Path} from '../interfaces/path'\n\nexport function isPath(value: any): value is Path {\n  return (\n    Array.isArray(value) &&\n    (value.length === 0 ||\n      typeof value[0] === 'number' ||\n      typeof value[0] === 'string' ||\n      isKeyedSegment(value[0]))\n  )\n}\n","export const isObject = (value: any) =>\n  typeof value === 'object' && value !== null\n","import type {Point} from '../interfaces/point'\nimport {isPath} from '../path/is-path'\nimport {isObject} from '../utils/is-object'\n\nexport function isPoint(value: any): value is Point {\n  return (\n    isObject(value) && typeof value.offset === 'number' && isPath(value.path)\n  )\n}\n","import type {Range} from '../interfaces/range'\nimport {isPoint} from '../point/is-point'\nimport {isObject} from '../utils/is-object'\n\nexport function isRange(value: any): value is Range {\n  return isObject(value) && isPoint(value.anchor) && isPoint(value.focus)\n}\n","import {isSpan} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getNode} from './get-node'\nimport {getNodes} from './get-nodes'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the concatenated text content of the node at a given path.\n *\n * @public\n */\nexport function getText(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): string | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (isSpan({schema: snapshot.context.schema}, entry.node)) {\n    return entry.node.text\n  }\n\n  let text = ''\n\n  for (const descendant of getNodes(snapshot, {at: path})) {\n    if (isSpan({schema: snapshot.context.schema}, descendant.node)) {\n      text += descendant.node.text\n    }\n  }\n\n  return text\n}\n","import {isSpan, type PortableTextSpan} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the span node at a given path.\n *\n * @public\n */\nexport function getSpan(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: PortableTextSpan; path: Path} | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (!isSpan({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 '../types/paths'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\n\n/**\n * Returns true if `ancestor` is equal to `descendant`, or if `descendant`\n * lives anywhere inside `ancestor`'s subtree.\n *\n * @public\n */\nexport function pathContains(ancestor: Path, descendant: Path): boolean {\n  if (ancestor.length > descendant.length) {\n    return false\n  }\n\n  for (let i = 0; i < ancestor.length; i++) {\n    const segment = ancestor[i]\n    const otherSegment = descendant[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 {Node} from '../interfaces/node'\nimport type {Point} from '../interfaces/point'\nimport {comparePoints} from './compare-points'\n\nexport function isBeforePoint(\n  point: Point,\n  another: Point,\n  root: {value: Array<Node>},\n): boolean {\n  return comparePoints(point, another, root) === -1\n}\n","import {comparePaths} from '../engine/path/compare-paths'\nimport {isAfterPoint} from '../engine/point/is-after-point'\nimport {isBeforePoint} from '../engine/point/is-before-point'\nimport {isPoint} from '../engine/point/is-point'\nimport {isRange} from '../engine/range/is-range'\nimport {rangeEdges} from '../engine/range/range-edges'\nimport type {EditorSelection, EditorSelectionPoint} from '../types/editor'\nimport type {Path} from '../types/paths'\nimport {comparePoints} from './compare-points'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Returns true if `range` and the supplied `target` intersect. The target\n * may be a `Path`, an `EditorSelectionPoint`, or another\n * `EditorSelection`.\n *\n * For a `Path` or `EditorSelectionPoint` target, \"intersect\" means the\n * target lies at or between `range`'s start and end edges (inclusive).\n *\n * For an `EditorSelection` target, \"intersect\" means either endpoint of\n * `target` lies inside `range`, or `range` strictly encloses `target`.\n *\n * Pass `snapshot.context.selection` as `range` to ask the question against\n * the editor's current selection.\n *\n * Returns `false` when either `range` or `target` is `null`.\n *\n * @public\n */\nexport function rangeIntersects(\n  snapshot: TraversalSnapshot,\n  range: EditorSelection,\n  target: Path | EditorSelectionPoint | EditorSelection,\n): boolean {\n  if (!range || target === null) {\n    return false\n  }\n\n  const root = {value: snapshot.context.value}\n\n  if (isRange(target)) {\n    if (\n      rangeIntersects(snapshot, range, target.anchor) ||\n      rangeIntersects(snapshot, range, target.focus)\n    ) {\n      return true\n    }\n    const [rs, re] = rangeEdges(range, root)\n    const [ts, te] = rangeEdges(target, root)\n    return isBeforePoint(rs, ts, root) && isAfterPoint(re, te, root)\n  }\n\n  const [start, end] = rangeEdges(range, root)\n  let isAfterStart = false\n  let isBeforeEnd = false\n\n  if (isPoint(target)) {\n    isAfterStart = comparePoints(snapshot, target, start) >= 0\n    isBeforeEnd = comparePoints(snapshot, target, end) <= 0\n  } else {\n    isAfterStart = comparePaths(target, start.path, root) >= 0\n    isBeforeEnd = comparePaths(target, end.path, root) <= 0\n  }\n\n  return isAfterStart && isBeforeEnd\n}\n","import {isTextBlock, type PortableTextTextBlock} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the text block node at a given path.\n *\n * @public\n */\nexport function getTextBlock(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: PortableTextTextBlock; path: Path} | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (!isTextBlock({schema: snapshot.context.schema}, entry.node)) {\n    return undefined\n  }\n\n  return {node: entry.node, path: entry.path}\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {getChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the first child of a node at a given path.\n *\n * @public\n */\nexport function getFirstChild(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; path: Path} | undefined {\n  return getChildren(snapshot, path).at(0)\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {getChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the last child of a node at a given path.\n *\n * @public\n */\nexport function getLastChild(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; path: Path} | undefined {\n  const children = getChildren(snapshot, path)\n\n  return children.at(-1)\n}\n","import {getSubSchema, type Schema} from '@portabletext/schema'\nimport type {Containers} from '../schema/resolve-containers'\n\n/**\n * Return a `Schema` that contains every named member declared anywhere\n * in the editor's schema graph that is reachable from a position where text\n * is edited - the root schema merged with the sub-schema of every registered\n * container whose field accepts text blocks, deduped by name. Useful for\n * rendering a static toolbar whose buttons stay stable across selection\n * moves while still reflecting everything that could plausibly be edited or\n * inserted somewhere.\n *\n * Containers whose field does NOT accept text blocks (e.g. a `table`\n * container whose `rows` field only accepts `row` objects, or a `row`\n * container whose `cells` field only accepts `cell` objects) are\n * **structural**: their immediate `of` types are organizational, not\n * insertable user content. Those structural types are excluded from the\n * union. Their nested text-block-accepting descendants (e.g. a `cell`\n * that contains a `content` field of `{type: 'block'}`) are reached via\n * those descendants' own container registration.\n *\n * Pair with `getPathSubSchema` (or a path-based intersection across a\n * range) to determine which of the union's members are applicable at the\n * current selection.\n *\n * @public\n */\nexport function getUnionSchema(schema: Schema, containers: Containers): Schema {\n  const decorators = mergeByName(schema.decorators, [])\n  const annotations = mergeByName(schema.annotations, [])\n  const lists = mergeByName(schema.lists, [])\n  const styles = mergeByName(schema.styles, [])\n  const inlineObjects = mergeByName(schema.inlineObjects, [])\n  const blockObjects = mergeByName(schema.blockObjects, [])\n\n  for (const container of containers.values()) {\n    if (!acceptsTextBlock(container.field.of, schema.block.name)) {\n      continue\n    }\n    const sub = getSubSchema(schema, container.field.of)\n    mergeByName(sub.decorators, decorators)\n    mergeByName(sub.annotations, annotations)\n    mergeByName(sub.lists, lists)\n    mergeByName(sub.styles, styles)\n    mergeByName(sub.inlineObjects, inlineObjects)\n    mergeByName(sub.blockObjects, blockObjects)\n  }\n\n  return {\n    ...schema,\n    decorators,\n    annotations,\n    lists,\n    styles,\n    inlineObjects,\n    blockObjects,\n  }\n}\n\nfunction acceptsTextBlock(\n  of: ReadonlyArray<{type: string}>,\n  blockName: string,\n): boolean {\n  return of.some(\n    (member) => member.type === 'block' || member.type === blockName,\n  )\n}\n\nfunction mergeByName<T extends {name: string}>(\n  source: ReadonlyArray<T>,\n  target: Array<T>,\n): Array<T> {\n  for (const entry of source) {\n    if (target.some((existing) => existing.name === entry.name)) {\n      continue\n    }\n    target.push(entry)\n  }\n  return target\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {isEditableContainer} from '../schema/is-editable-container'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the registered editable container at a given path.\n *\n * @public\n */\nexport function getContainer(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; path: Path} | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (!isEditableContainer(snapshot, entry.node, entry.path)) {\n    return undefined\n  }\n\n  return {node: entry.node, path: entry.path}\n}\n"],"mappings":"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"}
+{"version":3,"file":"get-container-CXdmRdiX.js","names":[],"sources":["../src/traversal/get-ancestor.ts","../src/traversal/is-leaf-object.ts","../src/traversal/get-leaf.ts","../src/engine/path/is-path.ts","../src/engine/utils/is-object.ts","../src/engine/point/is-point.ts","../src/engine/range/is-range.ts","../src/traversal/get-text.ts","../src/traversal/get-span.ts","../src/traversal/path-contains.ts","../src/engine/point/is-before-point.ts","../src/traversal/range-intersects.ts","../src/traversal/get-text-block.ts","../src/traversal/get-first-child.ts","../src/traversal/get-last-child.ts","../src/traversal/get-union-schema.ts","../src/traversal/get-container.ts"],"sourcesContent":["import type {PortableTextBlock} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getAncestors} from './get-ancestors'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Find an ancestor of the node at a given path that matches a predicate.\n * Does not check the node at the path itself, only its ancestors.\n *\n * `mode: 'lowest'` (default) returns the nearest matching ancestor.\n * `mode: 'highest'` returns the outermost matching ancestor.\n *\n * When `match` is a type predicate, the returned `node` narrows to that type.\n *\n * @public\n */\nexport function getAncestor<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 * @public\n */\nexport function getAncestor(\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 getAncestor(\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, mode = 'lowest'} = options\n  const ancestors = getAncestors(snapshot, path)\n\n  if (mode === 'highest') {\n    for (const ancestor of [...ancestors].reverse()) {\n      if (match(ancestor.node, ancestor.path)) {\n        return ancestor\n      }\n    }\n    return undefined\n  }\n\n  for (const ancestor of ancestors) {\n    if (match(ancestor.node, ancestor.path)) {\n      return ancestor\n    }\n  }\n\n  return undefined\n}\n","import type {PortableTextObject} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {isEditableContainer} from '../schema/is-editable-container'\nimport {isObject} from './is-object'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Check if a node is a leaf object: an object node that has no editable\n * children (not a container).\n * Returns true for block objects and inline objects that don't have\n * registered editable content (containers).\n *\n * @public\n */\nexport function isLeafObject(\n  snapshot: TraversalSnapshot,\n  node: unknown,\n  path: Path,\n): node is PortableTextObject {\n  return isObject(snapshot, node) && !isEditableContainer(snapshot, node, path)\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {getChildren} from './get-children'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the deepest leaf node starting from a path, walking toward either the\n * start or end edge. A leaf is any node that has no children according to the\n * traversal context.\n *\n * @public\n */\nexport function getLeaf(\n  snapshot: TraversalSnapshot,\n  path: Path,\n  options: {edge: 'start' | 'end'},\n): {node: Node; path: Path} | undefined {\n  const {edge} = options\n\n  let currentPath = path\n\n  // If starting from root (empty path), descend into first/last child\n  if (currentPath.length === 0) {\n    const children = getChildren(snapshot, [])\n    if (children.length === 0) {\n      return undefined\n    }\n    const firstOrLast = edge === 'end' ? children.at(-1)! : children.at(0)!\n    const nodeChildren = getChildren(snapshot, firstOrLast.path)\n    if (nodeChildren.length === 0) {\n      return firstOrLast\n    }\n    currentPath = firstOrLast.path\n  } else {\n    // Check if the node at path is already a leaf\n    const entry = getNode(snapshot, currentPath)\n    if (!entry) {\n      return undefined\n    }\n    const children = getChildren(snapshot, currentPath)\n    if (children.length === 0) {\n      return entry\n    }\n  }\n\n  // Descend to deepest leaf\n  while (true) {\n    const children = getChildren(snapshot, currentPath)\n    if (children.length === 0) {\n      const entry = getNode(snapshot, currentPath)\n      return entry ?? undefined\n    }\n    const child = edge === 'end' ? children.at(-1)! : children.at(0)!\n    currentPath = child.path\n  }\n}\n","import {isKeyedSegment} from '../../utils/util.is-keyed-segment'\nimport type {Path} from '../interfaces/path'\n\nexport function isPath(value: any): value is Path {\n  return (\n    Array.isArray(value) &&\n    (value.length === 0 ||\n      typeof value[0] === 'number' ||\n      typeof value[0] === 'string' ||\n      isKeyedSegment(value[0]))\n  )\n}\n","export const isObject = (value: any) =>\n  typeof value === 'object' && value !== null\n","import type {Point} from '../interfaces/point'\nimport {isPath} from '../path/is-path'\nimport {isObject} from '../utils/is-object'\n\nexport function isPoint(value: any): value is Point {\n  return (\n    isObject(value) && typeof value.offset === 'number' && isPath(value.path)\n  )\n}\n","import type {Range} from '../interfaces/range'\nimport {isPoint} from '../point/is-point'\nimport {isObject} from '../utils/is-object'\n\nexport function isRange(value: any): value is Range {\n  return isObject(value) && isPoint(value.anchor) && isPoint(value.focus)\n}\n","import {isSpan} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getNode} from './get-node'\nimport {getNodes} from './get-nodes'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the concatenated text content of the node at a given path.\n *\n * @public\n */\nexport function getText(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): string | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (isSpan({schema: snapshot.context.schema}, entry.node)) {\n    return entry.node.text\n  }\n\n  let text = ''\n\n  for (const descendant of getNodes(snapshot, {at: path})) {\n    if (isSpan({schema: snapshot.context.schema}, descendant.node)) {\n      text += descendant.node.text\n    }\n  }\n\n  return text\n}\n","import {isSpan, type PortableTextSpan} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the span node at a given path.\n *\n * @public\n */\nexport function getSpan(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: PortableTextSpan; path: Path} | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (!isSpan({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 '../types/paths'\nimport {isKeyedSegment} from '../utils/util.is-keyed-segment'\n\n/**\n * Returns true if `ancestor` is equal to `descendant`, or if `descendant`\n * lives anywhere inside `ancestor`'s subtree.\n *\n * @public\n */\nexport function pathContains(ancestor: Path, descendant: Path): boolean {\n  if (ancestor.length > descendant.length) {\n    return false\n  }\n\n  for (let i = 0; i < ancestor.length; i++) {\n    const segment = ancestor[i]\n    const otherSegment = descendant[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 {Node} from '../interfaces/node'\nimport type {Point} from '../interfaces/point'\nimport {comparePoints} from './compare-points'\n\nexport function isBeforePoint(\n  point: Point,\n  another: Point,\n  root: {value: Array<Node>},\n): boolean {\n  return comparePoints(point, another, root) === -1\n}\n","import {comparePaths} from '../engine/path/compare-paths'\nimport {isAfterPoint} from '../engine/point/is-after-point'\nimport {isBeforePoint} from '../engine/point/is-before-point'\nimport {isPoint} from '../engine/point/is-point'\nimport {isRange} from '../engine/range/is-range'\nimport {rangeEdges} from '../engine/range/range-edges'\nimport type {EditorSelection, EditorSelectionPoint} from '../types/editor'\nimport type {Path} from '../types/paths'\nimport {comparePoints} from './compare-points'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Returns true if `range` and the supplied `target` intersect. The target\n * may be a `Path`, an `EditorSelectionPoint`, or another\n * `EditorSelection`.\n *\n * For a `Path` or `EditorSelectionPoint` target, \"intersect\" means the\n * target lies at or between `range`'s start and end edges (inclusive).\n *\n * For an `EditorSelection` target, \"intersect\" means either endpoint of\n * `target` lies inside `range`, or `range` strictly encloses `target`.\n *\n * Pass `snapshot.context.selection` as `range` to ask the question against\n * the editor's current selection.\n *\n * Returns `false` when either `range` or `target` is `null`.\n *\n * @public\n */\nexport function rangeIntersects(\n  snapshot: TraversalSnapshot,\n  range: EditorSelection,\n  target: Path | EditorSelectionPoint | EditorSelection,\n): boolean {\n  if (!range || target === null) {\n    return false\n  }\n\n  const root = {value: snapshot.context.value}\n\n  if (isRange(target)) {\n    if (\n      rangeIntersects(snapshot, range, target.anchor) ||\n      rangeIntersects(snapshot, range, target.focus)\n    ) {\n      return true\n    }\n    const [rs, re] = rangeEdges(range, root)\n    const [ts, te] = rangeEdges(target, root)\n    return isBeforePoint(rs, ts, root) && isAfterPoint(re, te, root)\n  }\n\n  const [start, end] = rangeEdges(range, root)\n  let isAfterStart = false\n  let isBeforeEnd = false\n\n  if (isPoint(target)) {\n    isAfterStart = comparePoints(snapshot, target, start) >= 0\n    isBeforeEnd = comparePoints(snapshot, target, end) <= 0\n  } else {\n    isAfterStart = comparePaths(target, start.path, root) >= 0\n    isBeforeEnd = comparePaths(target, end.path, root) <= 0\n  }\n\n  return isAfterStart && isBeforeEnd\n}\n","import {isTextBlock, type PortableTextTextBlock} from '@portabletext/schema'\nimport type {Path} from '../engine/interfaces/path'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the text block node at a given path.\n *\n * @public\n */\nexport function getTextBlock(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: PortableTextTextBlock; path: Path} | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (!isTextBlock({schema: snapshot.context.schema}, entry.node)) {\n    return undefined\n  }\n\n  return {node: entry.node, path: entry.path}\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {getChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the first child of a node at a given path.\n *\n * @public\n */\nexport function getFirstChild(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; path: Path} | undefined {\n  return getChildren(snapshot, path).at(0)\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {getChildren} from './get-children'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the last child of a node at a given path.\n *\n * @public\n */\nexport function getLastChild(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; path: Path} | undefined {\n  const children = getChildren(snapshot, path)\n\n  return children.at(-1)\n}\n","import {getSubSchema, type Schema} from '@portabletext/schema'\nimport type {Containers} from '../schema/resolve-containers'\n\n/**\n * Return a `Schema` that contains every named member declared anywhere\n * in the editor's schema graph that is reachable from a position where text\n * is edited - the root schema merged with the sub-schema of every registered\n * container whose field accepts text blocks, deduped by name. Useful for\n * rendering a static toolbar whose buttons stay stable across selection\n * moves while still reflecting everything that could plausibly be edited or\n * inserted somewhere.\n *\n * Containers whose field does NOT accept text blocks (e.g. a `table`\n * container whose `rows` field only accepts `row` objects, or a `row`\n * container whose `cells` field only accepts `cell` objects) are\n * **structural**: their immediate `of` types are organizational, not\n * insertable user content. Those structural types are excluded from the\n * union. Their nested text-block-accepting descendants (e.g. a `cell`\n * that contains a `content` field of `{type: 'block'}`) are reached via\n * those descendants' own container registration.\n *\n * Pair with `getPathSubSchema` (or a path-based intersection across a\n * range) to determine which of the union's members are applicable at the\n * current selection.\n *\n * @public\n */\nexport function getUnionSchema(schema: Schema, containers: Containers): Schema {\n  const decorators = mergeByName(schema.decorators, [])\n  const annotations = mergeByName(schema.annotations, [])\n  const lists = mergeByName(schema.lists, [])\n  const styles = mergeByName(schema.styles, [])\n  const inlineObjects = mergeByName(schema.inlineObjects, [])\n  const blockObjects = mergeByName(schema.blockObjects, [])\n\n  for (const container of containers.values()) {\n    if (!acceptsTextBlock(container.field.of, schema.block.name)) {\n      continue\n    }\n    const sub = getSubSchema(schema, container.field.of)\n    mergeByName(sub.decorators, decorators)\n    mergeByName(sub.annotations, annotations)\n    mergeByName(sub.lists, lists)\n    mergeByName(sub.styles, styles)\n    mergeByName(sub.inlineObjects, inlineObjects)\n    mergeByName(sub.blockObjects, blockObjects)\n  }\n\n  return {\n    ...schema,\n    decorators,\n    annotations,\n    lists,\n    styles,\n    inlineObjects,\n    blockObjects,\n  }\n}\n\nfunction acceptsTextBlock(\n  of: ReadonlyArray<{type: string}>,\n  blockName: string,\n): boolean {\n  return of.some(\n    (member) => member.type === 'block' || member.type === blockName,\n  )\n}\n\nfunction mergeByName<T extends {name: string}>(\n  source: ReadonlyArray<T>,\n  target: Array<T>,\n): Array<T> {\n  for (const entry of source) {\n    if (target.some((existing) => existing.name === entry.name)) {\n      continue\n    }\n    target.push(entry)\n  }\n  return target\n}\n","import type {Node} from '../engine/interfaces/node'\nimport type {Path} from '../engine/interfaces/path'\nimport {isEditableContainer} from '../schema/is-editable-container'\nimport {getNode} from './get-node'\nimport type {TraversalSnapshot} from './traversal-snapshot'\n\n/**\n * Get the registered editable container at a given path.\n *\n * @public\n */\nexport function getContainer(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; path: Path} | undefined {\n  const entry = getNode(snapshot, path)\n\n  if (!entry) {\n    return undefined\n  }\n\n  if (!isEditableContainer(snapshot, entry.node, entry.path)) {\n    return undefined\n  }\n\n  return {node: entry.node, path: entry.path}\n}\n"],"mappings":"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"}

package/lib/{get-parent-DgaKcy8-.js → get-parent-BLzi7eLr.js}

@@ -15,6 +15,23 @@ function isKeyedSegment(segment) {
 function serializePath(path) {
 	return path.reduce((result, segment, index) => isKeyedSegment(segment) ? `${result}[_key=="${segment._key}"]` : `${result}${index === 0 ? "" : "."}${segment}`, "");
 }
+/**
+* A key only addresses a node when it's a non-empty string; sync payloads
+* and hand-authored content can carry `undefined`, `null`, or `''`.
+*/
+function hasUsableKey(key) {
+	return typeof key == "string" && key !== "";
+}
+/**
+* The path segment that identifies `node` among its siblings: keyed when
+* the node has a usable `_key`, otherwise the sibling index. A fabricated
+* `{_key: undefined}` segment identifies nothing (several keyless siblings
+* would all canonicalize to the same segment), so producers of resolved
+* paths must fall back to the index until normalization mints a key.
+*/
+function nodeSegment(node, index) {
+	return hasUsableKey(node._key) ? { _key: node._key } : index;
+}
 function isTypedObject(object) {
 	return isRecord(object) && typeof object._type == "string";
 }
@@ -77,21 +94,22 @@ function getChildren(snapshot, path) {
 			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 }] : [
+		let nodeIndex = currentChildren.indexOf(node);
+		currentPath = isRoot ? [nodeSegment(node, nodeIndex)] : [
 			...currentPath,
 			currentFieldName,
-			{ _key: node._key }
+			nodeSegment(node, nodeIndex)
 		], isRoot = !1;
 		let next = getNodeChildren(snapshot.context, node, currentParent);
 		if (!next) return [];
 		currentChildren = next.children, currentFieldName = next.fieldName, currentParent = next.parent;
 	}
-	return currentChildren.map((child) => ({
+	return currentChildren.map((child, childIndex) => ({
 		node: child,
-		path: isRoot ? [{ _key: child._key }] : [
+		path: isRoot ? [nodeSegment(child, childIndex)] : [
 			...currentPath,
 			currentFieldName,
-			{ _key: child._key }
+			nodeSegment(child, childIndex)
 		]
 	}));
 }
@@ -139,11 +157,14 @@ function getNodeChildren(context, node, parent) {
 * field name strings name a structural descent into the previous
 * node's children, and numbers are resolved by index.
 *
-* The returned `path` always identifies the returned node: it's fully
-* keyed (numeric indices are converted to `KeyedSegment`s) and any
-* trailing segments in the input that point outside the value tree —
-* e.g. an object node's primitive field, or an annotation reached via
-* `'markDefs'` on a text block — are stripped so that
+* The returned `path` always identifies the returned node: segments
+* are keyed wherever the node has a usable `_key` (numeric indices are
+* converted to `KeyedSegment`s), and stay numeric for nodes
+* normalization has not keyed yet (a `{_key: undefined}` segment would
+* not distinguish keyless siblings). Any trailing segments in the
+* input that point outside the value tree — e.g. an object node's
+* primitive field, or an annotation reached via `'markDefs'` on a text
+* block — are stripped so that
 * `getNode(snapshot, entry.path).node === entry.node`.
 *
 * The walk stops when a string segment names a field that isn't the
@@ -177,8 +198,12 @@ function resolveNode(snapshot, path) {
 		if (isKeyedSegment(segment)) {
 			resolvedPath.push(segment);
 			let 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 });
+			if (index !== void 0 && currentChildren[index]?._key === segment._key) node = currentChildren[index];
+			else {
+				let scanIndex = currentChildren.findIndex((child) => child._key === segment._key);
+				node = scanIndex === -1 ? void 0 : currentChildren[scanIndex], node && (resolvedPath[resolvedPath.length - 1] = nodeSegment(node, scanIndex));
+			}
+		} else if (typeof segment == "number") node = currentChildren.at(segment), node && resolvedPath.push(nodeSegment(node, segment));
 		else return { status: "missing" };
 		if (!node) return { status: "missing" };
 		let hasMoreSegments = !1;
@@ -238,6 +263,6 @@ function getParent(snapshot, path, options) {
 	};
 	if (!(options?.match && !options.match(result.node, result.path))) return result;
 }
-export { getChildren as a, isRecord as c, isKeyedSegment as d, resolveNode as i, isTypedObject as l, parentPath as n, getNodeChildren as o, getNode as r, getContainerChildren as s, getParent as t, serializePath as u };
+export { getChildren as a, isRecord as c, nodeSegment as d, serializePath as f, resolveNode as i, isTypedObject as l, parentPath as n, getNodeChildren as o, isKeyedSegment as p, getNode as r, getContainerChildren as s, getParent as t, hasUsableKey as u };
 
-//# sourceMappingURL=get-parent-DgaKcy8-.js.map
+//# sourceMappingURL=get-parent-BLzi7eLr.js.map

package/lib/get-parent-BLzi7eLr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-parent-BLzi7eLr.js","names":[],"sources":["../src/utils/util.is-keyed-segment.ts","../src/paths/serialize-path.ts","../src/paths/node-segment.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 {KeyedSegment} from '../types/paths'\n\n/**\n * A key only addresses a node when it's a non-empty string; sync payloads\n * and hand-authored content can carry `undefined`, `null`, or `''`.\n */\nexport function hasUsableKey(key: unknown): key is string {\n  return typeof key === 'string' && key !== ''\n}\n\n/**\n * The path segment that identifies `node` among its siblings: keyed when\n * the node has a usable `_key`, otherwise the sibling index. A fabricated\n * `{_key: undefined}` segment identifies nothing (several keyless siblings\n * would all canonicalize to the same segment), so producers of resolved\n * paths must fall back to the index until normalization mints a key.\n */\nexport function nodeSegment(\n  node: {_key?: unknown},\n  index: number,\n): KeyedSegment | number {\n  return hasUsableKey(node._key) ? {_key: node._key} : index\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 {nodeSegment} from '../paths/node-segment'\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 * @public\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    const nodeIndex = currentChildren.indexOf(node)\n    currentPath = isRoot\n      ? [nodeSegment(node, nodeIndex)]\n      : [...currentPath, currentFieldName, nodeSegment(node, nodeIndex)]\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, childIndex) => ({\n    node: child,\n    path: isRoot\n      ? [nodeSegment(child, childIndex)]\n      : [...currentPath, currentFieldName, nodeSegment(child, childIndex)],\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 {nodeSegment} from '../paths/node-segment'\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: segments\n * are keyed wherever the node has a usable `_key` (numeric indices are\n * converted to `KeyedSegment`s), and stay numeric for nodes\n * normalization has not keyed yet (a `{_key: undefined}` segment would\n * not distinguish keyless siblings). Any trailing segments in the\n * input that point outside the value tree — e.g. an object node's\n * primitive field, or an annotation reached via `'markDefs'` on a text\n * 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 * @public\n */\nexport function getNode(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): {node: Node; path: Path} | undefined {\n  const result = resolveNode(snapshot, path)\n  return result.status === 'found' ? result.entry : undefined\n}\n\n/**\n * Result of walking a path against a snapshot.\n *\n * `unreachable` is the one outcome that means \"structurally impossible\n * by design\": the path digs past a sidecar field (e.g. `markDefs` on\n * a text block) into a keyed/indexed segment, which `getNode` can\n * never resolve (use `getAnnotation` for annotations). Every other\n * negative outcome is `missing`; on those branches a caller bug and a\n * benign race (the node removed by a concurrent edit) produce the\n * same state, so they cannot be told apart.\n */\nexport type ResolveNodeResult =\n  | {status: 'found'; entry: {node: Node; path: Path}}\n  | {status: 'missing'}\n  | {status: 'unreachable'}\n\nexport function resolveNode(\n  snapshot: TraversalSnapshot,\n  path: Path,\n): ResolveNodeResult {\n  if (path.length === 0) {\n    return {status: 'missing'}\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); report unreachable.\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 {status: 'unreachable'}\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        const scanIndex = currentChildren.findIndex(\n          (child) => child._key === segment._key,\n        )\n        node = scanIndex === -1 ? undefined : currentChildren[scanIndex]\n        if (node) {\n          resolvedPath[resolvedPath.length - 1] = nodeSegment(node, scanIndex)\n        }\n      }\n    } else if (typeof segment === 'number') {\n      node = currentChildren.at(segment)\n      if (node) {\n        resolvedPath.push(nodeSegment(node, segment))\n      }\n    } else {\n      return {status: 'missing'}\n    }\n\n    if (!node) {\n      return {status: 'missing'}\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 {status: 'missing'}\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 {status: 'missing'}\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 {status: 'found', entry: {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 * @public\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 * @public\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"],"mappings":"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"}

package/lib/{get-path-sub-schema-Dd0QYZ0m.js → get-path-sub-schema-DsN1qF_l.js}

@@ -1,4 +1,4 @@
-import { a as getChildren, d as isKeyedSegment, l as isTypedObject, n as parentPath, o as getNodeChildren, r as getNode, t as getParent, u as serializePath } from "./get-parent-DgaKcy8-.js";
+import { a as getChildren, d as nodeSegment, f as serializePath, l as isTypedObject, n as parentPath, o as getNodeChildren, p as isKeyedSegment, r as getNode, t as getParent } from "./get-parent-BLzi7eLr.js";
 import { getSubSchema } from "@portabletext/schema";
 /**
 * Get all ancestors of the node at a given path, from nearest to furthest.
@@ -18,7 +18,7 @@ import { getSubSchema } from "@portabletext/schema";
 */
 function getAncestors(snapshot, path) {
 	let keyedIndices = [];
-	for (let i = 0; i < path.length; i++) isKeyedSegment(path[i]) && keyedIndices.push(i);
+	for (let i = 0; i < path.length; i++) (isKeyedSegment(path[i]) || typeof path[i] == "number") && keyedIndices.push(i);
 	if (keyedIndices.length <= 1) return [];
 	let { context, blockIndexMap } = snapshot, currentChildren = context.value, currentParent, ancestorsByDepth = [], resolvedPath = [], targetKeyedIndex = keyedIndices[keyedIndices.length - 1], segmentIndex = 0;
 	for (; segmentIndex < targetKeyedIndex;) {
@@ -31,8 +31,12 @@ function getAncestors(snapshot, path) {
 		if (isKeyedSegment(segment)) {
 			resolvedPath.push(segment);
 			let 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 });
+			if (index !== void 0 && currentChildren[index]?._key === segment._key) node = currentChildren[index];
+			else {
+				let scanIndex = currentChildren.findIndex((child) => child._key === segment._key);
+				node = scanIndex === -1 ? void 0 : currentChildren[scanIndex], node && (resolvedPath[resolvedPath.length - 1] = nodeSegment(node, scanIndex));
+			}
+		} else if (typeof segment == "number") node = currentChildren.at(segment), node && resolvedPath.push(nodeSegment(node, segment));
 		else return [];
 		if (!node) return [];
 		let next = getNodeChildren(context, node, currentParent);
@@ -510,4 +514,4 @@ function getPathSubSchema(snapshot, path) {
 }
 export { getAncestors as C, hasNode as S, comparePoints$1 as _, isInline as a, isEditableContainer as b, isSpanNode as c, resolveChildEntryIndex as d, isAncestorPath as f, isAfterPoint as g, isBackwardRange as h, getEnclosingBlock as i, getSibling as l, rangeEdges as m, getEnclosingContainer as n, getBlock as o, isTextBlockNode as p, comparePoints as r, isBlock as s, getPathSubSchema as t, getNodes as u, comparePaths as v, resolveContainerAt as x, isObject as y };
 
-//# sourceMappingURL=get-path-sub-schema-Dd0QYZ0m.js.map
+//# sourceMappingURL=get-path-sub-schema-DsN1qF_l.js.map