@portabletext/editor 7.10.15 → 7.10.17

package/lib/selector.is-at-the-start-of-block-gJIMWRpU.js

@@ -0,0 +1,822 @@
+import { a as getNodeChildren, i as getChildren, n as parentPath, r as getNode, t as getParent, u as isKeyedSegment } from "./get-parent-51Kzgaf9.js";
+import { S as hasNode, _ as comparePoints, a as isInline, b as isEditableContainer, c as isSpanNode, i as getEnclosingBlock, l as getSibling, m as rangeEdges, o as getBlock, p as isTextBlockNode, t as getPathSubSchema, u as getNodes, x as resolveContainerAt, y as isObject } from "./get-path-sub-schema--2I4NJbG.js";
+import { d as getSelectionEndPoint$1, f as isSelectionCollapsed$1, g as isEqualSelectionPoints, m as getBlockEndPoint, n as isListBlock, p as getBlockStartPoint, t as sliceBlocks, u as getSelectionStartPoint$1, v as blockOffsetToSpanSelectionPoint, y as spanSelectionPointToBlockOffset } from "./util.slice-blocks-DQnr9X2s.js";
+import { isSpan, isTextBlock } from "@portabletext/schema";
+/**
+* Returns true if the two ranges share at least one point.
+*
+* Two ranges overlap iff each one's start is at or before the other's end.
+* Adjacent ranges that touch at a single point are considered overlapping.
+*/
+function rangesOverlap(rangeA, rangeB, root) {
+	let [startA, endA] = rangeEdges(rangeA, root), [startB, endB] = rangeEdges(rangeB, root);
+	return comparePoints(startA, endB, root) <= 0 && comparePoints(startB, endA, root) <= 0;
+}
+/**
+* Get the node at the given path if it is inline (a span or inline object).
+*
+* A node is inline if its parent is a text block. Returns the node narrowed
+* to `PortableTextSpan | PortableTextObject`, or `undefined` if the node
+* doesn't exist or is not inline.
+*/
+function getInline(snapshot, path) {
+	let entry = getNode(snapshot, path);
+	if (!(!entry || !isInline(snapshot, entry.path)) && !(!isSpanNode({ schema: snapshot.context.schema }, entry.node) && !isObject(snapshot, entry.node))) return {
+		node: entry.node,
+		path: entry.path
+	};
+}
+/**
+* Returns the child (span or inline object) containing the focus selection,
+* resolved at any depth.
+*
+* @public
+*/
+const getFocusChild = (snapshot) => {
+	let selection = snapshot.context.selection;
+	if (selection) return getInline(snapshot, selection.focus.path);
+}, getFocusInlineObject = (snapshot) => {
+	let focusChild = getFocusChild(snapshot);
+	return focusChild && !isSpanNode(snapshot.context, focusChild.node) ? {
+		node: focusChild.node,
+		path: focusChild.path
+	} : void 0;
+}, getFocusSpan = (snapshot) => {
+	let focusChild = getFocusChild(snapshot);
+	return focusChild && isSpan(snapshot.context, focusChild.node) ? {
+		node: focusChild.node,
+		path: focusChild.path
+	} : void 0;
+}, getFocusBlock = (snapshot) => {
+	let selection = snapshot.context.selection;
+	if (selection) return getEnclosingBlock(snapshot, selection.focus.path);
+}, getFocusTextBlock = (snapshot) => {
+	let focusBlock = getFocusBlock(snapshot);
+	return focusBlock && isTextBlock(snapshot.context, focusBlock.node) ? {
+		node: focusBlock.node,
+		path: focusBlock.path
+	} : void 0;
+};
+/**
+* Set of types that are valid at the root of the editor's value: the
+* configured text-block type plus every registered block-object type.
+*
+* The editor accepts these at the top level of `value` and uses them
+* to validate input and as the implicit accept-list for any payload
+* that escapes registered containers.
+*/
+function getRootAcceptedTypes(schema) {
+	return /* @__PURE__ */ new Set([schema.block.name, ...schema.blockObjects.map((blockObject) => blockObject.name)]);
+}
+/**
+* Returns the portion of the document's value covered by the selection,
+* resolved at any depth.
+*
+* Containers fully inside the selection are preserved verbatim. Containers
+* on the selection boundary are recursed into so only the selected portion
+* of their content is kept. Text blocks on the boundary are span-sliced.
+*
+* The result preserves the full ancestor envelope around the selection. For
+* the clipboard-shaped view that unwraps the envelope toward the selection's
+* lowest common ancestor, see {@link getFragment}.
+*
+* @public
+*/
+const getSelectedValue = (snapshot) => {
+	let selection = snapshot.context.selection;
+	if (!selection) return [];
+	let startPoint = getSelectionStartPoint$1(selection), endPoint = getSelectionEndPoint$1(selection);
+	return !startPoint || !endPoint ? [] : sliceArray({
+		context: snapshot.context,
+		blocks: snapshot.context.value,
+		pathPrefix: [],
+		fieldNameInPrefix: void 0,
+		startEdge: startPoint,
+		endEdge: endPoint
+	});
+};
+function sliceArray({ context, blocks, pathPrefix, fieldNameInPrefix, startEdge, endEdge, parent }) {
+	if (blocks.length === 0) return [];
+	let startIdx = resolveIndex(blocks, pathPrefix, startEdge), endIdx = resolveIndex(blocks, pathPrefix, endEdge);
+	if (startIdx === -1 || endIdx === -1) return [];
+	let [lo, hi, loEdge, hiEdge] = startIdx <= endIdx ? [
+		startIdx,
+		endIdx,
+		startEdge,
+		endEdge
+	] : [
+		endIdx,
+		startIdx,
+		endEdge,
+		startEdge
+	], result = [];
+	for (let i = lo; i <= hi; i++) {
+		let block = blocks[i], blockPath = [
+			...pathPrefix,
+			...fieldNameInPrefix ? [fieldNameInPrefix] : [],
+			{ _key: block._key }
+		], startPointForBlock = i === lo ? loEdge : "array-start", endPointForBlock = i === hi ? hiEdge : "array-end", startInside = edgeIsInside(startPointForBlock, blockPath), endInside = edgeIsInside(endPointForBlock, blockPath);
+		if (!startInside && !endInside) {
+			result.push(block);
+			continue;
+		}
+		if (isTextBlock({ schema: context.schema }, block)) {
+			let sliced = sliceBoundaryTextBlock({
+				context,
+				block,
+				blockPath,
+				startEdge: startPointForBlock,
+				endEdge: endPointForBlock
+			});
+			sliced && result.push(sliced);
+			continue;
+		}
+		let childInfo = getNodeChildren(context, block, parent);
+		if (!childInfo) {
+			result.push(block);
+			continue;
+		}
+		let innerSliced = sliceArray({
+			context,
+			blocks: childInfo.children,
+			pathPrefix: blockPath,
+			fieldNameInPrefix: childInfo.fieldName,
+			startEdge: startPointForBlock,
+			endEdge: endPointForBlock,
+			parent: childInfo.parent
+		}), updatedBlock = { ...block };
+		updatedBlock[childInfo.fieldName] = innerSliced, result.push(updatedBlock);
+	}
+	return result;
+}
+function resolveIndex(blocks, pathPrefix, edge) {
+	return edge === "array-start" ? 0 : edge === "array-end" ? blocks.length - 1 : findBlockIndexForPoint(blocks, pathPrefix, edge);
+}
+function findBlockIndexForPoint(blocks, pathPrefix, point) {
+	let nodeSegmentIndex = pathPrefix.length;
+	nodeSegmentIndex < point.path.length && typeof point.path[nodeSegmentIndex] == "string" && nodeSegmentIndex++;
+	let segment = point.path[nodeSegmentIndex];
+	return segment === void 0 ? -1 : isKeyedSegment(segment) ? blocks.findIndex((block) => block._key === segment._key) : typeof segment == "number" && segment >= 0 && segment < blocks.length ? segment : -1;
+}
+function edgeIsInside(edge, blockPath) {
+	return edge === "array-start" || edge === "array-end" ? !1 : edge.path.length > blockPath.length;
+}
+function sliceBoundaryTextBlock({ context, block, blockPath, startEdge, endEdge }) {
+	if (!isTextBlock({ schema: context.schema }, block)) return block;
+	let firstChild = block.children[0], lastChild = block.children[block.children.length - 1], blockRelativeStart = stripPrefix(startEdge, blockPath, block, {
+		fallback: "block-start",
+		firstChild
+	}), blockRelativeEnd = stripPrefix(endEdge, blockPath, block, {
+		fallback: "block-end",
+		lastChild,
+		context
+	});
+	return sliceBlocks({
+		context: {
+			...context,
+			selection: {
+				anchor: blockRelativeStart,
+				focus: blockRelativeEnd
+			}
+		},
+		blocks: [block]
+	})[0];
+}
+function stripPrefix(edge, blockPath, block, opts) {
+	return edge !== "array-start" && edge !== "array-end" && edge.path.length > blockPath.length ? {
+		path: edge.path.slice(blockPath.length - 1),
+		offset: edge.offset
+	} : opts.fallback === "block-start" ? {
+		path: [
+			{ _key: block._key },
+			"children",
+			{ _key: opts.firstChild?._key ?? "" }
+		],
+		offset: 0
+	} : {
+		path: [
+			{ _key: block._key },
+			"children",
+			{ _key: opts.lastChild?._key ?? "" }
+		],
+		offset: opts.lastChild && opts.context && isSpan({ schema: opts.context.schema }, opts.lastChild) ? opts.lastChild.text.length : 0
+	};
+}
+/**
+* Returns the smallest top-level-valid fragment of the editor's value
+* that covers the current selection.
+*
+* Starts from {@link getSelectedValue}'s envelope and unwraps it toward
+* the selection's lowest common ancestor, stopping at the deepest level
+* whose siblings are all root-accepted types. Intermediate single-child
+* containers (a single row inside a table, a single cell inside a row)
+* are walked through to look for a deeper unwrap target; an intermediate
+* level with multiple siblings (the lowest common ancestor across two
+* cells in one row) ends the walk and the last root-valid wrapping is
+* returned.
+*
+* A selection whose endpoints terminate at the root level (collapsed at
+* a root-level node, or expanded across root siblings without descending
+* into them) is treated as the user pointing AT the named node(s) rather
+* than INTO them; the envelope is returned as-is and the unwrap walk is
+* skipped. This is how a chrome drag carries the container itself rather
+* than its unwrapped content.
+*
+* Backs every registered clipboard converter, `editor.getFragment()`
+* (which projects to blocks only), and the drag preview pipeline (which
+* uses the paths to find DOM nodes). Exposed for custom converters and
+* any consumer that needs the clipboard-shaped view of the current
+* selection without redundant ancestor envelopes.
+*
+* @public
+*/
+const getFragment = (snapshot) => {
+	let envelope = getSelectedValue(snapshot);
+	if (envelope.length === 0) return [];
+	let selection = snapshot.context.selection;
+	if (selection && selection.anchor.path.length <= 1 && selection.focus.path.length <= 1) return envelope.map((block) => ({
+		node: block,
+		path: [{ _key: block._key }]
+	}));
+	let { schema, containers, value } = snapshot.context, rootAcceptedTypes = getRootAcceptedTypes(schema), textBlockName = schema.block.name, lastRootValid = envelope, lastRootValidPrefix = [], current = envelope, pathPrefix = [];
+	for (; current.length === 1;) {
+		let single = current[0], singlePath = [...pathPrefix, { _key: single._key }], container = resolveContainerAt(containers, value, singlePath);
+		if (!container || !("field" in container)) break;
+		let children = single[container.field.name];
+		if (!Array.isArray(children) || children.length === 0) break;
+		let childBlocks = children;
+		if (pathPrefix.push({ _key: single._key }, container.field.name), current = childBlocks, childBlocks.every((block) => block._type === textBlockName || rootAcceptedTypes.has(block._type))) {
+			lastRootValid = childBlocks, lastRootValidPrefix = [...pathPrefix];
+			continue;
+		}
+		if (childBlocks.length !== 1) break;
+	}
+	return lastRootValid.map((block) => ({
+		node: block,
+		path: [...lastRootValidPrefix, { _key: block._key }]
+	}));
+}, getSelectionEndBlock = (snapshot) => {
+	let endPoint = getSelectionEndPoint$1(snapshot.context.selection);
+	if (endPoint) return getFocusBlock({
+		...snapshot,
+		context: {
+			...snapshot.context,
+			selection: {
+				anchor: endPoint,
+				focus: endPoint
+			}
+		}
+	});
+}, getSelectionStartBlock = (snapshot) => {
+	let startPoint = getSelectionStartPoint$1(snapshot.context.selection);
+	if (startPoint) return getFocusBlock({
+		...snapshot,
+		context: {
+			...snapshot.context,
+			selection: {
+				anchor: startPoint,
+				focus: startPoint
+			}
+		}
+	});
+};
+/**
+* Returns true if the supplied selection shares at least one point with the
+* editor's current selection. Resolves at any container depth.
+*
+* Two selections that touch at a single endpoint share that point and are
+* considered overlapping.
+*
+* @public
+*/
+function isOverlappingSelection(selection) {
+	return (snapshot) => {
+		let editorSelection = snapshot.context.selection;
+		return !selection || !editorSelection || !hasNode(snapshot, selection.anchor.path) || !hasNode(snapshot, selection.focus.path) || !hasNode(snapshot, editorSelection.anchor.path) || !hasNode(snapshot, editorSelection.focus.path) ? !1 : rangesOverlap(selection, editorSelection, { value: snapshot.context.value });
+	};
+}
+/**
+* @public
+*/
+const isSelectionCollapsed = (snapshot) => isSelectionCollapsed$1(snapshot.context.selection), isSelectionExpanded$1 = (snapshot) => snapshot.context.selection !== null && !isSelectionCollapsed(snapshot), getSelectedBlocks = (snapshot) => {
+	let selection = snapshot.context.selection;
+	if (!selection) return [];
+	let startPoint = getSelectionStartPoint$1(selection), endPoint = getSelectionEndPoint$1(selection);
+	if (!startPoint || !endPoint) return [];
+	let startRootKey = startPoint.path.find(isKeyedSegment)?._key, endRootKey = endPoint.path.find(isKeyedSegment)?._key;
+	if (startRootKey && startRootKey === endRootKey) {
+		let block = getBlock(snapshot, [{ _key: startRootKey }]);
+		if (block) return [{
+			node: block.node,
+			path: block.path
+		}];
+	}
+	let result = [];
+	for (let entry of getNodes(snapshot, {
+		from: startPoint.path,
+		to: endPoint.path,
+		match: (_, path) => path.length === 1
+	})) {
+		let block = getBlock(snapshot, entry.path);
+		block && result.push({
+			node: block.node,
+			path: block.path
+		});
+	}
+	return result;
+}, isSelectingEntireBlocks = (snapshot) => {
+	if (!snapshot.context.selection) return !1;
+	let startPoint = snapshot.context.selection.backward ? snapshot.context.selection.focus : snapshot.context.selection.anchor, endPoint = snapshot.context.selection.backward ? snapshot.context.selection.anchor : snapshot.context.selection.focus, startBlock = getSelectionStartBlock(snapshot), endBlock = getSelectionEndBlock(snapshot);
+	if (!startBlock || !endBlock) return !1;
+	let startBlockStartPoint = getBlockStartPoint({
+		context: snapshot.context,
+		block: startBlock
+	}), endBlockEndPoint = getBlockEndPoint({
+		context: snapshot.context,
+		block: endBlock
+	});
+	return isEqualSelectionPoints(startBlockStartPoint, startPoint) && isEqualSelectionPoints(endBlockEndPoint, endPoint);
+};
+/**
+* @public
+*/
+function isSelectionExpanded(selection) {
+	return selection ? !isSelectionCollapsed$1(selection) : !1;
+}
+/**
+* @public
+*/
+const getSelectionEndPoint = (snapshot) => {
+	if (snapshot.context.selection) return snapshot.context.selection.backward ? snapshot.context.selection.anchor : snapshot.context.selection.focus;
+}, getNextSpan = (snapshot) => {
+	let point = getSelectionEndPoint(snapshot);
+	if (point) return getSibling(snapshot, point.path, {
+		direction: "next",
+		match: (node) => isSpan(snapshot.context, node)
+	});
+}, getSelectionStartPoint = (snapshot) => {
+	if (snapshot.context.selection) return snapshot.context.selection.backward ? snapshot.context.selection.focus : snapshot.context.selection.anchor;
+}, getPreviousSpan = (snapshot) => {
+	let point = getSelectionStartPoint(snapshot);
+	if (point) return getSibling(snapshot, point.path, {
+		direction: "previous",
+		match: (node) => isSpan(snapshot.context, node)
+	});
+};
+/**
+* Returns the inline children (spans and inline objects) touched by the
+* selection, resolved at any depth.
+*
+* @public
+*/
+function getSelectedChildren(options) {
+	let filter = options?.filter;
+	return (snapshot) => {
+		let startPoint = getSelectionStartPoint$1(snapshot.context.selection), endPoint = getSelectionEndPoint$1(snapshot.context.selection);
+		if (!startPoint || !endPoint) return [];
+		let startChildKey = startPoint.path.findLast(isKeyedSegment)?._key, endChildKey = endPoint.path.findLast(isKeyedSegment)?._key, result = [];
+		if (startChildKey && startChildKey === endChildKey && isInline(snapshot, startPoint.path)) {
+			let node = getNode(snapshot, startPoint.path);
+			if (node) {
+				let child = node.node, skip = !1;
+				child._key === startChildKey && isSpan(snapshot.context, child) && (startPoint.offset >= child.text.length && (skip = !0), endPoint.offset <= 0 && (skip = !0)), !skip && (!filter || filter(child)) && result.push({
+					node: child,
+					path: node.path
+				});
+			}
+			return result;
+		}
+		for (let entry of getNodes(snapshot, {
+			from: startPoint.path,
+			to: endPoint.path,
+			match: (_, path) => isInline(snapshot, path)
+		})) {
+			let child = entry.node;
+			child._key === startChildKey && isSpan(snapshot.context, child) && startPoint.offset >= child.text.length || child._key === endChildKey && isSpan(snapshot.context, child) && endPoint.offset <= 0 || filter && !filter(child) || result.push({
+				node: child,
+				path: entry.path
+			});
+		}
+		return result;
+	};
+}
+/**
+* Returns the spans touched by the selection, resolved at any depth.
+*
+* @public
+*/
+const getSelectedSpans = (snapshot) => snapshot.context.selection ? getSelectedChildren({ filter: (child) => isSpan(snapshot.context, child) })(snapshot) : [], getMarkState = (snapshot) => {
+	if (!snapshot.context.selection) return;
+	let selection = snapshot.context.selection;
+	if (getBlock(snapshot, selection.anchor.path)) {
+		let spanSelectionPoint = blockOffsetToSpanSelectionPoint({
+			snapshot,
+			blockOffset: {
+				path: selection.anchor.path,
+				offset: selection.anchor.offset
+			},
+			direction: selection.backward ? "backward" : "forward"
+		});
+		selection = spanSelectionPoint ? {
+			...selection,
+			anchor: spanSelectionPoint
+		} : selection;
+	}
+	if (getBlock(snapshot, selection.focus.path)) {
+		let spanSelectionPoint = blockOffsetToSpanSelectionPoint({
+			snapshot,
+			blockOffset: {
+				path: selection.focus.path,
+				offset: selection.focus.offset
+			},
+			direction: selection.backward ? "backward" : "forward"
+		});
+		selection = spanSelectionPoint ? {
+			...selection,
+			focus: spanSelectionPoint
+		} : selection;
+	}
+	let focusSpan = getFocusSpan({
+		...snapshot,
+		context: {
+			...snapshot.context,
+			selection
+		}
+	});
+	if (!focusSpan) return;
+	if (isSelectionExpanded(selection)) {
+		let spanInfo = getSelectedSpans({
+			...snapshot,
+			context: {
+				...snapshot.context,
+				selection
+			}
+		}).map((span) => {
+			let block = getParent(snapshot, span.path, { match: (node) => isTextBlock({ schema: snapshot.context.schema }, node) });
+			return {
+				marks: span.node.marks ?? [],
+				decoratorNames: getPathSubSchema(snapshot, span.path).decorators.map((decorator) => decorator.name),
+				markDefKeys: (block?.node.markDefs ?? []).map((markDef) => markDef._key)
+			};
+		}), candidateMarks = /* @__PURE__ */ new Set();
+		for (let { marks: spanMarks } of spanInfo) for (let mark of spanMarks) candidateMarks.add(mark);
+		let marks = [];
+		for (let candidate of candidateMarks) {
+			let isDecoratorSomewhere = spanInfo.some(({ decoratorNames }) => decoratorNames.includes(candidate)), active = !0;
+			for (let { marks: spanMarks, decoratorNames, markDefKeys } of spanInfo) if ((isDecoratorSomewhere ? decoratorNames.includes(candidate) : markDefKeys.includes(candidate)) && !spanMarks.includes(candidate)) {
+				active = !1;
+				break;
+			}
+			active && marks.push(candidate);
+		}
+		return {
+			state: "unchanged",
+			marks
+		};
+	}
+	let decorators = getPathSubSchema(snapshot, focusSpan.path).decorators.map((decorator) => decorator.name), marks = focusSpan.node.marks ?? [], marksWithoutAnnotations = marks.filter((mark) => decorators.includes(mark)), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = focusSpan.node.text.length === 0, atTheBeginningOfSpan = snapshot.context.selection.anchor.offset === 0, atTheEndOfSpan = snapshot.context.selection.anchor.offset === focusSpan.node.text.length, previousSpan = getPreviousSpan({
+		...snapshot,
+		context: {
+			...snapshot.context,
+			selection
+		}
+	}), nextSpan = getNextSpan({
+		...snapshot,
+		context: {
+			...snapshot.context,
+			selection
+		}
+	}), nextSpanAnnotations = nextSpan?.node?.marks?.filter((mark) => !decorators.includes(mark)) ?? [], spanAnnotations = marks.filter((mark) => !decorators.includes(mark)), previousSpanHasAnnotations = previousSpan ? previousSpan.node.marks?.some((mark) => !decorators.includes(mark)) : !1, previousSpanHasSameAnnotations = previousSpan ? previousSpan.node.marks?.filter((mark) => !decorators.includes(mark)).every((mark) => marks.includes(mark)) : !1, previousSpanHasSameAnnotation = previousSpan ? previousSpan.node.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, previousSpanHasSameMarks = previousSpan ? previousSpan.node.marks?.every((mark) => marks.includes(mark)) : !1, nextSpanSharesSomeAnnotations = spanAnnotations.some((mark) => nextSpanAnnotations?.includes(mark));
+	if (spanHasAnnotations && !spanIsEmpty) {
+		if (atTheBeginningOfSpan) {
+			if (previousSpanHasSameMarks || previousSpanHasSameAnnotations) return {
+				state: "changed",
+				previousMarks: marks,
+				marks: previousSpan?.node.marks ?? []
+			};
+			if (previousSpanHasSameAnnotation) return {
+				state: "unchanged",
+				marks: focusSpan.node.marks ?? []
+			};
+			if (!previousSpan) return {
+				state: "changed",
+				previousMarks: marks,
+				marks: []
+			};
+		}
+		if (atTheEndOfSpan) {
+			if (!nextSpan || nextSpanAnnotations.length > 0 && !nextSpanSharesSomeAnnotations) return {
+				state: "changed",
+				previousMarks: marks,
+				marks: []
+			};
+			if (nextSpanSharesSomeAnnotations && nextSpanAnnotations.length < spanAnnotations.length || !nextSpanSharesSomeAnnotations) return {
+				state: "changed",
+				previousMarks: marks,
+				marks: nextSpan?.node.marks ?? []
+			};
+		}
+	}
+	return atTheBeginningOfSpan && !spanIsEmpty && previousSpan ? previousSpanHasAnnotations ? {
+		state: "changed",
+		marks,
+		previousMarks: previousSpan?.node.marks ?? []
+	} : {
+		state: "changed",
+		previousMarks: marks,
+		marks: (previousSpan?.node.marks ?? []).filter((mark) => decorators.includes(mark))
+	} : {
+		state: "unchanged",
+		marks
+	};
+};
+function getActiveAnnotationsMarks(snapshot) {
+	let schema = snapshot.context.schema;
+	return (getMarkState(snapshot)?.marks ?? []).filter((mark) => !schema.decorators.map((decorator) => decorator.name).includes(mark));
+}
+/**
+* Returns the text blocks touched by the selection, resolved at any depth.
+*
+* Walks the tree between the selection endpoints and returns every text
+* block found, regardless of container nesting. For toolbar state and
+* anywhere that needs "text blocks with text in the selection".
+*
+* @public
+*/
+const getSelectedTextBlocks = (snapshot) => {
+	let selection = snapshot.context.selection;
+	if (!selection) return [];
+	let startPoint = getSelectionStartPoint$1(selection), endPoint = getSelectionEndPoint$1(selection);
+	if (!startPoint || !endPoint) return [];
+	let startBlock = getEnclosingBlock(snapshot, startPoint.path), endBlock = getEnclosingBlock(snapshot, endPoint.path);
+	if (startBlock && endBlock && startBlock.node._key === endBlock.node._key && isTextBlock(snapshot.context, startBlock.node)) return [{
+		node: startBlock.node,
+		path: startBlock.path
+	}];
+	let result = [];
+	for (let entry of getNodes(snapshot, {
+		from: startPoint.path,
+		to: endPoint.path,
+		match: (node) => isTextBlock(snapshot.context, node)
+	})) isTextBlock(snapshot.context, entry.node) && result.push({
+		node: entry.node,
+		path: entry.path
+	});
+	return result;
+};
+function getActiveDecorators(snapshot) {
+	let decoratorState = snapshot.decoratorState, markState = getMarkState(snapshot), selectedBlocks = getSelectedTextBlocks(snapshot), decorators = /* @__PURE__ */ new Set();
+	for (let block of selectedBlocks) for (let decorator of getPathSubSchema(snapshot, block.path).decorators) decorators.add(decorator.name);
+	if (decorators.size === 0) for (let decorator of snapshot.context.schema.decorators) decorators.add(decorator.name);
+	let activeDecorators = (markState?.marks ?? []).filter((mark) => decorators.has(mark));
+	for (let decorator in decoratorState) decoratorState[decorator] === !1 ? activeDecorators = activeDecorators.filter((activeDecorator) => activeDecorator !== decorator) : decoratorState[decorator] === !0 && (activeDecorators.includes(decorator) || activeDecorators.push(decorator));
+	return activeDecorators;
+}
+/**
+* Check whether an annotation is active in the given `snapshot`.
+*
+* @public
+*/
+function isActiveAnnotation(annotation, options) {
+	return (snapshot) => {
+		if ((options?.mode ?? "full") === "partial" && isSelectionExpanded$1(snapshot)) return getSelectedValue(snapshot).some((block) => {
+			if (!isTextBlock(snapshot.context, block)) return !1;
+			let annotationKeys = new Set((block.markDefs ?? []).filter((markDef) => markDef._type === annotation).map((markDef) => markDef._key));
+			return annotationKeys.size !== 0 && block.children.some((child) => isSpan(snapshot.context, child) && child.text.length > 0 && child.marks?.some((mark) => annotationKeys.has(mark)));
+		});
+		let selectionMarkDefs = getSelectedTextBlocks(snapshot).flatMap((block) => block.node.markDefs ?? []), activeAnnotations = getActiveAnnotationsMarks(snapshot);
+		return selectionMarkDefs.filter((markDef) => markDef._type === annotation && activeAnnotations.includes(markDef._key)).length > 0;
+	};
+}
+/**
+* @public
+*/
+const getActiveAnnotations = (snapshot) => {
+	if (!snapshot.context.selection) return [];
+	let selectedBlocks = getSelectedTextBlocks(snapshot), markState = getMarkState(snapshot), decoratorNames = /* @__PURE__ */ new Set();
+	for (let block of selectedBlocks) for (let decorator of getPathSubSchema(snapshot, block.path).decorators) decoratorNames.add(decorator.name);
+	if (decoratorNames.size === 0) for (let decorator of snapshot.context.schema.decorators) decoratorNames.add(decorator.name);
+	let activeAnnotations = (markState?.marks ?? []).filter((mark) => !decoratorNames.has(mark));
+	return selectedBlocks.flatMap((block) => block.node.markDefs ?? []).filter((markDef) => activeAnnotations.includes(markDef._key));
+}, getActiveListItem = (snapshot) => {
+	if (!snapshot.context.selection) return;
+	let selectedTextBlocks = getSelectedTextBlocks(snapshot), firstTextBlock = selectedTextBlocks.at(0);
+	if (!firstTextBlock) return;
+	let firstListItem = firstTextBlock.node.listItem;
+	if (firstListItem && selectedTextBlocks.filter((block) => getPathSubSchema(snapshot, block.path).lists.some((l) => l.name === firstListItem)).every((block) => block.node.listItem === firstListItem)) return firstListItem;
+}, getActiveStyle = (snapshot) => {
+	if (!snapshot.context.selection) return;
+	let selectedTextBlocks = getSelectedTextBlocks(snapshot), firstTextBlock = selectedTextBlocks.at(0);
+	if (!firstTextBlock) return;
+	let firstStyle = firstTextBlock.node.style ?? getPathSubSchema(snapshot, firstTextBlock.path).styles.at(0)?.name;
+	if (firstStyle && selectedTextBlocks.filter((block) => getPathSubSchema(snapshot, block.path).styles.some((s) => s.name === firstStyle)).every((block) => (block.node.style ?? getPathSubSchema(snapshot, block.path).styles.at(0)?.name) === firstStyle)) return firstStyle;
+}, getNextInlineObject = (snapshot) => {
+	let point = getSelectionEndPoint(snapshot);
+	if (point) return getSibling(snapshot, point.path, {
+		direction: "next",
+		match: (node) => isObject(snapshot, node)
+	});
+}, getPreviousInlineObject = (snapshot) => {
+	let point = getSelectionStartPoint(snapshot);
+	if (point) return getSibling(snapshot, point.path, {
+		direction: "previous",
+		match: (node) => isObject(snapshot, node)
+	});
+}, getSelectionText = (snapshot) => {
+	let selectedValue = getSelectedValue(snapshot);
+	return collectText(snapshot.context, selectedValue);
+};
+function collectText(context, blocks, parent) {
+	let text = "";
+	for (let block of blocks) {
+		if (isTextBlock(context, block)) {
+			for (let child of block.children) isSpan(context, child) && (text += child.text);
+			continue;
+		}
+		let childInfo = getNodeChildren(context, block, parent);
+		childInfo && (text += collectText(context, childInfo.children, childInfo.parent));
+	}
+	return text;
+}
+/**
+* @public
+* Returns the selection of the of the word the caret is placed in.
+* Note: Only returns a word selection if the current selection is collapsed
+*/
+const getCaretWordSelection = (snapshot) => {
+	if (!snapshot.context.selection || !isSelectionCollapsed(snapshot)) return null;
+	let focusTextBlock = getFocusTextBlock(snapshot), selectionStartPoint = getSelectionStartPoint(snapshot), selectionStartOffset = selectionStartPoint ? spanSelectionPointToBlockOffset({
+		snapshot,
+		selectionPoint: selectionStartPoint
+	}) : void 0;
+	if (!focusTextBlock || !selectionStartPoint || !selectionStartOffset) return null;
+	let previousInlineObject = getPreviousInlineObject(snapshot), blockStartPoint = getBlockStartPoint({
+		context: snapshot.context,
+		block: focusTextBlock
+	}), textDirectlyBefore = getSelectionText({
+		...snapshot,
+		context: {
+			...snapshot.context,
+			selection: {
+				anchor: previousInlineObject ? {
+					path: previousInlineObject.path,
+					offset: 0
+				} : blockStartPoint,
+				focus: selectionStartPoint
+			}
+		}
+	}).split(/\s+/).at(-1), nextInlineObject = getNextInlineObject(snapshot), blockEndPoint = getBlockEndPoint({
+		context: snapshot.context,
+		block: focusTextBlock
+	}), textDirectlyAfter = getSelectionText({
+		...snapshot,
+		context: {
+			...snapshot.context,
+			selection: {
+				anchor: selectionStartPoint,
+				focus: nextInlineObject ? {
+					path: nextInlineObject.path,
+					offset: 0
+				} : blockEndPoint
+			}
+		}
+	}).split(/\s+/).at(0);
+	if ((textDirectlyBefore === void 0 || textDirectlyBefore === "") && (textDirectlyAfter === void 0 || textDirectlyAfter === "")) return null;
+	let caretWordStartOffset = textDirectlyBefore ? {
+		...selectionStartOffset,
+		offset: selectionStartOffset.offset - textDirectlyBefore.length
+	} : selectionStartOffset, caretWordEndOffset = textDirectlyAfter ? {
+		...selectionStartOffset,
+		offset: selectionStartOffset.offset + textDirectlyAfter.length
+	} : selectionStartOffset, caretWordStartSelectionPoint = blockOffsetToSpanSelectionPoint({
+		snapshot,
+		blockOffset: caretWordStartOffset,
+		direction: "backward"
+	}), caretWordEndSelectionPoint = blockOffsetToSpanSelectionPoint({
+		snapshot,
+		blockOffset: caretWordEndOffset,
+		direction: "forward"
+	});
+	if (!caretWordStartSelectionPoint || !caretWordEndSelectionPoint) return null;
+	let caretWordSelection = {
+		anchor: caretWordStartSelectionPoint,
+		focus: caretWordEndSelectionPoint
+	};
+	return isSelectionExpanded$1({
+		...snapshot,
+		context: {
+			...snapshot.context,
+			selection: caretWordSelection
+		}
+	}) ? caretWordSelection : null;
+}, getFocusBlockObject = (snapshot) => {
+	let focusBlock = getFocusBlock(snapshot);
+	if (focusBlock && !isTextBlockNode(snapshot.context, focusBlock.node) && !isEditableContainer(snapshot, focusBlock.node, focusBlock.path)) return {
+		node: focusBlock.node,
+		path: focusBlock.path
+	};
+}, getFocusListBlock = (snapshot) => {
+	let focusTextBlock = getFocusTextBlock(snapshot);
+	return focusTextBlock && isListBlock(snapshot.context, focusTextBlock.node) ? {
+		node: focusTextBlock.node,
+		path: focusTextBlock.path
+	} : void 0;
+}, getLastBlock = (snapshot) => {
+	let focusBlock = getFocusBlock(snapshot);
+	if (focusBlock) {
+		let last = getChildren(snapshot, parentPath(focusBlock.path)).at(-1);
+		if (last) return getBlock(snapshot, last.path);
+	}
+	let node = snapshot.context.value.at(-1);
+	return node ? {
+		node,
+		path: [{ _key: node._key }]
+	} : void 0;
+}, getNextBlock = (snapshot) => {
+	let selectionEndBlock = getSelectionEndBlock(snapshot);
+	if (!selectionEndBlock) return;
+	let next = getSibling(snapshot, selectionEndBlock.path, { direction: "next" });
+	if (next) return getBlock(snapshot, next.path);
+}, getPreviousBlock = (snapshot) => {
+	let selectionStartBlock = getSelectionStartBlock(snapshot);
+	if (!selectionStartBlock) return;
+	let previous = getSibling(snapshot, selectionStartBlock.path, { direction: "previous" });
+	if (previous) return getBlock(snapshot, previous.path);
+}, getSelectionEndChild = (snapshot) => {
+	let endPoint = getSelectionEndPoint$1(snapshot.context.selection);
+	if (endPoint) return getFocusChild({
+		...snapshot,
+		context: {
+			...snapshot.context,
+			selection: {
+				anchor: endPoint,
+				focus: endPoint
+			}
+		}
+	});
+}, getSelectionStartChild = (snapshot) => {
+	let startPoint = getSelectionStartPoint$1(snapshot.context.selection);
+	if (startPoint) return getFocusChild({
+		...snapshot,
+		context: {
+			...snapshot.context,
+			selection: {
+				anchor: startPoint,
+				focus: startPoint
+			}
+		}
+	});
+};
+/**
+* @public
+*/
+function isActiveDecorator(decorator) {
+	return (snapshot) => {
+		if (isSelectionExpanded$1(snapshot)) {
+			let inScopeSpans = getSelectedSpans(snapshot).filter((span) => getPathSubSchema(snapshot, span.path).decorators.some((d) => d.name === decorator));
+			return inScopeSpans.length > 0 && inScopeSpans.every((span) => span.node.marks?.includes(decorator));
+		}
+		return getActiveDecorators(snapshot).includes(decorator);
+	};
+}
+/**
+* @public
+*/
+function isActiveListItem(listItem) {
+	return (snapshot) => getActiveListItem(snapshot) === listItem;
+}
+/**
+* @public
+*/
+function isActiveStyle(style) {
+	return (snapshot) => getActiveStyle(snapshot) === style;
+}
+/**
+* @public
+*/
+function isAtTheEndOfBlock(block) {
+	return (snapshot) => {
+		if (!snapshot.context.selection || !isSelectionCollapsed(snapshot)) return !1;
+		let blockEndPoint = getBlockEndPoint({
+			context: snapshot.context,
+			block
+		});
+		return isEqualSelectionPoints(snapshot.context.selection.focus, blockEndPoint);
+	};
+}
+/**
+* @public
+*/
+function isAtTheStartOfBlock(block) {
+	return (snapshot) => {
+		if (!snapshot.context.selection || !isSelectionCollapsed(snapshot)) return !1;
+		let blockStartPoint = getBlockStartPoint({
+			context: snapshot.context,
+			block
+		});
+		return isEqualSelectionPoints(snapshot.context.selection.focus, blockStartPoint);
+	};
+}
+export { isSelectingEntireBlocks as A, getFocusTextBlock as B, getActiveAnnotationsMarks as C, getSelectionStartPoint as D, getPreviousSpan as E, getSelectionStartBlock as F, getInline as G, getFocusSpan as H, getSelectionEndBlock as I, rangesOverlap as K, getFragment as L, isSelectionExpanded$1 as M, isSelectionCollapsed as N, getNextSpan as O, isOverlappingSelection as P, getSelectedValue as R, getSelectedTextBlocks as S, getSelectedSpans as T, getFocusInlineObject as U, getFocusBlock as V, getFocusChild as W, getActiveStyle as _, isActiveDecorator as a, isActiveAnnotation as b, getPreviousBlock as c, getFocusListBlock as d, getFocusBlockObject as f, getNextInlineObject as g, getPreviousInlineObject as h, isActiveListItem as i, getSelectedBlocks as j, getSelectionEndPoint as k, getNextBlock as l, getSelectionText as m, isAtTheEndOfBlock as n, getSelectionStartChild as o, getCaretWordSelection as p, isActiveStyle as r, getSelectionEndChild as s, isAtTheStartOfBlock as t, getLastBlock as u, getActiveListItem as v, getMarkState as w, getActiveDecorators as x, getActiveAnnotations as y, getRootAcceptedTypes as z };
+
+//# sourceMappingURL=selector.is-at-the-start-of-block-gJIMWRpU.js.map