@liminis/editor 0.1.0-rc.1

package/dist/app/editor/nodes/CustomLinkNode.js

@@ -0,0 +1,209 @@
+import { LinkNode } from '@lexical/link';
+/**
+ * CustomLinkNode - Extends Lexical's LinkNode to prevent VS Code webview link interception
+ *
+ * The standard LinkNode renders `<a href="...">` which VS Code webviews intercept and
+ * open automatically on click. This custom node renders `<a data-href="...">` instead,
+ * allowing us to control navigation via JavaScript (Cmd+click to open).
+ */
+export class CustomLinkNode extends LinkNode {
+    /** @internal */
+    __wikiAliasState;
+    /**
+     * Whether this link was parsed from genuine `[[target]]` / `[[target|alias]]`
+     * wiki-link syntax, as opposed to a standard `[text](url)` link whose URL
+     * merely looks wiki-link-shaped. Export (`convertLinkNode` in
+     * `lexicalToMdast.ts`) always promotes a node with this flag set back to
+     * wiki-link syntax, regardless of `wikiLinkPromotionMode` — an opted-out
+     * host still must not corrupt a document's existing wiki-links (liminis#951).
+     * @internal
+     */
+    __wikiLinkOrigin;
+    constructor(url, attributes, key) {
+        super(url, attributes, key);
+        this.__wikiAliasState = null;
+        this.__wikiLinkOrigin = false;
+    }
+    static getType() {
+        return 'link'; // Use same type to replace the default LinkNode
+    }
+    static clone(node) {
+        const cloned = new CustomLinkNode(node.__url, { rel: node.__rel, target: node.__target, title: node.__title }, node.__key);
+        cloned.__wikiAliasState = node.__wikiAliasState;
+        cloned.__wikiLinkOrigin = node.__wikiLinkOrigin;
+        return cloned;
+    }
+    createDOM(config) {
+        void config;
+        const element = document.createElement('a');
+        // Store URL in data-href instead of href to prevent webview interception
+        element.setAttribute('data-href', this.__url);
+        if (this.__target !== null) {
+            element.target = this.__target;
+        }
+        if (this.__rel !== null) {
+            element.rel = this.__rel;
+        }
+        if (this.__title !== null) {
+            element.title = this.__title;
+        }
+        // Add visual styling class
+        element.className = 'editor-link';
+        // Mark wiki-links (internal .md links) with a data attribute
+        // This allows the WikiLinkExistencePlugin to check and style broken links
+        if (this.isWikiLink()) {
+            element.setAttribute('data-wiki-link', 'true');
+            element.setAttribute('data-wiki-target', this.__url);
+        }
+        else if (this.isExternalLink()) {
+            // External links get blue styling to differentiate from wiki-links
+            element.classList.add('editor-link-external');
+        }
+        return element;
+    }
+    /**
+     * Check if this link is a wiki-link (internal markdown file)
+     */
+    isWikiLink() {
+        const url = this.__url;
+        // Wiki-links are internal paths that don't start with http/https/mailto
+        // and typically end in .md or have no extension
+        return !url.startsWith('http://') &&
+            !url.startsWith('https://') &&
+            !url.startsWith('mailto:') &&
+            !url.startsWith('#');
+    }
+    /**
+     * Check if this link is an external link (http/https/mailto)
+     */
+    isExternalLink() {
+        const url = this.__url;
+        return url.startsWith('http://') || url.startsWith('https://') || url.startsWith('mailto:');
+    }
+    updateDOM(prevNode, anchor, config) {
+        void config;
+        const url = this.__url;
+        const target = this.__target;
+        const rel = this.__rel;
+        const title = this.__title;
+        if (url !== prevNode.__url) {
+            anchor.setAttribute('data-href', url);
+            // Update wiki-link attributes and external link class when URL changes
+            if (this.isWikiLink()) {
+                anchor.setAttribute('data-wiki-link', 'true');
+                anchor.setAttribute('data-wiki-target', url);
+                anchor.classList.remove('editor-link-external');
+            }
+            else {
+                anchor.removeAttribute('data-wiki-link');
+                anchor.removeAttribute('data-wiki-target');
+                anchor.classList.remove('editor-link-broken');
+                if (this.isExternalLink()) {
+                    anchor.classList.add('editor-link-external');
+                }
+                else {
+                    anchor.classList.remove('editor-link-external');
+                }
+            }
+        }
+        if (target !== prevNode.__target) {
+            if (target) {
+                anchor.target = target;
+            }
+            else {
+                anchor.removeAttribute('target');
+            }
+        }
+        if (rel !== prevNode.__rel) {
+            if (rel) {
+                anchor.rel = rel;
+            }
+            else {
+                anchor.removeAttribute('rel');
+            }
+        }
+        if (title !== prevNode.__title) {
+            if (title) {
+                anchor.title = title;
+            }
+            else {
+                anchor.removeAttribute('title');
+            }
+        }
+        return false;
+    }
+    static importDOM() {
+        return {
+            a: (node) => {
+                void node;
+                return {
+                    conversion: convertAnchorElement,
+                    priority: 1,
+                };
+            },
+        };
+    }
+    static importJSON(serializedNode) {
+        const node = $createCustomLinkNode(serializedNode.url, {
+            rel: serializedNode.rel,
+            target: serializedNode.target,
+            title: serializedNode.title,
+        });
+        if (serializedNode.wikiAliasState === 'empty') {
+            node.__wikiAliasState = 'empty';
+        }
+        if (serializedNode.wikiLinkOrigin) {
+            node.__wikiLinkOrigin = true;
+        }
+        node.setFormat(serializedNode.format);
+        node.setIndent(serializedNode.indent);
+        node.setDirection(serializedNode.direction);
+        return node;
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            type: 'link',
+            version: 1,
+            wikiAliasState: this.__wikiAliasState ?? undefined,
+            wikiLinkOrigin: this.__wikiLinkOrigin ? true : undefined,
+        };
+    }
+    setWikiAliasState(state) {
+        const writable = this.getWritable();
+        writable.__wikiAliasState = state;
+    }
+    getWikiAliasState() {
+        return this.__wikiAliasState ?? null;
+    }
+    setWikiLinkOrigin(origin) {
+        const writable = this.getWritable();
+        writable.__wikiLinkOrigin = origin;
+    }
+    getWikiLinkOrigin() {
+        return this.__wikiLinkOrigin;
+    }
+}
+function convertAnchorElement(domNode) {
+    let node = null;
+    if (domNode instanceof HTMLAnchorElement) {
+        // Check data-href first (our custom attribute), then fall back to href
+        const url = domNode.getAttribute('data-href') || domNode.getAttribute('href');
+        if (url) {
+            node = $createCustomLinkNode(url, {
+                rel: domNode.getAttribute('rel'),
+                target: domNode.getAttribute('target'),
+                title: domNode.getAttribute('title'),
+            });
+        }
+    }
+    return { node };
+}
+export function $createCustomLinkNode(url, attributes) {
+    const node = new CustomLinkNode(url, attributes);
+    node.__wikiAliasState = null;
+    return node;
+}
+export function $isCustomLinkNode(node) {
+    return node instanceof CustomLinkNode;
+}

