@aionbuilders/nabu 0.1.0-alpha.0

package/dist/blocks/heading/heading.svelte.js

@@ -0,0 +1,94 @@
+import { TextBehavior } from "../../behaviors/text";
+import HeadingComponent from "./Heading.svelte";
+import { Block } from "../block.svelte";
+import { LoroText } from "loro-crdt";
+
+/**
+ * @import { Nabu, NabuNode } from "../nabu.svelte";
+ * @import { TextNode } from "../../behaviors/text";
+ */
+
+/**
+ * @typedef {NabuNode<{type: "heading", text: LoroText, level: number}>} HeadingNode
+ */
+
+export class Heading extends Block {
+    /** @param {Nabu} nabu @param {HeadingNode} node */
+    constructor(nabu, node) {
+        super(nabu, node);
+        const data = node.data;
+        this.container = data.get("text") ?? data.setContainer("text", new LoroText());
+
+        /** @type {TextBehavior} */
+        this.behavior = new TextBehavior(this, this.container);
+        this.behaviors.set("text", this.behavior);
+
+        this.level = data.get("level") || 1;
+
+        this.serializers.set('markdown', () => `${'#'.repeat(this.level)} ${this.behavior.toMarkdown()}`);
+        this.serializers.set('json', () => ({
+            id: this.id,
+            type: 'heading',
+            props: { level: this.level },
+            content: this.behavior.toJSON()
+        }));
+        
+        // Synchronisation du niveau
+        this.node.data.subscribe(() => {
+            this.level = this.node.data.get("level") || 1;
+        });
+    }
+
+    /** @type {number} */
+    level = $state(1);
+
+    component = $derived(this.nabu.components.get("heading") || HeadingComponent);
+    
+    get text() {
+        return this.behavior.text;
+    }
+
+    get delta() {
+        return this.behavior.delta;
+    }
+
+    selection = $derived(this.behavior.selection);
+
+    /** @param {InputEvent} event */
+    beforeinput(event) {
+        return this.behavior.handleBeforeInput(event);
+    }
+
+    /**
+     * @param {number} targetOffset 
+     * @returns {{node: Node, offset: number} | null}
+     */
+    getDOMPoint(targetOffset) { return this.behavior.getDOMPoint(targetOffset); }
+
+    /** @param {Block} block */
+    absorbs(block) { return this.behavior.absorbs(block); }
+
+    /** @param {number} index @param {string} text */
+    insert(index, text) { return this.behavior.insert(index, text); }
+    
+    /** @param {Parameters<Block["delete"]>[0]} [deletion] */
+    delete(deletion) { return this.behavior.delete(deletion); }
+
+    /** @param {import('loro-crdt').Delta<string>[]} data */
+    applyDelta(data = []) { return this.behavior.applyDelta(data); }
+
+    /** @param {Parameters<Block["split"]>[0]} [options] @returns {ReturnType<Block["split"]>} */
+    split(options) { return this.behavior.split(options); }
+
+    /** @param {Nabu} nabu @param {string} type @param {Object} [props={}] @param {string|null} [parentId=null] @param {number|null} [index=null] */
+    static create(nabu, type, props = {}, parentId = null, index = null) {
+        const node = nabu.tree.createNode(parentId || undefined, index || undefined);
+        node.data.set("type", "heading");
+        node.data.set("level", props.level || 1);
+        const container = node.data.setContainer("text", new LoroText());
+        if (props.text) container.insert(0, props.text);
+        if (props.delta) container.applyDelta([...props.delta]);
+        const block = new Heading(nabu, node);
+        return block;
+    }
+}

package/dist/blocks/heading/hooks/onBeforeInput.hook.d.ts

@@ -0,0 +1,3 @@
+export function onBeforeInput(nabu: Nabu, event: InputEvent, block: Block): symbol;
+import type { Nabu } from "../..";
+import type { Block } from "../..";

package/dist/blocks/heading/hooks/onBeforeInput.hook.js

