svedit 0.11.1 → 0.12.0

package/dist/paste_utils.d.ts

@@ -14,10 +14,11 @@ export function get_text_property_name(node_type: string | null | undefined, sch
 /**
  * @param {any} node
  * @param {DocumentSchema} schema
- * @returns {{ text: string, annotations: any[] } | null}
+ * @returns {{ content: string, marks: any[], annotations: any[] } | null}
  */
 export function get_text_content(node: any, schema: DocumentSchema): {
-    text: string;
+    content: string;
+    marks: any[];
     annotations: any[];
 } | null;
 /**

package/dist/paste_utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paste_utils.d.ts","sourceRoot":"","sources":["../src/lib/paste_utils.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH,uDAEC;AAED,wDAkCC;AAED,kEAKC;AAED,oFAEC;AAED;;;;GAIG;AACH,kDAJW,MAAM,GAAG,IAAI,GAAG,SAAS,UACzB,cAAc,GACZ,MAAM,GAAG,IAAI,CAYzB;AAED;;;;GAIG;AACH,uCAJW,GAAG,UACH,cAAc,GACZ;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,GAAG,EAAE,CAAA;CAAE,GAAG,IAAI,CAoBvD;AAED;;;;GAIG;AACH,gDAJW,GAAG,UACH,cAAc,GACZ,OAAO,CAMnB;AAED;;;;GAIG;AACH,sEAJW,GAAG,UACH,cAAc,GACZ,MAAM,GAAG,IAAI,CAmBzB;AAED;;;;;GAKG;AACH,qEALW,MAAM,EAAE,aACR,MAAM,GAAG,IAAI,GAAG,SAAS,UACzB,cAAc,GACZ;IAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,GAAG,IAAI,CA8BvE;oCArKkC,cAAc"}
+{"version":3,"file":"paste_utils.d.ts","sourceRoot":"","sources":["../src/lib/paste_utils.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH,uDAEC;AAED,wDAkCC;AAED,kEAKC;AAED,oFAEC;AAED;;;;GAIG;AACH,kDAJW,MAAM,GAAG,IAAI,GAAG,SAAS,UACzB,cAAc,GACZ,MAAM,GAAG,IAAI,CAYzB;AAED;;;;GAIG;AACH,uCAJW,GAAG,UACH,cAAc,GACZ;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,GAAG,EAAE,CAAC;IAAC,WAAW,EAAE,GAAG,EAAE,CAAA;CAAE,GAAG,IAAI,CAqBxE;AAED;;;;GAIG;AACH,gDAJW,GAAG,UACH,cAAc,GACZ,OAAO,CAMnB;AAED;;;;GAIG;AACH,sEAJW,GAAG,UACH,cAAc,GACZ,MAAM,GAAG,IAAI,CAoBzB;AAED;;;;;GAKG;AACH,qEALW,MAAM,EAAE,aACR,MAAM,GAAG,IAAI,GAAG,SAAS,UACzB,cAAc,GACZ;IAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAAE,GAAG,IAAI,CA+BvE;oCAxKkC,cAAc"}

package/dist/paste_utils.js

@@ -62,10 +62,10 @@ export function get_text_property_name(node_type, schema) {
 	if (!node_type) return null;
 	const node_schema = schema[node_type];
 	if (!node_schema || node_schema.kind !== 'text') return null;
-	if (node_schema.properties?.content?.type === 'annotated_text') return 'content';
+	if (node_schema.properties?.content?.type === 'text') return 'content';
 	return (
 		Object.entries(node_schema.properties).find(([, property_definition]) => {
-			return property_definition.type === 'annotated_text';
+			return property_definition.type === 'text';
 		})?.[0] || null
 	);
 }
@@ -73,22 +73,23 @@ export function get_text_property_name(node_type, schema) {
 /**
  * @param {any} node
  * @param {DocumentSchema} schema
- * @returns {{ text: string, annotations: any[] } | null}
+ * @returns {{ content: string, marks: any[], annotations: any[] } | null}
  */
 export function get_text_content(node, schema) {
 	if (!node || typeof node !== 'object') return null;
 
+	const is_text_value = (value) =>
+		value &&
+		typeof value.content === 'string' &&
+		Array.isArray(value.marks) &&
+		Array.isArray(value.annotations);
+
 	const text_property_name = get_text_property_name(node.type, schema);
-	if (
-		text_property_name &&
-		node[text_property_name] &&
-		typeof node[text_property_name].text === 'string' &&
-		Array.isArray(node[text_property_name].annotations)
-	) {
+	if (text_property_name && is_text_value(node[text_property_name])) {
 		return node[text_property_name];
 	}
 
-	if (node.content && typeof node.content.text === 'string' && Array.isArray(node.content.annotations)) {
+	if (is_text_value(node.content)) {
 		return node.content;
 	}
 
@@ -125,8 +126,9 @@ export function get_default_text_node(node_array_property_definition, schema) {
 	}
 
 	return (
-		node_array_property_definition.node_types.find((node_type) => schema[node_type]?.kind === 'text') ||
-		null
+		node_array_property_definition.node_types.find(
+			(node_type) => schema[node_type]?.kind === 'text'
+		) || null
 	);
 }
 
@@ -156,7 +158,8 @@ export function create_plain_text_nodes_payload(paragraph_fragments, node_type,
 			id: node_id,
 			type: node_type,
 			[text_property_name]: {
-				text: fragment,
+				content: fragment,
+				marks: [],
 				annotations: []
 			}
 		};

package/dist/transforms.svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transforms.svelte.d.ts","sourceRoot":"","sources":["../src/lib/transforms.svelte.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,mCAJW,MAAM,2BAEN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QAM7B;AAED,kDAqDC;AAED,iDAoEC;AAED,sDAuBC"}
+{"version":3,"file":"transforms.svelte.d.ts","sourceRoot":"","sources":["../src/lib/transforms.svelte.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,mCAJW,MAAM,2BAEN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QAM7B;AAED,kDAoDC;AAED,iDAoEC;AAED,sDAuBC"}

package/dist/transforms.svelte.js

@@ -1,4 +1,4 @@
-import { split_annotated_text, join_annotated_text, get_char_length } from './utils.js';
+import { split_text, join_text, get_char_length } from './utils.js';
 import { get_default_node_type } from './doc_utils.js';
 
 /**
@@ -32,7 +32,6 @@ export function break_text_node(tr) {
 	// Get the node that owns the node_array property (e.g. a page.body)
 	const node_array_node = tr.get(selection.path.slice(0, -3));
 
-
 	// Delete selection unless collapsed
 	if (selection.anchor_offset !== selection.focus_offset) {
 		tr.delete_selection();
@@ -40,7 +39,7 @@ export function break_text_node(tr) {
 
 	const split_at_position = tr.selection.anchor_offset;
 	const content = tr.get(selection.path);
-	const [left_text, right_text] = split_annotated_text(content, split_at_position);
+	const [left_text, right_text] = split_text(content, split_at_position);
 
 	tr.set([node.id, 'content'], left_text);
 
@@ -93,7 +92,7 @@ export function join_text_node(tr) {
 	}
 
 	// Special behavior: if we can't join and current node is empty, delete it
-	if (!can_join && node.content.text === '') {
+	if (!can_join && node.content.content === '') {
 		tr.set_selection({
 			type: 'node',
 			path: tr.selection.path.slice(0, -2),
@@ -111,10 +110,10 @@ export function join_text_node(tr) {
 
 	// Normal joining logic - both nodes are text nodes
 	const previous_text_path = [...tr.selection.path.slice(0, -2), node_index - 1];
-	const joined_text = join_annotated_text(predecessor_node.content, node.content);
+	const joined_text = join_text(predecessor_node.content, node.content);
 
 	// Calculate caret position based on original predecessor content length
-	const caret_position = get_char_length(predecessor_node.content.text);
+	const caret_position = get_char_length(predecessor_node.content.content);
 
 	// First set the joined content on the predecessor node (preserves annotations)
 	tr.set([predecessor_node.id, 'content'], joined_text);

package/dist/types.d.ts

@@ -81,7 +81,7 @@ export type ArrayType = 'string_array' | 'number_array' | 'boolean_array' | 'int
 /**
  * Special types for rich content.
  */
-export type RichType = 'annotated_text';
+export type RichType = 'text';
 
 /**
  * Node reference types for linking to other nodes.
@@ -112,7 +112,7 @@ export type PropertyType = PrimitiveType | ReferenceType;
 // 	| 'number_array'
 // 	| 'boolean_array'
 // 	| 'integer_array'
-// 	| 'annotated_text'
+// 	| 'text'
 // 	| 'node'
 // 	| 'node_array';
 //
@@ -134,7 +134,7 @@ export type PropertyType = PrimitiveType | ReferenceType;
 // 								? Array<boolean>
 // 								: T extends 'integer_array'
 // 									? Array<number>
-// 									: T extends 'annotated_text'
+// 									: T extends 'text'
 // 										? AnnotatedText
 // 										: T extends 'node'
 // 											? string
@@ -147,11 +147,12 @@ export type PropertyType = PrimitiveType | ReferenceType;
 // };
 
 /**
- * A property that stores an annotated text with required allow_newlines setting.
+ * A property that stores text with optional marks and annotations and required allow_newlines setting.
  */
-export type AnnotatedTextProperty = {
-	type: 'annotated_text';
-	node_types?: string[];
+export type TextProperty = {
+	type: 'text';
+	mark_types?: string[];
+	annotation_types?: string[];
 	allow_newlines: boolean;
 };
 
@@ -228,7 +229,7 @@ export type IntegerArrayProperty = {
 };
 
 /**
- * A property that stores a primitive value (excluding annotated_text).
+ * A property that stores a primitive value (excluding text).
  */
 export type PrimitiveProperty =
 	| StringProperty
@@ -256,6 +257,8 @@ export type NodeProperty = {
 export type NodeArrayProperty = {
 	type: 'node_array';
 	node_types: string[];
+	mark_types?: string[];
+	annotation_types?: string[];
 	default_node_type?: string;
 };
 
@@ -263,29 +266,26 @@ export type NodeArrayProperty = {
  * Union type for all possible property definitions.
  */
 export type PropertyDefinition =
-	| PrimitiveProperty
-	| AnnotatedTextProperty
-	| NodeProperty
-	| NodeArrayProperty;
+	PrimitiveProperty | TextProperty | NodeProperty | NodeArrayProperty;
 
 /**
  * Node kind values for different types of content nodes
  */
-export type NodeKind = 'document' | 'block' | 'text' | 'annotation';
+export type NodeKind = 'document' | 'block' | 'text' | 'mark' | 'annotation';
 
 /**
- * Schema for text nodes - must have a content property of type annotated_text.
- * Use define_document_schema to also check that content is the only annotated_text property.
+ * Schema for text nodes - must have a content property of type text.
+ * Use define_document_schema to also check that content is the only text property.
  */
 export type TextNodeSchema = {
 	kind: 'text';
 	properties: {
-		content: AnnotatedTextProperty;
+		content: TextProperty;
 	} & Record<string, PropertyDefinition>;
 };
 
-export type AnnotatedTextPropertyNames<Properties> = {
-	[PropertyName in keyof Properties]: Properties[PropertyName] extends { type: 'annotated_text' }
+export type TextPropertyNames<Properties> = {
+	[PropertyName in keyof Properties]: Properties[PropertyName] extends { type: 'text' }
 		? PropertyName
 		: never;
 }[keyof Properties];
@@ -294,13 +294,11 @@ export type TextNodeSchemaError<Message extends string> = {
 	[SchemaError in `Svedit schema error: ${Message}`]: never;
 };
 
-export type TextNodeMissingContentError = TextNodeSchemaError<
-	'Text node schemas must define a "content" property of type annotated_text.'
->;
+export type TextNodeMissingContentError =
+	TextNodeSchemaError<'Text node schemas must define a "content" property of type text.'>;
 
-export type TextNodeExtraAnnotatedTextError<ExtraProperty extends string> = TextNodeSchemaError<
-	`Text node schemas must not define annotated_text property "${ExtraProperty}". Use "content" as the only annotated_text property.`
->;
+export type TextNodeExtraTextPropertyError<ExtraProperty extends string> =
+	TextNodeSchemaError<`Text node schemas must not define text property "${ExtraProperty}". Use "content" as the only text property.`>;
 
 export type ValidateTextNodeSchema<Schema> = Schema extends {
 	kind: 'text';
@@ -308,11 +306,11 @@ export type ValidateTextNodeSchema<Schema> = Schema extends {
 }
 	? string extends keyof Properties
 		? Schema
-		: Properties extends { content: AnnotatedTextProperty }
-			? Exclude<AnnotatedTextPropertyNames<Properties>, 'content'> extends infer ExtraProperties
+		: Properties extends { content: TextProperty }
+			? Exclude<TextPropertyNames<Properties>, 'content'> extends infer ExtraProperties
 				? [ExtraProperties] extends [never]
 					? Schema
-					: TextNodeExtraAnnotatedTextError<Extract<ExtraProperties, string>>
+					: TextNodeExtraTextPropertyError<Extract<ExtraProperties, string>>
 				: never
 			: TextNodeMissingContentError
 	: Schema;
@@ -325,7 +323,7 @@ export type ValidateDocumentSchema<Schema extends Record<string, NodeSchema>> =
  * Schema for non-text nodes
  */
 export type NonTextNodeSchema = {
-	kind: 'document' | 'block' | 'annotation';
+	kind: 'document' | 'block' | 'mark' | 'annotation';
 	properties: Record<string, PropertyDefinition>;
 };
 
@@ -363,9 +361,9 @@ export type Document = {
 };
 
 /**
- * Props for the AnnotatedTextProperty component
+ * Props for the TextProperty component
  */
-export type AnnotatedTextPropertyProps = {
+export type TextPropertyProps = {
 	/** The full path to the property */
 	path: DocumentPath;
 	/** Optional custom HTML tag */
@@ -414,6 +412,10 @@ export type NodeArrayPropertyProps = {
 export type NodeProps = {
 	/** The full path to the node */
 	path: DocumentPath;
+	/** The single node-array mark wrapping this node, if any */
+	mark?: NodeArrayAttachmentContext | null;
+	/** All node-array annotations covering this node */
+	annotations?: Array<NodeArrayAttachmentContext>;
 	/** Optional custom HTML tag */
 	tag?: string;
 	/** Optional string of CSS classes */
@@ -443,22 +445,61 @@ export type SveditProps = {
 };
 
 /**
- * Represents an annotation in an annotated string
+ * A range with an attached payload node, used for both marks and annotations.
  */
-export type Annotation = {
+export type Attachment = {
 	start_offset: number;
 	end_offset: number;
 	node_id: NodeId;
 };
 
 /**
- * Represents an annotated text with text and annotations
+ * A content-level range (e.g. strong, emphasis, link, section).
+ * Marks are mutually exclusive within a property and render in-place.
+ */
+export type Mark = Attachment;
+
+/**
+ * A metadata/overlay range (e.g. comment, marker).
+ * Annotations may overlap and are data-only.
+ */
+export type Annotation = Attachment;
+
+/**
+ * Represents text content with marks and annotations.
  */
 export type AnnotatedText = {
-	text: string;
+	content: string;
+	marks: Array<Mark>;
 	annotations: Array<Annotation>;
 };
 
+/**
+ * Represents an annotated node array with nodes, marks and annotations
+ */
+export type AnnotatedNodeArray = {
+	nodes: Array<NodeId>;
+	marks: Array<Mark>;
+	annotations: Array<Annotation>;
+};
+
+/**
+ * Attachment context passed to a node rendered inside an annotated node array.
+ * It is the flattened mark or annotation attachment, enriched with the resolved
+ * payload node, its index in the parent attachment array, and this child node's
+ * position in the attachment range.
+ */
+export type NodeArrayAttachmentContext = {
+	start_offset: number;
+	end_offset: number;
+	node_id: NodeId;
+	index: number;
+	node: DocumentNode;
+	is_start: boolean;
+	is_middle: boolean;
+	is_end: boolean;
+};
+
 /**
  * Represents a selection highlight fragment for non-annotated text selections
  */
@@ -468,19 +509,48 @@ export type SelectionHighlightFragment = {
 };
 
 /**
- * Represents an annotation fragment in annotated text content
+ * Represents a mark fragment in annotated text content
  */
-export type AnnotationFragment = {
-	type: 'annotation';
-	/** NodeId that has annotation type and details */
+export type MarkFragment = {
+	type: 'mark';
+	/** NodeId that has mark type and details */
 	node: any;
-	/** The text content of the annotation */
+	/** The text content of the mark */
 	content: string;
-	/** Index of the annotation in the original array */
-	annotation_index: number;
+	/** Index of the mark in the original array */
+	mark_index: number;
 };
 
 /**
  * Represents a fragment of annotated text content
  */
-export type Fragment = string | AnnotationFragment | SelectionHighlightFragment;
+export type Fragment = string | MarkFragment | SelectionHighlightFragment;
+
+/**
+ * Represents a node array fragment for plain nodes
+ */
+export type NodeArrayPlainFragment = {
+	type: 'nodes';
+	nodes: Array<NodeId>;
+	start_index: number;
+};
+
+/**
+ * Represents a mark fragment in node array content
+ */
+export type NodeArrayMarkFragment = {
+	type: 'mark';
+	/** NodeId that has mark type and details */
+	node: any;
+	/** The nodes wrapped by the mark */
+	nodes: Array<NodeId>;
+	/** Start index in the original nodes array */
+	start_index: number;
+	/** Index of the mark in the original array */
+	mark_index: number;
+};
+
+/**
+ * Represents a fragment of annotated node array content
+ */
+export type NodeArrayFragment = NodeArrayPlainFragment | NodeArrayMarkFragment;

package/dist/utils.d.ts

@@ -101,37 +101,38 @@ export function char_to_utf16_offset(str: string, char_offset: number): number;
 /**
  * Splits an annotated text at the specified character position.
  *
- * Annotations that span the split point will be divided appropriately,
- * with offsets adjusted for each resulting part.
+ * Marks and annotations that span the split point will be divided
+ * appropriately, with offsets adjusted for each resulting part.
  *
- * @param {AnnotatedText} text_with_annotations - Annotated text object
+ * @param {AnnotatedText} text_value - Annotated text object
  * @param {number} at_position - Character position where to split (0-based)
  * @returns {[AnnotatedText, AnnotatedText]} Tuple of [left_part, right_part]
  *
  * @example
- * split_annotated_text({text: "Hello world", annotations: [{start_offset: 6, end_offset: 11, node_id: "strong"}]}, 8)
+ * split_text({content: "Hello world", marks: [{start_offset: 6, end_offset: 11, node_id: "strong"}], annotations: []}, 8)
  * // Returns:
  * // [
- * //   {text: "Hello wo", annotations: [{start_offset: 6, end_offset: 8, node_id: "strong"}]},
- * //   {text: "rld", annotations: [{start_offset: 0, end_offset: 3, node_id: "strong"}]}
+ * //   {content: "Hello wo", marks: [{start_offset: 6, end_offset: 8, node_id: "strong"}], annotations: []},
+ * //   {content: "rld", marks: [{start_offset: 0, end_offset: 3, node_id: "strong"}], annotations: []}
  * // ]
  */
-export function split_annotated_text(text_with_annotations: AnnotatedText, at_position: number): [AnnotatedText, AnnotatedText];
+export function split_text(text_value: AnnotatedText, at_position: number): [AnnotatedText, AnnotatedText];
 /**
  * Joins two annotated texts into a single annotated text.
  *
- * Annotations from the second text will have their offsets shifted by the length
- * of the first text. Adjacent annotations of the same type and data will be merged.
+ * Marks and annotations from the second text will have their offsets shifted
+ * by the length of the first text. Adjacent ranges referencing the same node
+ * will be merged.
  *
  * @param {AnnotatedText} first_text - First annotated text object
  * @param {AnnotatedText} second_text - Second annotated text object
  * @returns {AnnotatedText} Combined annotated text object
  *
  * @example
- * join_annotated_text({text: "Hello wo", annotations: [{start_offset: 6, end_offset: 8, node_id: "strong"}]}, {text: "rld", annotations: [{start_offset: 0, end_offset: 3, node_id: "strong"}]})
- * // Returns: {text: "Hello world", annotations: [{start_offset: 6, end_offset: 11, node_id: "strong"}]}
+ * join_text({content: "Hello wo", marks: [{start_offset: 6, end_offset: 8, node_id: "strong"}], annotations: []}, {content: "rld", marks: [{start_offset: 0, end_offset: 3, node_id: "strong"}], annotations: []})
+ * // Returns: {content: "Hello world", marks: [{start_offset: 6, end_offset: 11, node_id: "strong"}], annotations: []}
  */
-export function join_annotated_text(first_text: AnnotatedText, second_text: AnnotatedText): AnnotatedText;
+export function join_text(first_text: AnnotatedText, second_text: AnnotatedText): AnnotatedText;
 /**
  * Convert snake_case string to PascalCase
  *
@@ -193,6 +194,18 @@ export function deserialize_path(serialized_path: string): Array<string | number
  * @returns {boolean}
  */
 export function paths_equal(a: Array<string | number>, b: Array<string | number>): boolean;
+/**
+ * Like traverse, but returns only node ids in depth-first order and never
+ * clones nodes. Use this when only the reachable id set is needed (e.g.
+ * reference bookkeeping) — traverse() deep-clones every visited node,
+ * which is wasteful for id-only consumers.
+ *
+ * @param {string} node_id - The ID of the node to start traversing from
+ * @param {object} schema - The document schema
+ * @param {Record<string, any>} nodes - All document nodes
+ * @returns {string[]} Node ids in depth-first order (entry point last)
+ */
+export function traverse_ids(node_id: string, schema: object, nodes: Record<string, any>): string[];
 export function traverse(node_id: any, schema: any, nodes: any): any[];
 /**
  * Extracts the normalized range from a text or node selection.
@@ -202,6 +215,56 @@ export function traverse(node_id: any, schema: any, nodes: any): any[];
  */
 export function get_selection_range(selection?: Selection): SelectionRange | null;
 export function is_selection_collapsed(selection: any): boolean;
+/**
+ * Adjust ranges (marks or annotations) after deleting a sequence range.
+ *
+ * Works for both annotated text (character offsets) and annotated node arrays
+ * (node offsets).
+ *
+ * @param {Array<import('./types.d.ts').Attachment>} ranges
+ * @param {number} start
+ * @param {number} end
+ * @returns {{ranges: Array<import('./types.d.ts').Attachment>, removed_node_ids: string[]}}
+ */
+export function adjust_ranges_for_deletion(ranges: Array<import("./types.d.ts").Attachment>, start: number, end: number): {
+    ranges: Array<import("./types.d.ts").Attachment>;
+    removed_node_ids: string[];
+};
+/**
+ * Adjust ranges (marks or annotations) after inserting into a sequence.
+ *
+ * Insertion inside a range extends it. Insertion exactly at either edge
+ * stays outside the range.
+ *
+ * @param {Array<import('./types.d.ts').Attachment>} ranges
+ * @param {number} offset
+ * @param {number} length
+ * @returns {Array<import('./types.d.ts').Attachment>}
+ */
+export function adjust_ranges_for_insertion(ranges: Array<import("./types.d.ts").Attachment>, offset: number, length: number): Array<import("./types.d.ts").Attachment>;
+/**
+ * Check whether ranges are non-empty and mutually exclusive.
+ *
+ * @param {Array<import('./types.d.ts').Attachment>} ranges
+ * @param {number} [length]
+ * @returns {boolean}
+ */
+export function are_ranges_exclusive(ranges: Array<import("./types.d.ts").Attachment>, length?: number): boolean;
+/**
+ * Calculates abstract fragment ranges from a length and marks.
+ *
+ * @param {number} length - Length of the sequence (e.g. text length or array length)
+ * @param {Array<import('./types.d.ts').Mark>} marks - Array of marks
+ * @param {import('./types.d.ts').SelectionRange} [selection_highlight_range] - Optional selection highlight range
+ * @returns {Array<{type: 'content' | 'mark' | 'selection_highlight', start_offset: number, end_offset: number, mark_index?: number, node_id?: string}>}
+ */
+export function calculate_fragment_ranges(length: number, marks: Array<import("./types.d.ts").Mark>, selection_highlight_range?: import("./types.d.ts").SelectionRange): Array<{
+    type: "content" | "mark" | "selection_highlight";
+    start_offset: number;
+    end_offset: number;
+    mark_index?: number;
+    node_id?: string;
+}>;
 export const PATH_SEPARATOR: "__";
 import type { AnnotatedText } from './types.d.ts';
 import type { Selection } from './types.d.ts';

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/lib/utils.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,8CAFa,OAAO,CAanB;AAED;;;;;;;GAOG;AACH,qCAFa,OAAO,CASnB;AAGD;;;GAGG;AACH,6CAFa,OAAO,CAUnB;AAED;;;;;;;;;;;;;GAaG;AACH,qCARW,MAAM,GACJ,MAAM,CASlB;AAGD;;;;;;;;;;;;;;GAcG;AACH,iCATW,MAAM,SACN,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;;GAcG;AACH,gCATW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;;;;;GAaG;AACH,0CARW,MAAM,gBACN,MAAM,GACJ,MAAM,CAmBlB;AAED;;;;;;;;;;;;;GAaG;AACH,0CARW,MAAM,eACN,MAAM,GACJ,MAAM,CAelB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,4DAZW,aAAa,eACb,MAAM,GACJ,CAAC,aAAa,EAAE,aAAa,CAAC,CA6C1C;AAED;;;;;;;;;;;;;GAaG;AACH,gDARW,aAAa,eACb,aAAa,GACX,aAAa,CA4CzB;AAED;;;;;;;;GAQG;AACH,qCANW,MAAM,GACJ,MAAM,CAUlB;AAMD;;;;;;;;;GASG;AACH,sDAHW,MAAM,GACJ,OAAO,CAQnB;AAED;;;;;;GAMG;AACH,oDAJW,MAAM,UACN,MAAM,GACJ,IAAI,CAQhB;AAED;;;;;;;;;;;;GAYG;AACH,qCANW,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GACpB,MAAM,CAmBlB;AAED;;;;;;;;GAQG;AACH,kDANW,MAAM,GACJ,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAuBlC;AAED;;;;;;GAMG;AACH,+BAJW,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,KACtB,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GACpB,OAAO,CAKnB;AAED,uEAgCC;AAED;;;;;GAKG;AACH,gDAHW,SAAS,GACP,cAAc,GAAG,IAAI,CAWjC;AAED,gEAMC;AApKD,6BAA8B,IAAI,CAAC;mCA3SsC,cAAc;+BAAd,cAAc;oCAAd,cAAc"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/lib/utils.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,8CAFa,OAAO,CAanB;AAED;;;;;;;GAOG;AACH,qCAFa,OAAO,CASnB;AAGD;;;GAGG;AACH,6CAFa,OAAO,CAUnB;AAED;;;;;;;;;;;;;GAaG;AACH,qCARW,MAAM,GACJ,MAAM,CASlB;AAGD;;;;;;;;;;;;;;GAcG;AACH,iCATW,MAAM,SACN,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;;GAcG;AACH,gCATW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;;;;;GAaG;AACH,0CARW,MAAM,gBACN,MAAM,GACJ,MAAM,CAmBlB;AAED;;;;;;;;;;;;;GAaG;AACH,0CARW,MAAM,eACN,MAAM,GACJ,MAAM,CAelB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,uCAZW,aAAa,eACb,MAAM,GACJ,CAAC,aAAa,EAAE,aAAa,CAAC,CAuC1C;AAED;;;;;;;;;;;;;;GAcG;AACH,sCARW,aAAa,eACb,aAAa,GACX,aAAa,CAgDzB;AAED;;;;;;;;GAQG;AACH,qCANW,MAAM,GACJ,MAAM,CAUlB;AAMD;;;;;;;;;GASG;AACH,sDAHW,MAAM,GACJ,OAAO,CAQnB;AAED;;;;;;GAMG;AACH,oDAJW,MAAM,UACN,MAAM,GACJ,IAAI,CAQhB;AAED;;;;;;;;;;;;GAYG;AACH,qCANW,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GACpB,MAAM,CAmBlB;AAED;;;;;;;;GAQG;AACH,kDANW,MAAM,GACJ,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAuBlC;AAED;;;;;;GAMG;AACH,+BAJW,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,KACtB,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,GACpB,OAAO,CAKnB;AAED;;;;;;;;;;GAUG;AACH,sCALW,MAAM,UACN,MAAM,SACN,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,MAAM,EAAE,CAkCpB;AAED,uEAsCC;AAED;;;;;GAKG;AACH,gDAHW,SAAS,GACP,cAAc,GAAG,IAAI,CAWjC;AAED,gEAMC;AAED;;;;;;;;;;GAUG;AACH,mDALW,KAAK,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,SACxC,MAAM,OACN,MAAM,GACJ;IAAC,MAAM,EAAE,KAAK,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,CAAC;IAAC,gBAAgB,EAAE,MAAM,EAAE,CAAA;CAAC,CAkC1F;AAED;;;;;;;;;;GAUG;AACH,oDALW,KAAK,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,UACxC,MAAM,UACN,MAAM,GACJ,KAAK,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,CAsBpD;AAED;;;;;;GAMG;AACH,6CAJW,KAAK,CAAC,OAAO,cAAc,EAAE,UAAU,CAAC,WACxC,MAAM,GACJ,OAAO,CAgBnB;AAED;;;;;;;GAOG;AACH,kDALW,MAAM,SACN,KAAK,CAAC,OAAO,cAAc,EAAE,IAAI,CAAC,8BAClC,OAAO,cAAc,EAAE,cAAc,GACnC,KAAK,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,qBAAqB,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC,CAuDtJ;AA3XD,6BAA8B,IAAI,CAAC;mCA1SwD,cAAc;+BAAd,cAAc;oCAAd,cAAc"}