package/dist/app/editor/nodes/CustomListItemNode.d.ts

@@ -0,0 +1,46 @@
+import { ListItemNode, SerializedListItemNode } from '@lexical/list';
+import { LexicalNode, NodeKey, EditorConfig } from 'lexical';
+export declare const ORDERED_TASK_CHECKED_CLASS = "editor-listitem-ordered-checked";
+export declare const ORDERED_TASK_UNCHECKED_CLASS = "editor-listitem-ordered-unchecked";
+export type SerializedCustomListItemNode = SerializedListItemNode & {
+    taskChecked?: boolean | null;
+};
+/**
+ * CustomListItemNode - Extends Lexical's ListItemNode to carry each item's true
+ * per-item task-checkbox state through the markdown round trip.
+ *
+ * Stock ListItemNode.getChecked() is not a stored value — it's derived as
+ * `parentList.getListType() === 'check' ? Boolean(__checked) : undefined`. In a
+ * list that mixes checkbox and plain items, the list is typed 'check' (so the
+ * items that need checkbox UI get it), which makes every plain item's
+ * getChecked() coerce `Boolean(undefined)` to `false` — indistinguishable from
+ * a genuine unchecked task. This subclass stores the tri-state
+ * (checked / unchecked / not-a-task) independent of the parent list's type, so
+ * export can tell plain items and unchecked tasks apart.
+ */
+export declare class CustomListItemNode extends ListItemNode {
+    /** @internal */
+    __taskChecked: boolean | null;
+    constructor(value?: number, checked?: boolean, key?: NodeKey);
+    static getType(): string;
+    static clone(node: CustomListItemNode): CustomListItemNode;
+    static importJSON(serializedNode: SerializedCustomListItemNode): CustomListItemNode;
+    exportJSON(): SerializedCustomListItemNode;
+    setChecked(checked?: boolean): this;
+    setTaskChecked(taskChecked: boolean | null): void;
+    getTaskChecked(): boolean | null;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(prevNode: CustomListItemNode, dom: HTMLElement, config: EditorConfig): boolean;
+    /**
+     * Applies (or clears) the ordered-task checkbox affordance. Only fires for
+     * a leaf item (mirrors stock's own `!$isListNode(getFirstChild())` guard —
+     * a list item whose only child is a nested list isn't itself a task) whose
+     * parent list is `'number'`-typed and whose own `__taskChecked` (this
+     * item's field, not the list's) is non-null — a plain item in a mixed
+     * ordered list is left with no checkbox, same as a plain item in a mixed
+     * unordered list today.
+     */
+    private updateOrderedTaskDOM;
+}
+export declare function $createCustomListItemNode(checked?: boolean): CustomListItemNode;
+export declare function $isCustomListItemNode(node: LexicalNode | null | undefined): node is CustomListItemNode;

