svedit 0.11.1 → 0.13.0

package/dist/Svedit.svelte.d.ts

@@ -1,12 +1,32 @@
-export default Svedit;
-type Svedit = {
-    $on?(type: string, callback: (e: any) => void): () => void;
-    $set?(props: Partial<SveditProps>): void;
-} & {
-    focus_canvas: () => void;
+import './styles/svedit-colors.css';
+import './styles/svedit-animations.css';
+import type { DocumentSchema, SveditProps } from './types.js';
+declare function $$render<S extends DocumentSchema>(): {
+    props: SveditProps<S>;
+    exports: {
+        focus_canvas: () => void;
+    };
+    bindings: "editable";
+    slots: {};
+    events: {};
 };
-declare const Svedit: import("svelte").Component<SveditProps, {
-    focus_canvas: () => void;
-}, "editable">;
-import type { SveditProps } from './types.d.ts';
+declare class __sveltets_Render<S extends DocumentSchema> {
+    props(): ReturnType<typeof $$render<S>>['props'];
+    events(): ReturnType<typeof $$render<S>>['events'];
+    slots(): ReturnType<typeof $$render<S>>['slots'];
+    bindings(): "editable";
+    exports(): {
+        focus_canvas: () => void;
+    };
+}
+interface $$IsomorphicComponent {
+    new <S extends DocumentSchema>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<S>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<S>['props']>, ReturnType<__sveltets_Render<S>['events']>, ReturnType<__sveltets_Render<S>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<S>['bindings']>;
+    } & ReturnType<__sveltets_Render<S>['exports']>;
+    <S extends DocumentSchema>(internal: unknown, props: ReturnType<__sveltets_Render<S>['props']> & {}): ReturnType<__sveltets_Render<S>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Svedit: $$IsomorphicComponent;
+type Svedit<S extends DocumentSchema> = InstanceType<typeof Svedit<S>>;
+export default Svedit;
 //# sourceMappingURL=Svedit.svelte.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Svedit.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Svedit.svelte.js"],"names":[],"mappings":";;;;;;;AA0mDA;;eAAqD;iCA9jD1C,cAAc"}
+{"version":3,"file":"Svedit.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Svedit.svelte.ts"],"names":[],"mappings":"AAyBA,OAAO,4BAA4B,CAAC;AACpC,OAAO,gCAAgC,CAAC;AAExC,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EASX,MAAM,YAAY,CAAC;AAGrB,iBAAS,QAAQ,CAAC,CAAC,SAAS,cAAc;WA8lDb,WAAW,CAAC,CAAC,CAAC;aAAwB;QAAE,YAAY,aAAqB;KAAE;;;;EAAuE;AAC/K,cAAM,iBAAiB,CAAC,CAAC,SAAS,cAAc;IAC5C,KAAK,IAAI,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;IAChD,MAAM,IAAI,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IAClD,KAAK,IAAI,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;IAChD,QAAQ;IACR,OAAO;;;CACV;AAED,UAAU,qBAAqB;IAC3B,KAAK,CAAC,SAAS,cAAc,EAAE,OAAO,EAAE,OAAO,QAAQ,EAAE,2BAA2B,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG;QAAE,UAAU,CAAC,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAA;KAAE,GAAG,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;IACnZ,CAAC,CAAC,SAAS,cAAc,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;IAClJ,YAAY,CAAC,EAAE,UAAU,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;CACjE;AACD,QAAA,MAAM,MAAM,EAAE,qBAAmC,CAAC;AAChC,KAAK,MAAM,CAAC,CAAC,SAAS,cAAc,IAAI,YAAY,CAAC,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AACzE,eAAe,MAAM,CAAC"}

package/dist/{AnnotatedTextProperty.svelte → TextProperty.svelte}

@@ -1,19 +1,32 @@
-<script>
+<script lang="ts">
 	import { getContext } from 'svelte';
 	import {
 		char_slice,
 		get_char_length,
 		paths_equal,
 		serialize_path,
-		get_selection_range
+		get_selection_range,
+		calculate_fragment_ranges
 	} from './utils.js';
 