@@ -0,0 +1,58 @@
+import { tick } from "svelte";
+import { TextBehavior } from "../../../behaviors/text";
+import {Heading} from "../heading.svelte";
+
+/**
+ * @import { Nabu, Block } from "../..";
+ */
+
+/** @param {Nabu} nabu @param {InputEvent} event @param {Block} block */
+export const onBeforeInput = (nabu, event, block) => {
+    const {BREAK, CONTINUE} = nabu;
+    if (event.inputType === "deleteContentBackward" && block instanceof Heading) {
+        const behavior = block.behaviors.get("text");
+        if (!behavior || !(behavior instanceof TextBehavior)) return CONTINUE;
+        const sel = behavior.selection;
+        if (!sel || !sel.isCollapsed || sel.from !== 0) return CONTINUE;
+        const blockId = block.node.id.toString();
+        block.transformTo("paragraph");
+        tick().then(() => {
+            const block = nabu.blocks.get(blockId);
+            if (block) block.focus({start: 0, end: 0});
+        });
+        return BREAK;
+    }
+
+
+    if (event.data !== " ") return CONTINUE;
+    
+    const behavior = block.behaviors.get("text");
+    if (!behavior || !(behavior instanceof TextBehavior)) return CONTINUE;
+    
+    const sel = behavior.selection;
+    if (!sel || !sel.isCollapsed) return CONTINUE;
+    
+    const text = behavior.text;
+    const textBeforeCursor = text.slice(0, sel.from);
+    
+    const match = textBeforeCursor.match(/^(#{1,6})$/);
+    if (!match) return CONTINUE;
+    
+    const level = match[1].length;
+    
+    if (block.type === "heading" && block.level === level) return CONTINUE;
+    
+    behavior.delete({index: 0, length: level});
+    
+    const blockId = block.node.id.toString();
+    
+    block.transformTo("heading", { level });
+    
+    tick().then(() => {
+        const block = nabu.blocks.get(blockId);
+        if (block) block.focus({start: 0, end: 0});
+    });
+    
+    return BREAK;
+}
+

package/dist/blocks/heading/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @import { Nabu } from "../nabu.svelte";
+ */
+export const HeadingExtension: import("../..").Extension;
+import HeadingComponent from "./Heading.svelte";
+import { Heading } from "./heading.svelte";
+export { HeadingComponent, Heading };

package/dist/blocks/heading/index.js

@@ -0,0 +1,41 @@
+import { tick } from "svelte";
+import { TextBehavior } from "../../behaviors/text";
+import { extension } from "../../utils/extensions";
+import { Heading } from "./heading.svelte";
+import HeadingComponent from "./Heading.svelte";
+import { onBeforeInput } from "./hooks/onBeforeInput.hook";
+
+/**
+ * @import { Nabu } from "../nabu.svelte";
+ */
+
+const HeadingExtension = extension("heading", {
+    block: Heading,
+    component: HeadingComponent,
+    hooks: {
+        /** @param {Nabu} nabu @param {Heading} block @param {Event} event @param {{offset: number, delta: import('loro-crdt').Delta<string>}} data */
+        onSplit: (nabu, block, event, data) => {
+            const { offset, delta } = data;
+            
+            block.delete({from: offset, to: -1});
+            
+            const currentIndex = block.node.index();
+            const parent = block.node.parent();
+            const parentId = parent?.id.toString() || null;
+            
+            // On split souvent un titre pour créer un paragraphe après
+            const newBlock = nabu.insert("paragraph", { delta }, parentId, currentIndex + 1);
+
+            block.commit();
+            
+            setTimeout(() => {
+                nabu.selection.setCursor(newBlock, 0);
+            }, 0);
+
+            return { block: newBlock };
+        },
+        onBeforeInput,
+    }
+})
+
+export { HeadingExtension, HeadingComponent, Heading };

package/dist/blocks/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./block.svelte";
+export * from "./nabu.svelte";
+export * from "./megablock.svelte";
+export * from "./container.utils";
+export * from "./paragraph";
+export * from "./heading";
+export * from "./list";
+export * from "./selection.svelte";
+export { default as NabuEditor } from "./Nabu.svelte";
+export { default as BlockComponent } from "./Block.svelte";

package/dist/blocks/index.js

@@ -0,0 +1,12 @@
+export * from "./block.svelte";
+export * from "./nabu.svelte";
+export * from "./megablock.svelte";
+export { default as NabuEditor } from "./Nabu.svelte";
+export { default as BlockComponent } from "./Block.svelte";
+export * from "./container.utils";
+
+export * from "./paragraph";
+export * from "./heading";
+export * from "./list";
+
+export * from "./selection.svelte";

package/dist/blocks/list/List.svelte

@@ -0,0 +1,25 @@
+<script>
+    import Block from "../Block.svelte";
+    
+    /** @type {{block: import('./list.svelte.js').List}}*/
+    let {block} = $props();
+</script>
+
+<svelte:element 
+    this={block.listType === 'ordered' ? 'ol' : 'ul'} 
+    data-block-id={block.id}
+    data-block-type="list"
+    class="nabu-list"
+>
+    {#each block.children as child (child.id)}
+        <Block block={child} />
+    {/each}
+</svelte:element>
+
+<style>
+    .nabu-list {
+        margin-top: 0.5rem;
+        margin-bottom: 0.5rem;
+        padding-left: 1.5rem;
+    }
+</style>

package/dist/blocks/list/List.svelte.d.ts

@@ -0,0 +1,11 @@
+export default List;
+type List = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<$$ComponentProps>): void;
+};
+declare const List: import("svelte").Component<{
+    block: import("./list.svelte.js").List;
+}, {}, "">;
+type $$ComponentProps = {
+    block: import("./list.svelte.js").List;
+};

package/dist/blocks/list/ListItem.svelte

@@ -0,0 +1,45 @@
+<script>
+    import Block from "../Block.svelte";
+    import RichText from '../../behaviors/text/RichText.svelte';
+
+    /** @type {{block: import('./list-item.svelte.js').ListItem}}*/
+    let {block} = $props();
+</script>
+
+<li 
+    data-block-id={block.id}
+    data-block-type="list-item"
+    class="nabu-list-item"
+    class:selected={block.selected}
+    class:first={block.isSelectionStart}
+    class:last={block.isSelectionEnd}
+>
+    <div bind:this={block.element} class="item-content"><RichText delta={block.delta} /></div><!-- 
+    -->{#if block.children && block.children.length > 0}
+    <div class="item-children">
+        {#each block.children as child (child.id)}
+        <Block block={child} />
+        {/each}
+    </div>
+    {/if}
+</li>
+
+<style>
+    .nabu-list-item {
+        margin: 0.25rem 0;
+        
+        &.selected > .item-content {
+            background-color: rgba(59, 130, 246, 0.25);
+        }
+    }
+    
+    .item-content {
+        outline: none;
+        white-space: pre-wrap;
+        min-height: 1.5em; /* Permet de cliquer dans un item vide */
+    }
+    
+    .item-children {
+        /* Pas de margin-left ici, c'est le <ul> imbriqué qui gèrera l'indentation */
+    }
+</style>

package/dist/blocks/list/ListItem.svelte.d.ts

@@ -0,0 +1,11 @@
+export default ListItem;
+type ListItem = {
+    $on?(type: string, callback: (e: any) => void): () => void;
+    $set?(props: Partial<$$ComponentProps>): void;
+};
+declare const ListItem: import("svelte").Component<{
+    block: import("./list-item.svelte.js").ListItem;
+}, {}, "">;
+type $$ComponentProps = {
+    block: import("./list-item.svelte.js").ListItem;
+};

package/dist/blocks/list/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @import {SvelteSet} from "svelte/reactivity";
+ */
+export const ListExtension: import("../..").Extension;
+export const ListItemExtension: import("../..").Extension;
+import { List } from "./list.svelte";
+import { ListItem } from "./list-item.svelte";
+import ListComponent from "./List.svelte";
+import ListItemComponent from "./ListItem.svelte";
+export { List, ListItem, ListComponent, ListItemComponent };

package/dist/blocks/list/index.js

@@ -0,0 +1,41 @@
+import { extension } from "../../utils/extensions";
+import { List } from "./list.svelte";
+import ListComponent from "./List.svelte";
+import { ListItem } from "./list-item.svelte";
+import ListItemComponent from "./ListItem.svelte";
+import { ListBehavior } from "./list.behavior.svelte";
+
+/**
+ * @import {SvelteSet} from "svelte/reactivity";
+ */
+
+const ListExtension = extension("list", {
+    block: List,
+    component: ListComponent,
+    hooks: {
+        onBeforeTransaction(nabu) {
+            const lists = /** @type {SvelteSet<List>} */ (nabu.blocksByType.get("list"));
+            lists?.forEach(list => {
+                const behavior = list.behaviors.get("list");
+                if (!behavior || !(behavior instanceof ListBehavior)) return;
+                const sibblings = list.getAdjacentSiblings();
+                const previous = sibblings.previous;
+                if (!previous) return;
+                const previousBehavior = previous.behaviors.get("list");
+                if (!previousBehavior || !(previousBehavior instanceof ListBehavior)) return;
+                
+                previousBehavior.absorbs(list);
+                list.destroy();
+
+            })
+
+        }
+    }
+});
+
+const ListItemExtension = extension("list-item", {
+    block: ListItem,
+    component: ListItemComponent,
+});
+
+export { ListExtension, ListItemExtension, List, ListItem, ListComponent, ListItemComponent };

package/dist/blocks/list/list-item.svelte.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @import { Nabu, NabuNode, Block } from "..";
+ */
+/**
+ * @typedef {NabuNode<{type: "list-item", text: LoroText}>} ListItemNode
+ */
+export class ListItem extends MegaBlock {
+    /** @param {Nabu} nabu @param {string} type @param {Object} [props={}] @param {string|null} [parentId=null] @param {number|null} [index=null] */
+    static create(nabu: Nabu, type: string, props?: Object, parentId?: string | null, index?: number | null): ListItem;
+    /** @param {Nabu} nabu @param {ListItemNode} node */
+    constructor(nabu: Nabu, node: ListItemNode);
+    container: LoroText;
+    /** @type {TextBehavior} */
+    behavior: TextBehavior;
+    component: import("svelte").Component<any, any, string> | import("svelte").Component<{
+        block: import("./list-item.svelte").ListItem;
+    }, {}, "">;
+    get text(): string;
+    get delta(): import("loro-crdt").Delta<string>[];
+    selection: {
+        from: number;
+        to: number;
+        isCollapsed: boolean;
+        direction: "forward" | "backward" | "none";
+    } | null;
+    sublist: Block | undefined;
+    /**
+     * Retourne la sous-liste existante, ou en crée une nouvelle à la fin des enfants.
+     * @param {"bullet" | "ordered"} [listType="bullet"]
+     */
+    getOrCreateSublist(listType?: "bullet" | "ordered"): Block;
+    /** @param {KeyboardEvent} event */
+    keydown(event: KeyboardEvent): boolean;
+    /** @param {import('../block.svelte').Block} block */
+    absorbs(block: import("../block.svelte").Block): boolean;
+    /** @param {import('loro-crdt').Delta<string>[]} data */
+    applyDelta(data?: import("loro-crdt").Delta<string>[]): void;
+    /** @param {Parameters<import('../block.svelte').Block["split"]>[0]} [options] @returns {ReturnType<import('../block.svelte').Block["split"]>} */
+    split(options?: Parameters<import("../block.svelte").Block["split"]>[0]): ReturnType<import("../block.svelte").Block["split"]>;
+}
+export type ListItemNode = NabuNode<{
+    type: "list-item";
+    text: LoroText;
+}>;
+import { MegaBlock } from "../megablock.svelte";
+import { LoroText } from "loro-crdt";
+import { TextBehavior } from "../../behaviors/text";
+import type { Block } from "..";
+import type { Nabu } from "..";
+import type { NabuNode } from "..";

package/dist/blocks/list/list-item.svelte.js

@@ -0,0 +1,213 @@
+import { MegaBlock } from "../megablock.svelte";
+import ListItemComponent from "./ListItem.svelte";
+import { LoroText } from "loro-crdt";
+import { TextBehavior } from "../../behaviors/text";
+
+/**
+ * @import { Nabu, NabuNode, Block } from "..";
+ */
+
+/**
+ * @typedef {NabuNode<{type: "list-item", text: LoroText}>} ListItemNode
+ */
+
+export class ListItem extends MegaBlock {
+    /** @param {Nabu} nabu @param {ListItemNode} node */
+    constructor(nabu, node) {
+        super(nabu, node);
+        
+        const data = node.data;
+        this.container = data.get("text") ?? data.setContainer("text", new LoroText());
+
+        /** @type {TextBehavior} */
+        this.behavior = new TextBehavior(this, this.container);
+        this.behaviors.set("text", this.behavior);
+
+        this.serializers.set('markdown', () => {
+            const depth = this.parents.filter(p => p.type === 'listItem').length;
+            const indent = '  '.repeat(depth);
+            const listType = /** @type {any} */ (this.parent)?.listType ?? 'bullet';
+            const prefix = listType === 'ordered' ? `${this.index + 1}.` : '-';
+            const lines = [`${indent}${prefix} ${this.behavior.toMarkdown()}`];
+            if (this.sublist) {
+                const sublistMd = this.sublist.serialize('markdown');
+                if (sublistMd) lines.push(sublistMd);
+            }
+            return lines.join('\n');
+        });
+        this.serializers.set('json', () => {
+            /** @type {Record<string, any>} */
+            const result = {
+                id: this.id,
+                type: 'list-item',
+                content: this.behavior.toJSON()
+            };
+            const childrenJson = this.children.map(c => c.serialize('json')).filter(Boolean);
+            if (childrenJson.length) result.children = childrenJson;
+            return result;
+        });
+    }
+
+    component = $derived(this.nabu.components.get("list-item") || ListItemComponent);
+    
+    get text() {
+        return this.behavior.text;
+    }
+
+    get delta() {
+        return this.behavior.delta;
+    }
+
+    selection = $derived(this.behavior.selection);
+
+    sublist = $derived(this.children.find(child => child.node.data.get("type") === "list"));
+
+    /**
+     * Retourne la sous-liste existante, ou en crée une nouvelle à la fin des enfants.
+     * @param {"bullet" | "ordered"} [listType="bullet"] 
+     */
+    getOrCreateSublist(listType = "bullet") {
+        if (this.sublist) return this.sublist;
+        
+        // S'il n'y en a pas, on demande à Nabu d'en créer une en tant qu'enfant de ce ListItem
+        const newList = this.nabu.insert("list", { listType }, this.node.id.toString());
+        return newList;
+    }
+
+    /** @param {KeyboardEvent} event */
+    keydown(event) {
+        if (event.key === "Tab") {
+            event.preventDefault(); // On bloque le comportement natif
+            
+            if (event.shiftKey) {
+                // --- Shift+Tab (Unindent with Carry) ---
+                
+                // 1. Notre parent immédiat (une List)
+                const parentListNode = this.node.parent();
+                if (!parentListNode) return true;
+                
+                // 2. Le ListItem qui contient cette liste (le "grand-parent" logique)
+                const grandParentItemNode = parentListNode.parent();
+                
+                // Si on n'a pas de ListItem au-dessus (on est déjà au premier niveau)
+                if (!grandParentItemNode || grandParentItemNode.data.get("type") !== "list-item") {
+                    return true;
+                }
+
+                // 3. Gérer le "Carry" : emporter les frères suivants avec nous
+                const myIndex = this.node.index();
+                const siblings = parentListNode.children();
+                const followers = siblings.slice(myIndex + 1);
+                
+                if (followers.length > 0) {
+                    // On s'assure d'avoir notre propre sous-liste pour accueillir nos anciens frères
+                    const mySublist = this.getOrCreateSublist();
+                    for (const follower of followers) {
+                        this.nabu.tree.move(follower.id.toString(), mySublist.node.id.toString());
+                    }
+                }
+                
+                // 4. Le parent cible est la List qui contient notre grand-parent
+                const targetParentListNode = grandParentItemNode.parent();
+                if (!targetParentListNode) return true;
+                
+                // 5. On se place juste après notre ancien grand-parent
+                const targetIndex = grandParentItemNode.index() + 1;
+                
+                this.nabu.tree.move(this.node.id.toString(), targetParentListNode.id.toString(), targetIndex);
+                
+                this.commit();
+                
+                // 6. Restauration du focus
+                setTimeout(() => this.behavior.block.focus(), 0);
+            } else {
+                // --- Tab (Indent with Hoist) ---
+                
+                // 1. On trouve notre index actuel
+                const currentIndex = this.node.index();
+                if (currentIndex === 0) return true; // Impossible d'indenter le premier item
+                
+                // 2. On trouve le frère précédent (qui va devenir notre parent "logique")
+                const parentList = this.node.parent();
+                if (!parentList) return true;
+                
+                const previousNode = parentList.children()?.[currentIndex - 1];
+                if (!previousNode) return true;
+                const previousItem = this.nabu.blocks.get(previousNode.id.toString());
+                
+                // Si le frère précédent n'est pas un ListItem
+                if (!previousItem || previousItem.type !== "list-item") return true;
+                
+                // 3. On demande au frère précédent sa sous-liste (ou de la créer)
+                // @ts-ignore : On sait que c'est un ListItem
+                const targetSublist = previousItem.getOrCreateSublist();
+                const targetSublistId = targetSublist.node.id.toString();
+                
+                // 4. On se déplace à la fin de cette sous-liste cible
+                this.nabu.tree.move(this.node.id.toString(), targetSublistId);
+                
+                // 5. Si on avait des enfants (Hoist), on les remonte avec nous en tant que frères
+                if (this.sublist) {
+                    const childrenNodes = this.sublist.node.children();
+                    for (const childNode of childrenNodes) {
+                        // Ils se placeront après nous dans la nouvelle liste
+                        this.nabu.tree.move(childNode.id.toString(), targetSublistId);
+                    }
+                }
+
+                this.commit();
+                
+                // 6. On restaure le curseur
+                setTimeout(() => this.behavior.block.focus(), 0);
+            }
+            return true;
+        }
+        
+        // On délègue les flèches etc.
+        return false;
+    }
+
+    /** @param {InputEvent} event */
+    beforeinput(event) {
+        return this.behavior.handleBeforeInput(event);
+    }
+
+    /**
+     * @param {number} targetOffset 
+     * @returns {{node: Node, offset: number} | null}
+     */
+    getDOMPoint(targetOffset) { return this.behavior.getDOMPoint(targetOffset); }
+
+    /** @param {import('../block.svelte').Block} block */
+    absorbs(block) { return this.behavior.absorbs(block); }
+
+    
+
+    /** @param {number} index @param {string} text */
+    insert(index, text) { return this.behavior.insert(index, text); }
+    
+    /** @param {Parameters<import('../block.svelte').Block["delete"]>[0]} [deletion] */
+    delete(deletion) { return this.behavior.delete(deletion); }
+
+    /** @param {import('loro-crdt').Delta<string>[]} data */
+    applyDelta(data = []) { return this.behavior.applyDelta(data); }
+
+    /** @param {Parameters<import('../block.svelte').Block["split"]>[0]} [options] @returns {ReturnType<import('../block.svelte').Block["split"]>} */
+    split(options) { 
+        return this.ascend("onSplit", null, { 
+            offset: options?.offset || 0,
+            delta: this.behavior.container.sliceDelta(options?.offset || 0, this.text.length)
+        });
+    }
+
+    /** @param {Nabu} nabu @param {string} type @param {Object} [props={}] @param {string|null} [parentId=null] @param {number|null} [index=null] */
+    static create(nabu, type, props = {}, parentId = null, index = null) {
+        const node = nabu.tree.createNode(parentId || undefined, index || undefined);
+        node.data.set("type", "list-item");
+        const container = node.data.setContainer("text", new LoroText());
+        if (props.text) container.insert(0, props.text);
+        if (props.delta) container.applyDelta([...props.delta]);
+        const block = new ListItem(nabu, node);
+        return block;
+    }
+}

package/dist/blocks/list/list.behavior.svelte.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @import {Block, NabuNode} from "..";
+ * @import {LoroText} from "loro-crdt";
+ */
+/**
+ * @typedef {NabuNode<{type: "list", listType: "bullet" | "ordered"}>} ListNode
+ */
+export class ListBehavior {
+    /** @param {Block} block */
+    constructor(block: Block);
+    block: Block;
+    node: ListNode;
+    /** @type {"bullet" | "ordered"} */
+    listType: "bullet" | "ordered";
+    /** @param {Block} block */
+    absorbs(block: Block): true | undefined;
+}
+export type ListNode = NabuNode<{
+    type: "list";
+    listType: "bullet" | "ordered";
+}>;
+import type { Block } from "..";
+import type { NabuNode } from "..";