package/dist/app/editor/nodes/CustomListItemNode.js

@@ -0,0 +1,120 @@
+import { ListItemNode, $isListNode } from '@lexical/list';
+// Ordered-task checkbox rendering is owned entirely by this node rather than
+// by @lexical/list's own checklist support, which only renders a checkbox
+// (DOM attributes, theme classes, click/keyboard handling) when the *parent
+// list's* listType is 'check' — and Lexical has no 'check'-typed list that is
+// also numbered. These class names are deliberately separate from the
+// editorTheme's listitemChecked/listitemUnchecked (Editor.tsx), which apply
+// `list-style-type: none` and would suppress <ol> numbering.
+export const ORDERED_TASK_CHECKED_CLASS = 'editor-listitem-ordered-checked';
+export const ORDERED_TASK_UNCHECKED_CLASS = 'editor-listitem-ordered-unchecked';
+/**
+ * CustomListItemNode - Extends Lexical's ListItemNode to carry each item's true
+ * per-item task-checkbox state through the markdown round trip.
+ *
+ * Stock ListItemNode.getChecked() is not a stored value — it's derived as
+ * `parentList.getListType() === 'check' ? Boolean(__checked) : undefined`. In a
+ * list that mixes checkbox and plain items, the list is typed 'check' (so the
+ * items that need checkbox UI get it), which makes every plain item's
+ * getChecked() coerce `Boolean(undefined)` to `false` — indistinguishable from
+ * a genuine unchecked task. This subclass stores the tri-state
+ * (checked / unchecked / not-a-task) independent of the parent list's type, so
+ * export can tell plain items and unchecked tasks apart.
+ */
+export class CustomListItemNode extends ListItemNode {
+    /** @internal */
+    __taskChecked;
+    constructor(value, checked, key) {
+        super(value, checked, key);
+        this.__taskChecked = checked ?? null;
+    }
+    static getType() {
+        return 'listitem'; // Use same type to replace the default ListItemNode
+    }
+    static clone(node) {
+        const cloned = new CustomListItemNode(node.__value, node.__checked, node.__key);
+        cloned.__taskChecked = $isCustomListItemNode(node) ? node.__taskChecked : null;
+        return cloned;
+    }
+    static importJSON(serializedNode) {
+        const node = $createCustomListItemNode(serializedNode.checked);
+        // Only fall back to the legacy `checked` field when `taskChecked` is
+        // absent (older serialized documents predating this field) — an
+        // explicit `taskChecked: null` means "plain item" and must not be
+        // coerced into `checked`'s boolean via `??`, or a plain item in a
+        // mixed list would be rehydrated as an unchecked task.
+        node.__taskChecked = serializedNode.taskChecked !== undefined ? serializedNode.taskChecked : (serializedNode.checked ?? null);
+        node.setValue(serializedNode.value);
+        node.setFormat(serializedNode.format);
+        node.setIndent(serializedNode.indent);
+        node.setDirection(serializedNode.direction);
+        return node;
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            type: 'listitem',
+            taskChecked: this.__taskChecked,
+        };
+    }
+    // Lexical's own CheckListPlugin/registerList() transforms call setChecked()
+    // directly during live editing, bypassing the mapper entirely. Syncing
+    // __taskChecked here means toggling a checkbox on a previously-plain item
+    // in a mixed list correctly promotes it to a real task.
+    setChecked(checked) {
+        const writable = super.setChecked(checked);
+        writable.__taskChecked = checked ?? null;
+        return writable;
+    }
+    setTaskChecked(taskChecked) {
+        const writable = this.getWritable();
+        writable.__taskChecked = taskChecked;
+    }
+    getTaskChecked() {
+        return this.__taskChecked;
+    }
+    createDOM(config) {
+        const dom = super.createDOM(config);
+        this.updateOrderedTaskDOM(dom);
+        return dom;
+    }
+    updateDOM(prevNode, dom, config) {
+        const result = super.updateDOM(prevNode, dom, config);
+        this.updateOrderedTaskDOM(dom);
+        return result;
+    }
+    /**
+     * Applies (or clears) the ordered-task checkbox affordance. Only fires for
+     * a leaf item (mirrors stock's own `!$isListNode(getFirstChild())` guard —
+     * a list item whose only child is a nested list isn't itself a task) whose
+     * parent list is `'number'`-typed and whose own `__taskChecked` (this
+     * item's field, not the list's) is non-null — a plain item in a mixed
+     * ordered list is left with no checkbox, same as a plain item in a mixed
+     * unordered list today.
+     */
+    updateOrderedTaskDOM(dom) {
+        const parent = this.getParent();
+        const isOrderedTask = $isListNode(parent) && parent.getListType() === 'number' && !$isListNode(this.getFirstChild()) && this.__taskChecked !== null;
+        dom.classList.remove(ORDERED_TASK_CHECKED_CLASS, ORDERED_TASK_UNCHECKED_CLASS);
+        if (!isOrderedTask) {
+            // Stock updateListItemChecked already clears these for any non-'check'
+            // parent list, but that runs before this item's own listType/parent may
+            // have changed shape (e.g. an ordered task item demoted to plain) — so
+            // clear explicitly here too rather than relying on ordering.
+            dom.removeAttribute('role');
+            dom.removeAttribute('tabIndex');
+            dom.removeAttribute('aria-checked');
+            return;
+        }
+        dom.classList.add(this.__taskChecked ? ORDERED_TASK_CHECKED_CLASS : ORDERED_TASK_UNCHECKED_CLASS);
+        dom.setAttribute('role', 'checkbox');
+        dom.setAttribute('tabIndex', '-1');
+        dom.setAttribute('aria-checked', this.__taskChecked ? 'true' : 'false');
+    }
+}
+export function $createCustomListItemNode(checked) {
+    return new CustomListItemNode(undefined, checked);
+}
+export function $isCustomListItemNode(node) {
+    return node instanceof CustomListItemNode;
+}