-	/** @import { AnnotatedTextPropertyProps, Annotation, Fragment, SelectionRange } from './types.d.ts'; */
-
-	const svedit = getContext('svedit');
-
-	/** @type {AnnotatedTextPropertyProps} */
-	let { path, class: css_class, placeholder = '', tag = 'div', style = '', ...rest } = $props();
+	import type {
+		TextPropertyProps,
+		Mark,
+		Fragment,
+		SelectionRange,
+		SveditContext
+	} from './types.js';
+
+	const svedit = getContext<SveditContext>('svedit');
+
+	let {
+		path,
+		class: css_class,
+		placeholder = '',
+		tag = 'div',
+		style = '',
+		...rest
+	}: TextPropertyProps = $props();
 
 	let path_str = $derived(serialize_path(path));
 
@@ -23,16 +36,20 @@
 		);
 	});
 
-	let plain_text = $derived(svedit.session.get(path).text);
-	let is_empty = $derived(
-		get_char_length(plain_text) === 0 && !(svedit.is_composing && is_focused)
-	);
+	let plain_text = $derived(svedit.session.get(path).content);
+	// A string has zero grapheme clusters iff it has zero code units, so a
+	// plain length check avoids a full Intl.Segmenter pass (this derived
+	// re-runs for every text property on every document change).
+	let is_empty = $derived(plain_text.length === 0 && !(svedit.is_composing && is_focused));
 
-	let is_collapsed = $derived(
-		is_focused && svedit.session.selection?.anchor_offset == svedit.session.selection?.focus_offset
-	);
+	let is_collapsed = $derived.by(() => {
+		const selection = svedit.session.selection;
+		return (
+			is_focused && selection?.type === 'text' && selection.anchor_offset === selection.focus_offset
+		);
+	});
 
-	// Get selection highlight range if not inside an annotation
+	// Get selection highlight range if it does not touch marks.
 	// Only render selection highlight when canvas is NOT focused.
 	// This avoids DOM mutations (splitting text nodes for highlight spans)
 	// while the user is actively selecting, which would cause selection
@@ -41,7 +58,7 @@
 		if (svedit.canvas_focused) return null;
 		if (is_collapsed) return null;
 		if (!is_focused) return null;
-		if (svedit.session.active_annotation()) return null;
+		if (svedit.session.selected_marks.length > 0) return null;
 		const sel = svedit.session.selection;
 		if (!sel || sel.type !== 'text') return null;
 		return get_selection_range(sel);
@@ -49,61 +66,57 @@
 
 	let fragments = $derived(
 		get_fragments(
-			svedit.session.get(path).text,
-			svedit.session.get(path).annotations,
+			svedit.session.get(path).content,
+			svedit.session.get(path).marks,
 			selection_highlight_range
 		)
 	);
 
 	/**
-	 * Converts text with annotations into renderable fragments for display.
-	 * @param {string} text - The plain text content
-	 * @param {Array<Annotation>} annotations - Array of annotations
-	 * @param {SelectionRange} [selection_highlight_range] - Optional selection highlight range
-	 * @returns {Array<Fragment>} Array of fragments
+	 * Converts text with marks into renderable fragments for display.
+	 * Annotations never fragment the text; they are data-only.
 	 */
