svedit 0.4.0 → 0.5.0

package/dist/Transaction.svelte.d.ts

@@ -47,6 +47,7 @@ export default class Transaction {
      *
      * @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
      *
      * @example
      * ```js
@@ -54,7 +55,8 @@ export default class Transaction {
      * tr.set(["page_1", "body", "0", "description"], {text: "Hello world", annotations: []});
      * ```
      */
-    set(path: DocumentPath, value: any): void;
+    set(path: DocumentPath, value: any): Transaction;
+    build(node_id: any, nodes: any): any;
     /**
      * Creates a new node in the document.
      *
@@ -124,31 +126,26 @@ export default class Transaction {
      * Behavior depends on selection type:
      * - For node selections: Removes selected nodes and cascades deletion of unreferenced nodes
      * - For text selections: Removes selected text and adjusts annotations accordingly
-     * - For collapsed selections: Deletes the previous character/node
+     * - For collapsed selections: Deletes the previous character/node (backward) or next character/node (forward)
      *
+     * @param {'backward' | 'forward'} [direction] - Direction of deletion for collapsed selections
      * @returns {Transaction} This transaction instance for method chaining
      */
-    delete_selection(): Transaction;
+    delete_selection(direction?: "backward" | "forward"): Transaction;
     /**
      * Inserts an array of nodes at the current node selection.
      *
-     * If there's a current selection, it will be deleted first. New nodes are
-     * created if they don't already exist (e.g., for cut+paste scenarios).
+     * If there's a current selection, it will be deleted first.
      *
-     * @param {SerializedNode[]} nodes - Array of node objects to insert
+     * @param {NodeId[]} node_ids - Array of node IDs to insert
      * @returns {Transaction} This transaction instance for method chaining
      *
-     * @note Assumes we only insert new nodes, not reference existing ones
-     *
      * @example
      * ```js
-     * tr.insert_nodes([
-     *   {id: 'para_1', type: 'paragraph', content: ['Hello', []]},
-     *   {id: 'para_2', type: 'paragraph', content: ['World', []]}
-     * ]);
+     * tr.insert_nodes_new(['para_1', 'para_2']);
      * ```
      */
-    insert_nodes(nodes: SerializedNode[]): Transaction;
+    insert_nodes(node_ids: NodeId[]): Transaction;
     /**
      * Inserts text at the current text selection, replacing any selected content.
      *
@@ -165,7 +162,7 @@ export default class Transaction {
      * tr.insert_text('Hello, world!');
      * ```
      */
-    insert_text(replaced_text: string): Transaction;
+    insert_text(replaced_text: string, annotations?: any[], nodes?: {}): Transaction;
     /**
      * Recursively deletes nodes that become unreferenced after the initial deletion.
      *
@@ -191,5 +188,5 @@ export default class Transaction {
 }
 import type { DocumentPath } from './types.js';
 import type { Selection } from './types.js';
-import type { SerializedNode } from './types.js';
+import type { NodeId } from './types.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":"AAMA;;;;;;;;;;;;;;GAcG;AACH;IACE;;;;OAIG;IACH,iBAFW,GAAG,EAWb;IARC,SAAc;IAEd,oCAAoC;IACpC,KADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CACnB;IACb,oCAAoC;IACpC,aADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CACX;IAErB,sBAA0C;IAG5C;;;;;OAKG;IACH,UAHW,YAAY,GACV,GAAG,CAIf;IAED;;;;OAIG;IACH,iBAFa,SAAS,CAIrB;IAED;;;;;;;;;;;;;;OAcG;IACH,UATW,YAAY,SACZ,GAAG,QA2Bb;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAbW,GAAG,GACD,WAAW,CAyBvB;IAED;;;;;;;;;;;;OAYG;IACH,WARW,GAAG,GACD,WAAW,CAcvB;IAED;;;;;;OAMG;IACH,yBAJW,SAAS,GACP,WAAW,CAOvB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,+BAbW,GAAG,yBACH,GAAG,GACD,WAAW,CAuDvB;IAED;;;;;;;;;OASG;IACH,oBAFa,WAAW,CAyGvB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,oBAbW,cAAc,EAAE,GACd,WAAW,CAqDvB;IAED;;;;;;;;;;;;;;;OAeG;IACH,2BAVW,MAAM,GACJ,WAAW,CA8EvB;IAED;;;;;;;;OAQG;IACH,2CA+BC;IAED;;;;;;;;;;OAUG;IACH,4CAuBC;CACF;kCAxjBmE,YAAY;+BAAZ,YAAY;oCAAZ,YAAY"}
+{"version":3,"file":"Transaction.svelte.d.ts","sourceRoot":"","sources":["../src/lib/Transaction.svelte.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH;IACE;;;;OAIG;IACH,iBAFW,GAAG,EAWb;IARC,SAAc;IAEd,oCAAoC;IACpC,KADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CACnB;IACb,oCAAoC;IACpC,aADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CACX;IAErB,sBAA0C;IAG5C;;;;;OAKG;IACH,UAHW,YAAY,GACV,GAAG,CAIf;IAED;;;;OAIG;IACH,iBAFa,SAAS,CAIrB;IAED;;;;;;;;;;;;;;;OAeG;IACH,UAVW,YAAY,SACZ,GAAG,GACD,WAAW,CA4BvB;IAKD,qCAoDC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAbW,GAAG,GACD,WAAW,CAyBvB;IAED;;;;;;;;;;;;OAYG;IACH,WARW,GAAG,GACD,WAAW,CAcvB;IAED;;;;;;OAMG;IACH,yBAJW,SAAS,GACP,WAAW,CAOvB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,+BAbW,GAAG,yBACH,GAAG,GACD,WAAW,CAuDvB;IAED;;;;;;;;;;OAUG;IACH,6BAHW,UAAU,GAAG,SAAS,GACpB,WAAW,CA6IvB;IAED;;;;;;;;;;;;OAYG;IACH,uBARW,MAAM,EAAE,GACN,WAAW,CAyCvB;IAED;;;;;;;;;;;;;;;OAeG;IACH,2BAVW,MAAM,oCACJ,WAAW,CAwGvB;IAED;;;;;;;;OAQG;IACH,2CA+BC;IAED;;;;;;;;;;OAUG;IACH,4CAuBC;CACF;kCAtqBmD,YAAY;+BAAZ,YAAY;4BAAZ,YAAY"}

package/dist/Transaction.svelte.js

@@ -1,8 +1,9 @@
 /**
- * @import { NodeId, SerializedNode, Selection, DocumentPath } from './types.js'
+ * @import { NodeId, Selection, DocumentPath } from './types.js'
  */
 
-import { get_char_length, char_slice } from './util.js';
+import { get_char_length, char_slice, traverse } from './util.js';
+import { join_text_node } from './commands.svelte.js';
 
 /**
  * Transaction class for managing atomic document operations with undo/redo support.
@@ -63,6 +64,7 @@ export default class Transaction {
    *
    * @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
    *
    * @example
    * ```js
@@ -89,6 +91,64 @@ export default class Transaction {
     this.ops.push(op);
     this.inverse_ops.push(['set', path, previous_value]);
     this.doc._apply_op(op);
+    return this;
+  }
+
+  // Takes a subgraph and constructs new nodes from it
+  // NOTE: all ids will be mapped to new unique ids.
+  // NOTE: Omitted properties will be populated with default values.
+  build(node_id, nodes) {
+    const depth_first_nodes = traverse(node_id, this.doc.schema, nodes);
+    // This maps original ids to newly generated ids
+    const id_map = {};
+
+    for (const node of depth_first_nodes) {
+      const new_id = this.doc.generate_id();
+      id_map[node.id] = new_id;
+      const new_node = { ...node, id: new_id };
+      const node_schema = this.doc.schema[node.type];
+
+      // Update all property references to use new IDs
+      for (const [property_name, property_definition] of Object.entries(node_schema.properties)) {
+        const property_type = property_definition.type;
+        const value = node[property_name];
+
+        // Apply default values
+        if (property_type === 'node_array') {
+          // [] is the default value for node arrays
+          new_node[property_name] = Array.isArray(value) ? value.map(ref_id => id_map[ref_id]) : [];
+        } else if (property_type === 'node') {
+          // null is the default value for node references
+          new_node[property_name] = typeof value === 'string' ? id_map[value] : null;
+        } else if (property_type === 'annotated_text') {
+          if (value) {
+            const annotations = value.annotations.map(annotation => {
+              const {start_offset, end_offset, node_id} = annotation;
+              return {start_offset, end_offset, node_id: id_map[node_id] || node_id};
+            });
+            new_node[property_name] = {text: value.text, annotations};
+          } else {
+            new_node[property_name] = {text: '', annotations: []};
+          }
+        } else if (property_type === 'string') {
+          new_node[property_name] = value ?? property_definition.default ?? '';
+        } else if (property_type === 'integer') {
+          new_node[property_name] = value ?? property_definition.default ?? 0;
+        } else if (property_type === 'number') {
+          new_node[property_name] = value ?? property_definition.default ?? 0;
+        } else if (property_type === 'boolean') {
+          new_node[property_name] = value ?? property_definition.default ?? false;
+        } else if (['integer_array', 'number_array'].includes(property_type)) {
+          new_node[property_name] = value ?? property_definition.default ?? [];
+        } else if (property_type === 'string_array') {
+          new_node[property_name] = value ?? property_definition.default ?? [];
+        }
+      }
+
+      this.create(new_node);
+    }
+
+    return id_map[depth_first_nodes.at(-1).id];
   }
 
   /**
@@ -232,23 +292,60 @@ export default class Transaction {
    * Behavior depends on selection type:
    * - For node selections: Removes selected nodes and cascades deletion of unreferenced nodes
    * - For text selections: Removes selected text and adjusts annotations accordingly
-   * - For collapsed selections: Deletes the previous character/node
+   * - For collapsed selections: Deletes the previous character/node (backward) or next character/node (forward)
    *
+   * @param {'backward' | 'forward'} [direction] - Direction of deletion for collapsed selections
    * @returns {Transaction} This transaction instance for method chaining
    */
-  delete_selection() {
+  delete_selection(direction = 'backward') {
     if (!this.doc.selection) return this;
     const path = this.doc.selection.path;
+
+    if (this.doc.selection.type === 'property') {
+      this.set(path, '');
+      return this;
+    }
+
     // Get the start and end indices for the selection
     let start = Math.min(this.doc.selection.anchor_offset, this.doc.selection.focus_offset);
     let end = Math.max(this.doc.selection.anchor_offset, this.doc.selection.focus_offset);
+    let length;
+
+    if (this.doc.selection?.type === 'text') {
+      const text_content = this.doc.get(this.doc.selection.path).text;
+      length = get_char_length(text_content);
+    } else if (this.doc.selection?.type === 'node') {
+      const node_array = this.doc.get(this.doc.selection.path);
+      length = node_array.length;
+    }
 
-    // If selection is collapsed we delete the previous node
+    // If selection is collapsed we delete the previous char/node (backward)
+    // or the next char/node (forward)
     if (start === end) {
-      if (start > 0) {
+      if (direction === 'backward' && start > 0) {
         start = start - 1;
-      } else {
-        return this; // cursor is at the very beginning, do nothing.
+      } else if (direction === 'forward' && end < length) {
+        end = end + 1;
+      } else if (direction === 'backward' && start === 0) {
+        join_text_node(this);
+        return this;
+      } else if (direction === 'forward' && end === length) {
+        // At end of text - try to join with next text node
+        const node_index = parseInt(String(this.doc.selection.path.at(-2)), 10);
+        const successor_node = this.doc.get([...this.doc.selection.path.slice(0, -2), node_index + 1]);
+        // Check if next node is a text node
+        if (successor_node && this.doc.kind(successor_node) === 'text') {
+          // Set selection to beginning of next text node
+          this.set_selection({
+            type: 'text',
+            path: [...this.doc.selection.path.slice(0, -2), node_index + 1, 'content'],
+            anchor_offset: 0,
+            focus_offset: 0
+          });
+          // Use join_text_node to merge with previous node
+          join_text_node(this);
+        }
+        return this;
       }
     }
 
@@ -344,23 +441,17 @@ export default class Transaction {
   /**
    * Inserts an array of nodes at the current node selection.
    *
-   * If there's a current selection, it will be deleted first. New nodes are
-   * created if they don't already exist (e.g., for cut+paste scenarios).
+   * If there's a current selection, it will be deleted first.
    *
-   * @param {SerializedNode[]} nodes - Array of node objects to insert
+   * @param {NodeId[]} node_ids - Array of node IDs to insert
    * @returns {Transaction} This transaction instance for method chaining
    *
-   * @note Assumes we only insert new nodes, not reference existing ones
-   *
    * @example
    * ```js
-   * tr.insert_nodes([
-   *   {id: 'para_1', type: 'paragraph', content: ['Hello', []]},
-   *   {id: 'para_2', type: 'paragraph', content: ['World', []]}
-   * ]);
+   * tr.insert_nodes_new(['para_1', 'para_2']);
    * ```
    */
-  insert_nodes(nodes) {
+  insert_nodes(node_ids) {
     if (this.doc.selection.type !== 'node') return this;
 
     // Unless cursor is collapsed, delete the selected nodes as a first step
@@ -382,13 +473,6 @@ export default class Transaction {
       node_array.splice(start, end - start);
     }
 
-    // First create the new nodes (unless they already exists e.g. in case of cut+paste)
-    nodes.forEach(node => {
-      if (!this.doc.get(node.id)) {
-        this.create(node);
-      }
-    });
-    const node_ids = nodes.map(node => node.id);
     node_array.splice(start, 0, ...node_ids);
 
     // Update the node_array in the entry
@@ -398,7 +482,7 @@ export default class Transaction {
       type: 'node',
       path: [...this.doc.selection.path],
       anchor_offset: start,
-      focus_offset: start + nodes.length
+      focus_offset: start + node_ids.length
     };
     return this;
   }
@@ -419,7 +503,7 @@ export default class Transaction {
    * tr.insert_text('Hello, world!');
    * ```
    */
-  insert_text(replaced_text) {
+  insert_text(replaced_text, annotations = [], nodes = {}) {
     if (this.doc.selection.type !== 'text') return this;
 
     const annotated_text = structuredClone($state.snapshot(this.doc.get(this.doc.selection.path)));
@@ -487,6 +571,32 @@ export default class Transaction {
       focus_offset: start + get_char_length(replaced_text),
     };
     this.doc.selection = new_selection;
+
+    // Now we apply annotations if there are any, but only if there's no active annotation
+    // at the current collapsed cursor
+    if (!this.doc.active_annotation() && annotations.length > 0) {
+      const new_annotations = annotations.map(annotation => {
+        const original_annotation_node = nodes[annotation.node_id];
+        const text_property_definition = this.doc.inspect(this.doc.selection.path);
+        // console.log('original_annotation_node.type', original_annotation_node.type);
+        // console.log('text_property_definition', text_property_definition);
+        if (text_property_definition.node_types.includes(original_annotation_node.type)) {
+          const new_annotation_node_id = this.build(annotation.node_id, nodes);
+          return {
+            start_offset: start + annotation.start_offset,
+            end_offset: start + annotation.end_offset,
+            node_id: new_annotation_node_id
+          };
+        } else {
+          // Annotation type not allowed in new context, skip it.
+          return null;
+        }
+      }).filter(Boolean);
+      const next_annotated_text = structuredClone(annotated_text);
+      next_annotated_text.annotations = next_annotated_text.annotations.concat(new_annotations);
+      this.set(this.doc.selection.path, next_annotated_text); // this will update the current state and create a history entry
+    }
+
     return this;
   }
 

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

@@ -1 +1 @@
-{"version":3,"file":"commands.svelte.d.ts","sourceRoot":"","sources":["../src/lib/commands.svelte.js"],"names":[],"mappings":"AAGA,kDAqDC;AAED,iDAsEC;AAED,sDA6BC;AAED,6CA6GC"}
+{"version":3,"file":"commands.svelte.d.ts","sourceRoot":"","sources":["../src/lib/commands.svelte.js"],"names":[],"mappings":"AAGA,kDAqDC;AAED,iDAsEC;AAED,sDAwBC;AAED,6CA6GC"}

package/dist/commands.svelte.js

@@ -117,7 +117,7 @@ export function join_text_node(tr) {
   });
 
   tr.delete_selection();
-  
+
   // Finally set the cursor position at the join point using the pre-calculated position
   tr.set_selection({
     type: 'text',
@@ -145,11 +145,6 @@ export function insert_default_node(tr) {
   const property_definition = doc.schema[node_array_node.type].properties[property_name];
   const default_type = get_default_node_type(property_definition);
 
-  // Only proceed if there's exactly one allowed node_type
-  // if (!default_type || property_schema.node_types.length !== 1) {
-  //   return false;
-  // }
-
   // Use the inserter function if available
   if (doc.config?.inserters?.[default_type]) {
     doc.config.inserters[default_type](tr);

package/dist/util.d.ts

@@ -122,5 +122,6 @@ export function join_annotated_text(first_text: AnnotatedText, second_text: Anno
  * snake_to_pascal('list_item') // Returns: 'ListItem'
  */
 export function snake_to_pascal(str: string): string;
+export function traverse(node_id: any, schema: any, nodes: any): any[];
 import type { AnnotatedText } from './types.d.ts';
 //# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/lib/util.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH,qCARW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;;GAcG;AACH,iCATW,MAAM,SACN,MAAM,GACJ,MAAM,CAWlB;AAED;;;;;;;;;;;;;;GAcG;AACH,gCATW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;GAaG;AACH,0CARW,MAAM,gBACN,MAAM,GACJ,MAAM,CAoBlB;AAED;;;;;;;;;;;;;GAaG;AACH,0CARW,MAAM,eACN,MAAM,GACJ,MAAM,CAgBlB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,4DAZW,aAAa,eACb,MAAM,GACJ,CAAC,aAAa,EAAE,aAAa,CAAC,CAyC1C;AAGD;;;;;;;;;;;;;GAaG;AACH,gDARW,aAAa,eACb,aAAa,GACX,aAAa,CAqCzB;AAED;;;;;;;;GAQG;AACH,qCANW,MAAM,GACJ,MAAM,CAUlB;mCAzO6C,cAAc"}
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/lib/util.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH,qCARW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;;GAcG;AACH,iCATW,MAAM,SACN,MAAM,GACJ,MAAM,CAWlB;AAED;;;;;;;;;;;;;;GAcG;AACH,gCATW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;;;;;;;;GAaG;AACH,0CARW,MAAM,gBACN,MAAM,GACJ,MAAM,CAoBlB;AAED;;;;;;;;;;;;;GAaG;AACH,0CARW,MAAM,eACN,MAAM,GACJ,MAAM,CAgBlB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,4DAZW,aAAa,eACb,MAAM,GACJ,CAAC,aAAa,EAAE,aAAa,CAAC,CAyC1C;AAGD;;;;;;;;;;;;;GAaG;AACH,gDARW,aAAa,eACb,aAAa,GACX,aAAa,CAqCzB;AAED;;;;;;;;GAQG;AACH,qCANW,MAAM,GACJ,MAAM,CAUlB;AAED,uEAgCC;mCA3Q6C,cAAc"}

package/dist/util.js

@@ -233,3 +233,37 @@ export function snake_to_pascal(str) {
     .map(word => word.charAt(0).toUpperCase() + word.slice(1))
     .join('');
 }
+
+export function traverse(node_id, schema, nodes) {
+  const json = [];
+  const visited = {};
+  const visit = (node) => {
+    if (!node || visited[node.id]) {
+      return;
+    }
+    visited[node.id] = true;
+    for (const [property_name, value] of Object.entries(node)) {
+      const property_definition = schema[node.type].properties[property_name];
+
+      if (property_definition?.type === 'node_array') {
+        for (const v of value) {
+          if (typeof v === 'string') {
+            visit(nodes[v]);
+          }
+        }
+      } else if (property_definition?.type === 'node') {
+        visit(nodes[value]);
+      } else if (property_definition?.type === 'annotated_text') {
+        for (const annotation of value.annotations) {
+          visit(nodes[annotation.node_id]);
+        }
+      }
+    }
+    // Finally add the node to the result.
+    // Deep clone, to make sure nothing of the original document is referenced.
+    json.push(structuredClone(node));
+  }
+  // Start with the root node (document_id)
+  visit(nodes[node_id]);
+  return json;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "svedit",
-	"version": "0.4.0",
+	"version": "0.5.0",
 	"license": "MIT",
 	"scripts": {
 		"dev": "vite dev",
@@ -39,27 +39,27 @@
 		"svelte": "^5.0.0"
 	},
 	"devDependencies": {
-		"@eslint/compat": "^1.2.5",
-		"@eslint/js": "^9.18.0",
-		"@sveltejs/adapter-auto": "^6.0.0",
-		"@sveltejs/kit": "^2.21.2",
-		"@sveltejs/package": "^2.0.0",
-		"@sveltejs/vite-plugin-svelte": "^6.0.0",
-		"@typescript-eslint/eslint-plugin": "^8.39.1",
-		"@typescript-eslint/parser": "^8.39.1",
+		"@eslint/compat": "^1.4.0",
+		"@eslint/js": "^9.36.0",
+		"@sveltejs/adapter-auto": "^6.1.0",
+		"@sveltejs/kit": "^2.43.7",
+		"@sveltejs/package": "^2.5.4",
+		"@sveltejs/vite-plugin-svelte": "^6.2.1",
+		"@typescript-eslint/eslint-plugin": "^8.45.0",
+		"@typescript-eslint/parser": "^8.45.0",
 		"@vitest/browser": "^3.2.4",
-		"eslint": "^9.18.0",
-		"eslint-config-prettier": "^10.0.1",
-		"eslint-plugin-svelte": "^3.0.0",
-		"globals": "^16.0.0",
-		"prettier": "^3.4.2",
-		"prettier-plugin-svelte": "^3.3.3",
-		"publint": "^0.3.2",
-		"svelte": "^5.0.0",
-		"svelte-check": "^4.0.0",
-		"vite": "^7.0.4",
-		"vitest": "^3.2.3",
+		"eslint": "^9.36.0",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-plugin-svelte": "^3.12.4",
+		"globals": "^16.4.0",
+		"prettier": "^3.6.2",
+		"prettier-plugin-svelte": "^3.4.0",
+		"publint": "^0.3.13",
+		"svelte": "^5.39.8",
+		"svelte-check": "^4.3.2",
+		"vite": "^7.1.7",
+		"vitest": "^3.2.4",
 		"vitest-browser-svelte": "^1.1.0",
-		"nanoid": "^5.1.5"
+		"nanoid": "^5.1.6"
 	}
 }

package/src/lib/Document.svelte.js

@@ -1,5 +1,5 @@
 import Transaction from './Transaction.svelte.js';
-import { char_slice, get_char_length } from './util.js';
+import { char_slice, get_char_length, traverse } from './util.js';
 
 /**
  * @import {
@@ -8,13 +8,10 @@ import { char_slice, get_char_length } from './util.js';
  *   Selection,
  *   Annotation,
  *   PrimitiveType,
- *   DocumentSchemaPrimitive,
  *   NodeProperty,
  *   NodeArrayProperty,
  *   NodeKind,
  *   NodeSchema,
- *   TextNodeSchema,
- *   NonTextNodeSchema,
  *   DocumentSchema,
  *   SerializedDocument
  * } from './types.d.ts';
@@ -315,8 +312,8 @@ export default class Document {
  	get_available_annotation_types() {
     if (this.selection?.type !== 'text') return [];
     const path = this.selection.path;
-    const property_schema = this.inspect(path);
-    return property_schema.node_types || [];
+    const property_definition = this.inspect(path);
+    return property_definition.node_types || [];
 	}
 
  	// Helper function to get the currently selected node
@@ -600,6 +597,47 @@ export default class Document {
     return this.schema[node.type].kind;
   }
 
+  /**
+   * Determines whether a node type can be inserted at a given selection.
+   * @param {string} node_type - The type of node to insert.
+   * @param {Selection} [selection] - The selection at which to insert the node.
+   * @returns {boolean} True if the node type can be inserted, false otherwise.
+   */
+  can_insert(node_type, selection = this.selection) {
+    if (selection?.type === 'node') {
+      const property_definition = this.inspect(selection.path);
+      if (property_definition.node_types.includes(node_type)) {
+        return true;
+      }
+    }
+
+    // No insert position found yet, and root not reached, try one level up if possible
+    let next_node_insert_cursor = this.get_next_node_insert_cursor(selection);
+    if (!next_node_insert_cursor) return false;
+    return this.can_insert(node_type, next_node_insert_cursor);
+  }
+
+  /**
+   * Compute next possible insert position from a given selection
+   *
+   * @param {Selection} [selection] - Reference selection
+   * @returns {Selection} True if the paste operation was successful, false otherwise
+   */
+  get_next_node_insert_cursor(selection = this.selection) {
+    // There's no parent path to insert into
+    if (!selection || selection.path.length <= 2) {
+      return null;
+    }
+
+    const node_offset = parseInt(String(selection.path.at(-2)), 10) + 1;
+    return {
+      type: 'node',
+      path: selection.path.slice(0, -2),
+      anchor_offset: node_offset,
+      focus_offset: node_offset,
+    };
+  }
+
   /**
    * Returns the annotation object that is currently "under the cursor".
    * NOTE: Annotations in Svedit are exclusive, so there can only be one active_annotation
@@ -628,6 +666,35 @@ export default class Document {
     }
   }
 
+  get_selected_annotated_text() {
+    if (this.selection?.type !== 'text') return null;
+
+    const selection_start =   Math.min(this.selection.anchor_offset, this.selection.focus_offset);
+    const selection_end = Math.max(this.selection.anchor_offset, this.selection.focus_offset);
+    const annotated_text = this.get(this.selection.path);
+    const text = char_slice(annotated_text.text, selection_start, selection_end);
+    const nodes = {};
+    const annotations = annotated_text.annotations.map(a => {
+      if (selection_start < a.end_offset && selection_end > a.start_offset) {
+        const sub_graph = this.traverse(a.node_id);
+        for (const node of sub_graph) {
+          if (!nodes[node.id]) {
+            nodes[node.id] = node;
+          }
+        }
+        return {
+          start_offset: Math.max(a.start_offset - selection_start, 0),
+          end_offset: Math.min(a.end_offset - selection_start, selection_end - selection_start),
+          node_id: a.node_id
+        };
+      } else {
+        return null;
+      }
+    }).filter(Boolean);
+
+    return { text, annotations, nodes };
+  }
+
   // TODO: think about ways how we can also turn a node selection into plain text.
   get_selected_plain_text() {
     if (this.selection?.type !== 'text') return null;
@@ -703,37 +770,7 @@ export default class Document {
   // IMPORTANT: Leaf nodes must go first, branches second and the root node (entry point) last (depth-first traversal)
   // NOTE: Nodes that are not reachable from the entry point node will not be included in the serialization
   traverse(node_id) {
-    const json = [];
-    const visited = {};
-    const visit = (node) => {
-      if (!node || visited[node.id]) {
-        return;
-      }
-      visited[node.id] = true;
-      for (const [property_name, value] of Object.entries(node)) {
-        const property_schema = this.schema[node.type].properties[property_name];
-
-        if (property_schema?.type === 'node_array') {
-          for (const v of value) {
-            if (typeof v === 'string') {
-              visit($state.snapshot(this.get(v)));
-            }
-          }
-        } else if (property_schema?.type === 'node') {
-          visit($state.snapshot(this.get(value)));
-        } else if (property_schema?.type === 'annotated_text') {
-          for (const annotation of value.annotations) {
-            visit($state.snapshot(this.get(annotation.node_id)));
-          }
-        }
-      }
-      // Finally add the node to the result.
-      // We use a deep clone, so we make sure nothing of the original document is referenced.
-      json.push(structuredClone(node));
-    }
-    // Start with the root node (document_id)
-    visit($state.snapshot(this.get(node_id)));
-    return json;
+    return traverse(node_id, this.schema, $state.snapshot(this.nodes));
   }
 
   /**