package/dist/app/editor/nodes/CustomListNode.d.ts

@@ -0,0 +1,27 @@
+import { ListNode, SerializedListNode, ListType } from '@lexical/list';
+import { LexicalNode } from 'lexical';
+export type SerializedCustomListNode = SerializedListNode & {
+    spread?: boolean;
+};
+/**
+ * CustomListNode - Extends Lexical's ListNode to carry the CommonMark "spread"
+ * (loose vs. tight) state through the markdown round trip.
+ *
+ * Stock ListNode has no field for this — the loose/tight distinction (blank
+ * lines between list items) exists on the parsed mdast List node but is
+ * otherwise discarded once imported into Lexical. This subclass preserves it
+ * so it can be written back out on export.
+ */
+export declare class CustomListNode extends ListNode {
+    /** @internal */
+    __spread: boolean;
+    constructor(listType: ListType, start: number, key?: string);
+    static getType(): string;
+    static clone(node: CustomListNode): CustomListNode;
+    static importJSON(serializedNode: SerializedCustomListNode): CustomListNode;
+    exportJSON(): SerializedCustomListNode;
+    setSpread(spread: boolean): void;
+    getSpread(): boolean;
+}
+export declare function $createCustomListNode(listType: ListType, start?: number): CustomListNode;
+export declare function $isCustomListNode(node: LexicalNode | null | undefined): node is CustomListNode;