-	function get_fragments(text, annotations, selection_highlight_range) {
-		/** @type {Array<Fragment>} */
-		let fragments = [];
-		let last_index = 0;
+	function get_fragments(
+		text: string,
+		marks: Array<Mark>,
+		selection_highlight_range?: SelectionRange | null
+	): Array<Fragment> {
+		// Fast path: no marks and no selection highlight means the whole text
+		// is a single content fragment. This runs for EVERY text property on
+		// EVERY document change, so skipping the two full Intl.Segmenter passes
+		// (get_char_length + char_slice over the whole text) matters at scale.
+		if (marks.length === 0 && !selection_highlight_range) {
+			return text.length > 0 ? [text] : [];
+		}
 
-		// Merge annotations with selection highlight and sort by start offset
-		const ranges = [
-			...annotations,
-			...(selection_highlight_range ? [selection_highlight_range] : [])
-		].sort((a, b) => a.start_offset - b.start_offset);
+		const ranges = calculate_fragment_ranges(
+			get_char_length(text),
+			marks,
+			selection_highlight_range
+		);
+		const fragments: Array<Fragment> = [];
 
 		for (const range of ranges) {
-			// Add text before this range
-			if (range.start_offset > last_index) {
-				fragments.push(char_slice(text, last_index, range.start_offset));
-			}
-
 			const content = char_slice(text, range.start_offset, range.end_offset);
 
-			if ('node_id' in range) {
+			if (range.type === 'mark') {
 				const node = svedit.session.get(range.node_id);
-				if (!node) throw new Error(`Node not found for annotation ${range.node_id}`);
+				if (!node) throw new Error(`Node not found for mark ${range.node_id}`);
 
 				fragments.push({
-					type: 'annotation',
+					type: 'mark',
 					node,
 					content,
-					annotation_index: annotations.indexOf(/** @type {Annotation} */ (range))
+					mark_index: range.mark_index!
 				});
-			} else {
+			} else if (range.type === 'selection_highlight') {
 				fragments.push({
 					type: 'selection_highlight',
 					content
 				});
+			} else {
+				fragments.push(content);
 			}
-
-			last_index = range.end_offset;
-		}
-
-		// Add any remaining text
-		if (last_index < get_char_length(text)) {
-			fragments.push(char_slice(text, last_index));
 		}
 
 		return fragments;
@@ -130,12 +143,14 @@
 		{#if typeof fragment === 'string'}{fragment}{:else if fragment.type === 'selection_highlight'}<span
 				class="selection-highlight"
 				style="anchor-name: --selection-highlight;">{fragment.content}</span
-			>{:else if fragment.type === 'annotation'}
-			{@const AnnotationComponent = svedit.session.config.node_components[fragment.node.type]}
-			<AnnotationComponent
-				path={[...path, 'annotations', fragment.annotation_index, 'node_id']}
-				content={fragment.content}
-			/>
+			>{:else if fragment.type === 'mark'}
+			{@const MarkComponent = svedit.session.config.node_components[fragment.node.type]}
+			{#if MarkComponent}
+				<MarkComponent
+					path={[...path, 'marks', fragment.mark_index, 'node_id']}
+					content={fragment.content}
+				/>
+			{:else}<span class="mark-{fragment.node.type}">{fragment.content}</span>{/if}
 		{/if}
 	{/each}<!--
   -->{#if !is_focused || !is_empty}<br />{/if}

package/dist/TextProperty.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { TextPropertyProps } from './types.js';
+declare const TextProperty: import("svelte").Component<TextPropertyProps, {}, "">;
+type TextProperty = ReturnType<typeof TextProperty>;
+export default TextProperty;
+//# sourceMappingURL=TextProperty.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TextProperty.svelte.d.ts","sourceRoot":"","sources":["../src/lib/TextProperty.svelte.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EACV,iBAAiB,EAKjB,MAAM,YAAY,CAAC;AAsIrB,QAAA,MAAM,YAAY,uDAAwC,CAAC;AAC3D,KAAK,YAAY,GAAG,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;AACpD,eAAe,YAAY,CAAC"}

package/dist/Transaction.svelte.d.ts

@@ -1,3 +1,5 @@
+import type { SelectedAttachment } from './doc_utils.js';
+import type { NodeId, NodeKind, Selection, Document, DocumentSchema, DocumentNode, DocumentPath, Mark, Annotation, DocumentOperation, DynamicRecord, Inspection, SessionConfig } from './types.js';
 /**
  * Transaction class for managing atomic document operations with undo/redo support.
  *
@@ -14,110 +16,81 @@
  * ```
  */
 export default class Transaction {
-    /**
-     * Creates a new Transaction with the given state.
-     *
-     * @param {DocumentSchema} schema - The document schema
-     * @param {Document} doc - The document state {document_id, nodes}
-     * @param {Selection | null} selection - The current selection
-     * @param {object} config - The document config (including generate_id)
-     */
-    constructor(schema: DocumentSchema, doc: Document, selection: Selection | null, config: object);
     schema: DocumentSchema;
-    /** @type {object} */
-    doc: object;
-    /** @type {Selection} */
+    doc: Document;
     selection: Selection;
-    config: any;
-    /** @type {Record<string, any>[]} */
-    ops: Record<string, any>[];
-    /** @type {Record<string, any>[]} */
-    inverse_ops: Record<string, any>[];
-    selection_before: Selection;
-    /** @type {NodeId[]} */
+    config: SessionConfig;
+    ops: DocumentOperation[];
+    inverse_ops: DocumentOperation[];
+    selection_before: Selection | null;
     created_node_ids: NodeId[];
-    /** @type {NodeId[]} */
     modified_node_ids: NodeId[];
-    /** @type {NodeId[]} */
     deleted_node_ids: NodeId[];
+    changed_node_types: boolean;
+    /**
+     * Creates a new Transaction with the given state.
+     *
+     * @param schema - The document schema
+     * @param doc - The document state {document_id, nodes}
+     * @param selection - The current selection
+     * @param config - The document config (including generate_id)
+     */
+    constructor(schema: DocumentSchema, doc: Document, selection: Selection | null, config: SessionConfig);
     /**
      * Gets a value from the document at the specified path.
      *
-     * @param {DocumentPath|string} path - The path to the value in the document, or a string node ID
-     * @returns {any} The value at the specified path
+     * @param path - The path to the value in the document, or a string node ID
+     * @returns The value at the specified path
      */
     get(path: DocumentPath | string): any;
     /**
      * Gets the type of a property from the schema.
-     *
-     * @param {string} type - The node type
-     * @param {string} property - The property name
-     * @returns {string} The property type
      */
     property_type(type: string, property: string): string;
     /**
-     * Determines the kind of a node ('block', 'text', or 'annotation').
-     *
-     * @param {any} node - The node to check
-     * @returns {'block'|'text'|'annotation'} The node kind
+     * Determines the kind of a node ('document', 'block', 'text', 'mark', or 'annotation').
      */
-    kind(node: any): "block" | "text" | "annotation";
+    kind(node: DocumentNode): NodeKind;
     /**
      * Inspects a path to get metadata about the value at that location.
-     *
-     * @param {DocumentPath} path - The path to inspect
-     * @returns {{kind: 'property'|'node', [key: string]: any}} Metadata about the path
      */
-    inspect(path: DocumentPath): {
-        kind: "property" | "node";
-        [key: string]: any;
-    };
+    inspect(path: DocumentPath): Inspection;
     /**
      * Generates a new unique ID using the config's generate_id function.
-     *
-     * @returns {string} A new unique ID
      */
     generate_id(): string;
     /**
      * Validates a node against the document schema.
      *
-     * @param {any} node - The node to validate
      * @throws {Error} Throws if the node is invalid
      */
-    validate_node(node: any): void;
+    validate_node(node: DocumentNode): void;
     /**
      * Gets all nodes referenced by a given node (recursively).
-     *
-     * @param {NodeId} node_id - The node ID to get references for
-     * @returns {NodeId[]} Array of referenced node IDs
      */
     get_referenced_nodes(node_id: NodeId): NodeId[];
+    /**
+     * Gets the available mark types for the current selection.
+     */
+    get available_mark_types(): string[];
     /**
      * Gets the available annotation types for the current selection.
-     *
-     * @returns {string[]} Array of available annotation type names
      */
     get available_annotation_types(): string[];
     /**
-     * Returns the annotation object that is currently "under the caret".
-     * NOTE: Annotations in Svedit are exclusive, so there can only be one active_annotation
-     *
-     * @param {string} [annotation_type] Optional annotation type to filter by
-     * @returns {Annotation|null}
+     * Returns marks touched by the current selection.
      */
-    active_annotation(annotation_type?: string): Annotation | null;
+    get selected_marks(): SelectedAttachment[];
+    get active_mark(): SelectedAttachment | null;
     /**
-     * Applies an operation to the document (internal).
-     *
-     * @param {Array} op - The operation to apply
-     * @private
+     * Returns annotations touched by the current selection.
      */
-    private _apply_op;
+    get selected_annotations(): SelectedAttachment[];
+    get active_annotation(): SelectedAttachment | null;
     /**
-     * @param {NodeId[]} node_ids
-     * @param {NodeId} node_id
-     * @private
+     * Applies an operation to the document (internal).
      */
+    private _apply_op;
     private _track_node_id;
     /**
      * Sets a property of a node to a new value.
@@ -125,26 +98,26 @@ export default class Transaction {
      * This is the core operation for modifying document properties. It records
      * both the forward operation and its inverse for undo support.
      *
-     * @param {DocumentPath} path - Array path to the property (e.g., ["node_1", "title"])
-     * @param {any} value - The new value to set
-     * @returns {Transaction} This transaction instance for method chaining
+     * @param path - Array path to the property (e.g., ["node_1", "title"])
+     * @param value - The new value to set
+     * @returns This transaction instance for method chaining
      *
      * @example
      * ```js
      * tr.set(["list_1", "list_items"], [1, 2, 3]);
-     * tr.set(["page_1", "body", "0", "description"], {text: "Hello world", annotations: []});
+     * tr.set(["page_1", "body", "0", "description"], {content: "Hello world", marks: [], annotations: []});
      * ```
      */
-    set(path: DocumentPath, value: any): Transaction;
-    build(node_id: any, nodes: any): any;
+    set(path: DocumentPath, value: any): this;
+    build(node_id: NodeId, nodes: Record<string, DocumentNode>): NodeId;
     /**
      * Creates a new node in the document.
      *
      * The node must have a valid id and must not already exist in the document.
      * Omitted properties with schema defaults are filled before validation.
      *
-     * @param {any} node - The node object to create (must include id, type, and required properties)
-     * @returns {Transaction} This transaction instance for method chaining
+     * @param node - The node object to create (must include id, type, and required properties)
+     * @returns This transaction instance for method chaining
      * @throws {Error} If the node ID is invalid or if the node already exists
      *
      * @example
@@ -156,7 +129,7 @@ export default class Transaction {
      * });
      * ```
      */
-    create(node: any): Transaction;
+    create(node: DocumentNode): this;
     /**
      * Deletes a node from the document by its ID.
      *
@@ -164,57 +137,74 @@ export default class Transaction {
      *
      * NOTE: This is a force-delete and intentionally does NOT check whether
      * the node is still referenced from elsewhere — callers (e.g.
-     * `annotate_text`) sometimes need to remove a node while a stale
+     * `toggle_mark`) sometimes need to remove a node while a stale
      * reference to it still exists in the property they are about to update.
      * For ref-count-aware cleanup, see how `set` calls
      * `_cascade_delete_unreferenced_nodes`.
      *
-     * @param {any} id - The ID of the node to delete
-     * @returns {Transaction} This transaction instance for method chaining
+     * @param id - The ID of the node to delete
+     * @returns This transaction instance for method chaining
      *
      * @example
      * ```js
      * tr.delete('node_123');
      * ```
      */
-    delete(id: any): Transaction;
+    delete(id: NodeId): this;
     /**
      * Sets the document selection.
      *
-     * @param {Selection} selection - The new selection object
-     * @returns {Transaction} This transaction instance for method chaining
+     * @param selection - The new selection object
+     * @returns This transaction instance for method chaining
      * @throws {Error} Throws if the selection is invalid or out of bounds
      */
-    set_selection(selection: Selection): Transaction;
+    set_selection(selection: Selection): this;
     /**
      * Validates a selection against the current document state.
      *
-     * @param {Selection} selection - The selection to validate
      * @throws {Error} Throws if the selection is invalid
-     * @private
      */
     private _validate_selection;
     /**
-     * Adds, updates, or removes text annotations in the current selection.
+     * Toggles a mark on the current text or node selection.
      *
-     * Handles various annotation scenarios including adding new annotations,
-     * updating existing ones (especially for links), and removing annotations
-     * when conflicting types are applied.
+     * Marks are mutually exclusive. Whole marks are toggled, removed, or
+     * switched; ranges are never truncated or expanded by this command.
      *
-     * @param {any} annotation_type - The type of annotation (e.g., 'link', 'bold', 'italic')
-     * @param {any} annotation_properties - Additional data for the annotation (e.g., href for links)
-     * @returns {Transaction} This transaction instance for method chaining
+     * @param mark_type - The type of mark (e.g., 'link', 'strong', 'emphasis')
+     * @param mark_properties - Additional data for the mark (e.g., href for links)
+     * @returns This transaction instance for method chaining
      *
      * @example
      * ```js
-     * // Add a link annotation
-     * tr.annotate_text('link', { href: 'https://example.com' });
+     * // Add a link mark
+     * tr.toggle_mark('link', { href: 'https://example.com' });
      *
      * // Add emphasis
-     * tr.annotate_text('emphasis', {});
+     * tr.toggle_mark('emphasis', {});
      * ```
      */
-    annotate_text(annotation_type: any, annotation_properties: any): Transaction;
+    toggle_mark(mark_type: string, mark_properties?: DynamicRecord): this;
+    /**
+     * Toggles an annotation on the current text or node selection.
+     *
+     * Annotations only compete with touched annotations of the same type:
+     * touched same-type annotations are removed, otherwise a new annotation is
+     * created. Marks and other annotation types never block a toggle, and
+     * same-type annotations may still overlap when created through lower-level
+     * APIs.
+     *
+     * @param annotation_type - The type of annotation (e.g., 'comment', 'marker')
+     * @param annotation_properties - Additional data for the annotation
+     * @returns This transaction instance for method chaining
+     *
+     * @example
+     * ```js
+     * // Add a comment annotation
+     * tr.toggle_annotation('comment', { text: 'Please review' });
+     * ```
+     */
+    toggle_annotation(annotation_type: string, annotation_properties?: DynamicRecord): this;
     /**
      * Deletes the currently selected text, node, or property.
      *
@@ -224,34 +214,38 @@ export default class Transaction {
      * - For collapsed selections: Deletes the previous character/node (backward) or next character/node (forward)
      * - For property selections: Delegates to the config's handle_property_deletion hook
      *
-     * @param {'backward' | 'forward'} [direction] - Direction of deletion for collapsed selections
-     * @returns {Transaction} This transaction instance for method chaining
+     * @param direction - Direction of deletion for collapsed selections
+     * @returns This transaction instance for method chaining
      */
-    delete_selection(direction?: "backward" | "forward"): Transaction;
+    delete_selection(direction?: 'backward' | 'forward'): this;
     /**
      * Inserts nodes at the current node selection position.
      *
      * If the selection is expanded (not collapsed), first deletes the selected nodes
      * before inserting the new ones.
      *
-     * @param {NodeId[]} node_ids - Array of node IDs to insert
-     * @returns {Transaction} This transaction instance for method chaining
+     * @param node_ids - Array of node IDs to insert
+     * @param marks - Selection-relative marks to restore
+     * @param annotations - Selection-relative annotations to restore
+     * @param nodes - Node graph for restored marks and annotations
+     * @returns This transaction instance for method chaining
      */
-    insert_nodes(node_ids: NodeId[]): Transaction;
+    insert_nodes(node_ids: NodeId[], marks?: Array<Mark>, annotations?: Array<Annotation>, nodes?: Record<NodeId, DocumentNode>): this;
     /**
      * Inserts text at the current text selection position.
      *
-     * Handles annotation adjustments when text is inserted, including:
-     * - Expanding annotations that contain the insertion point
-     * - Shifting annotations that come after the insertion point
-     * - Optionally applying new annotations to the inserted text
+     * Handles mark and annotation adjustments when text is inserted, including:
+     * - Expanding ranges that contain the insertion point
+     * - Shifting ranges that come after the insertion point
+     * - Optionally applying new marks and annotations to the inserted text
      *
-     * @param {string} replaced_text - The text to insert
-     * @param {Array} [annotations] - Optional annotations to apply to the inserted text
-     * @param {object} [nodes] - Optional node definitions for annotation nodes
-     * @returns {Transaction} This transaction instance for method chaining
+     * @param replaced_text - The text to insert
+     * @param marks - Optional marks to apply to the inserted text
+     * @param annotations - Optional annotations to apply to the inserted text
+     * @param nodes - Optional node definitions for mark and annotation nodes
+     * @returns This transaction instance for method chaining
      */
-    insert_text(replaced_text: string, annotations?: any[], nodes?: object): Transaction;
+    insert_text(replaced_text: string, marks?: Array<Mark>, annotations?: Array<Annotation>, nodes?: Record<NodeId, DocumentNode>): this;
     /**
      * Recursively deletes nodes that are no longer referenced in the document.
      *
@@ -259,27 +253,8 @@ export default class Transaction {
      * references are removed. Uses reference counting to determine which
      * nodes are safe to delete.
      *
-     * @param {NodeId[]} potentially_orphaned_nodes - Array of node IDs to check
-     * @private
+     * @param potentially_orphaned_nodes - Array of node IDs to check
      */
     private _cascade_delete_unreferenced_nodes;
-    /**
-     * Counts references to a node, excluding nodes that have been marked for deletion.
-     *
-     * This is used during cascade deletion to accurately count remaining references
-     * as nodes are being deleted.
-     *
-     * @param {NodeId} target_node_id - The node ID to count references for
-     * @param {Record<NodeId, boolean>} nodes_to_delete - Nodes already marked for deletion
-     * @returns {number} The number of references to the target node
-     * @private
-     */
-    private _count_references_excluding_deleted;
 }
-import type { DocumentSchema } from './types.d.js';
-import type { Selection } from './types.d.js';
-import type { NodeId } from './types.d.js';
-import type { DocumentPath } from './types.d.js';
-import type { Annotation } from './types.d.js';
-import type { Document } from './types.d.js';
 //# sourceMappingURL=Transaction.svelte.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Transaction.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Transaction.svelte.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;;OAOG;IACH,oBALW,cAAc,OACd,QAAQ,aACR,SAAS,GAAG,IAAI,UAChB,MAAM,EAuBhB;IApBA,uBAAoB;IACpB,qBAAqB;IACrB,KADW,MAAM,CACH;IACd,wBAAwB;IACxB,WADW,SAAS,CACM;IAC1B,YAAoB;IAEpB,oCAAoC;IACpC,KADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CACnB;IACb,oCAAoC;IACpC,aADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CACX;IAErB,4BAAiC;IAEjC,uBAAuB;IACvB,kBADW,MAAM,EAAE,CACO;IAC1B,uBAAuB;IACvB,mBADW,MAAM,EAAE,CACQ;IAC3B,uBAAuB;IACvB,kBADW,MAAM,EAAE,CACO;IAG3B;;;;;OAKG;IACH,UAHW,YAAY,GAAC,MAAM,GACjB,GAAG,CAIf;IAED;;;;;;OAMG;IACH,oBAJW,MAAM,YACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,WAHW,GAAG,GACD,OAAO,GAAC,MAAM,GAAC,YAAY,CAIvC;IAED;;;;;OAKG;IACH,cAHW,YAAY,GACV;QAAC,IAAI,EAAE,UAAU,GAAC,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAIzD;IAED;;;;OAIG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,oBAHW,GAAG,QAKb;IAGD;;;;;OAKG;IACH,8BAHW,MAAM,GACJ,MAAM,EAAE,CAKpB;IAED;;;;OAIG;IACH,kCAFa,MAAM,EAAE,CAOpB;IAED;;;;;;OAMG;IACH,oCAHW,MAAM,GACJ,UAAU,GAAC,IAAI,CAI3B;IAED;;;;;OAKG;IACH,kBAEC;IAED;;;;OAIG;IACH,uBAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,UAVW,YAAY,SACZ,GAAG,GACD,WAAW,CA8DvB;IAKD,qCAkCC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAbW,GAAG,GACD,WAAW,CA4BvB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,WARW,GAAG,GACD,WAAW,CAuBvB;IAED;;;;;;OAMG;IACH,yBAJW,SAAS,GACP,WAAW,CAOvB;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,+BAbW,GAAG,yBACH,GAAG,GACD,WAAW,CA+EvB;IAED;;;;;;;;;;;OAWG;IACH,6BAHW,UAAU,GAAG,SAAS,GACpB,WAAW,CA8IvB;IAED;;;;;;;;OAQG;IACH,uBAHW,MAAM,EAAE,GACN,WAAW,CA2BvB;IAED;;;;;;;;;;;;OAYG;IACH,2BALW,MAAM,+BAEN,MAAM,GACJ,WAAW,CA2FvB;IAED;;;;;;;;;OASG;IACH,2CAiCC;IAED;;;;;;;;;;OAUG;IACH,4CAOC;CACD;oCA50ByF,cAAc;+BAAd,cAAc;4BAAd,cAAc;kCAAd,cAAc;gCAAd,cAAc;8BAAd,cAAc"}
+{"version":3,"file":"Transaction.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Transaction.svelte.ts"],"names":[],"mappings":"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"}