package/dist/app/editor/nodes/CustomListNode.js

@@ -0,0 +1,54 @@
+import { ListNode } from '@lexical/list';
+/**
+ * CustomListNode - Extends Lexical's ListNode to carry the CommonMark "spread"
+ * (loose vs. tight) state through the markdown round trip.
+ *
+ * Stock ListNode has no field for this — the loose/tight distinction (blank
+ * lines between list items) exists on the parsed mdast List node but is
+ * otherwise discarded once imported into Lexical. This subclass preserves it
+ * so it can be written back out on export.
+ */
+export class CustomListNode extends ListNode {
+    /** @internal */
+    __spread;
+    constructor(listType, start, key) {
+        super(listType, start, key);
+        this.__spread = false;
+    }
+    static getType() {
+        return 'list'; // Use same type to replace the default ListNode
+    }
+    static clone(node) {
+        const cloned = new CustomListNode(node.__listType, node.__start, node.__key);
+        cloned.__spread = $isCustomListNode(node) ? node.__spread : false;
+        return cloned;
+    }
+    static importJSON(serializedNode) {
+        const node = $createCustomListNode(serializedNode.listType, serializedNode.start);
+        node.__spread = serializedNode.spread ?? false;
+        node.setFormat(serializedNode.format);
+        node.setIndent(serializedNode.indent);
+        node.setDirection(serializedNode.direction);
+        return node;
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            type: 'list',
+            spread: this.__spread,
+        };
+    }
+    setSpread(spread) {
+        const writable = this.getWritable();
+        writable.__spread = spread;
+    }
+    getSpread() {
+        return this.__spread;
+    }
+}
+export function $createCustomListNode(listType, start = 1) {
+    return new CustomListNode(listType, start);
+}
+export function $isCustomListNode(node) {
+    return node instanceof CustomListNode;
+}

package/dist/app/editor/nodes/DefinitionListNode.d.ts

@@ -0,0 +1,44 @@
+import { DOMConversionMap, DOMExportOutput, EditorConfig, ElementNode, LexicalNode, SerializedElementNode } from 'lexical';
+export type SerializedDefinitionListNode = SerializedElementNode;
+export declare class DefinitionListNode extends ElementNode {
+    static getType(): string;
+    static clone(node: DefinitionListNode): DefinitionListNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    static importJSON(serializedNode: SerializedDefinitionListNode): DefinitionListNode;
+    exportJSON(): SerializedDefinitionListNode;
+    isShadowRoot(): boolean;
+    canBeEmpty(): boolean;
+}
+export declare function $createDefinitionListNode(): DefinitionListNode;
+export declare function $isDefinitionListNode(node: LexicalNode | null | undefined): node is DefinitionListNode;
+export type SerializedDefinitionTermNode = SerializedElementNode;
+export declare class DefinitionTermNode extends ElementNode {
+    static getType(): string;
+    static clone(node: DefinitionTermNode): DefinitionTermNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    static importJSON(serializedNode: SerializedDefinitionTermNode): DefinitionTermNode;
+    exportJSON(): SerializedDefinitionTermNode;
+}
+export declare function $createDefinitionTermNode(): DefinitionTermNode;
+export declare function $isDefinitionTermNode(node: LexicalNode | null | undefined): node is DefinitionTermNode;
+export type SerializedDefinitionDescriptionNode = SerializedElementNode;
+export declare class DefinitionDescriptionNode extends ElementNode {
+    static getType(): string;
+    static clone(node: DefinitionDescriptionNode): DefinitionDescriptionNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(): DOMExportOutput;
+    static importJSON(serializedNode: SerializedDefinitionDescriptionNode): DefinitionDescriptionNode;
+    exportJSON(): SerializedDefinitionDescriptionNode;
+    isShadowRoot(): boolean;
+    canBeEmpty(): boolean;
+}
+export declare function $createDefinitionDescriptionNode(): DefinitionDescriptionNode;
+export declare function $isDefinitionDescriptionNode(node: LexicalNode | null | undefined): node is DefinitionDescriptionNode;

package/dist/app/editor/nodes/DefinitionListNode.js

@@ -0,0 +1,151 @@
+import { ElementNode, } from 'lexical';
+export class DefinitionListNode extends ElementNode {
+    static getType() {
+        return 'definition-list';
+    }
+    static clone(node) {
+        return new DefinitionListNode(node.__key);
+    }
+    createDOM(config) {
+        void config;
+        return document.createElement('dl');
+    }
+    updateDOM() {
+        return false;
+    }
+    static importDOM() {
+        return {
+            dl: () => ({
+                conversion: convertDefinitionListElement,
+                priority: 1,
+            }),
+        };
+    }
+    exportDOM() {
+        return { element: document.createElement('dl') };
+    }
+    static importJSON(serializedNode) {
+        void serializedNode;
+        return $createDefinitionListNode();
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            type: 'definition-list',
+            version: 1,
+        };
+    }
+    isShadowRoot() {
+        return true;
+    }
+    canBeEmpty() {
+        return false;
+    }
+}
+function convertDefinitionListElement() {
+    return { node: $createDefinitionListNode() };
+}
+export function $createDefinitionListNode() {
+    return new DefinitionListNode();
+}
+export function $isDefinitionListNode(node) {
+    return node instanceof DefinitionListNode;
+}
+export class DefinitionTermNode extends ElementNode {
+    static getType() {
+        return 'definition-term';
+    }
+    static clone(node) {
+        return new DefinitionTermNode(node.__key);
+    }
+    createDOM(config) {
+        void config;
+        return document.createElement('dt');
+    }
+    updateDOM() {
+        return false;
+    }
+    static importDOM() {
+        return {
+            dt: () => ({
+                conversion: convertDefinitionTermElement,
+                priority: 1,
+            }),
+        };
+    }
+    exportDOM() {
+        return { element: document.createElement('dt') };
+    }
+    static importJSON(serializedNode) {
+        void serializedNode;
+        return $createDefinitionTermNode();
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            type: 'definition-term',
+            version: 1,
+        };
+    }
+}
+function convertDefinitionTermElement() {
+    return { node: $createDefinitionTermNode() };
+}
+export function $createDefinitionTermNode() {
+    return new DefinitionTermNode();
+}
+export function $isDefinitionTermNode(node) {
+    return node instanceof DefinitionTermNode;
+}
+export class DefinitionDescriptionNode extends ElementNode {
+    static getType() {
+        return 'definition-description';
+    }
+    static clone(node) {
+        return new DefinitionDescriptionNode(node.__key);
+    }
+    createDOM(config) {
+        void config;
+        return document.createElement('dd');
+    }
+    updateDOM() {
+        return false;
+    }
+    static importDOM() {
+        return {
+            dd: () => ({
+                conversion: convertDefinitionDescriptionElement,
+                priority: 1,
+            }),
+        };
+    }
+    exportDOM() {
+        return { element: document.createElement('dd') };
+    }
+    static importJSON(serializedNode) {
+        void serializedNode;
+        return $createDefinitionDescriptionNode();
+    }
+    exportJSON() {
+        return {
+            ...super.exportJSON(),
+            type: 'definition-description',
+            version: 1,
+        };
+    }
+    isShadowRoot() {
+        return true;
+    }
+    canBeEmpty() {
+        return false;
+    }
+}
+function convertDefinitionDescriptionElement() {
+    return { node: $createDefinitionDescriptionNode() };
+}
+export function $createDefinitionDescriptionNode() {
+    return new DefinitionDescriptionNode();
+}
+export function $isDefinitionDescriptionNode(node) {
+    return node instanceof DefinitionDescriptionNode;
+}