@liminis/editor 0.1.0-rc.1

package/dist/app/editor/AnnotationPlugin.js

@@ -0,0 +1,135 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { COMMAND_PRIORITY_CRITICAL } from 'lexical';
+import { readAnchorFields, removeMarksForAnnotation, removeMarksForAnnotations, wrapNativeRangeInMark, } from './annotation-marks.js';
+import { OPEN_ANNOTATION_COMPOSER_COMMAND } from './annotationCommands.js';
+/**
+ * Turns a user selection into a captured anchor for a configured kind.
+ *
+ * Deliberately headless: it renders no composer of its own. Whether a comment
+ * gets a textarea or a correction gets a panel is host UX, so this plugin's
+ * whole job is to listen for the create command, run the shared capture
+ * primitive, and hand the anchor out. Both kinds take the same path here —
+ * only `retainMarkOnCreate` differs, which is what SC-001 rests on.
+ *
+ * Not gated on `editable`: annotating is decoupled from editing, and a
+ * read-only document is a legitimate place to comment.
+ */
+export function AnnotationPlugin({ kinds, onCreateAnnotation, logger, wikiLinkPromotion }) {
+    const [editor] = useLexicalComposerContext();
+    const mintId = useCallback(() => {
+        // crypto.randomUUID is unavailable in some non-secure contexts (an
+        // unpackaged Electron or file:// window); the id only has to be unique
+        // within this document's live marks, so a fallback is fine.
+        if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+            return crypto.randomUUID();
+        }
+        // A timestamp alone is not enough: `performance.now()` is coarsened for
+        // fingerprinting protection, so two creates in quick succession can land on
+        // the same value. Ids gate mark placement and removal via `hasID`/`deleteID`,
+        // so a collision would merge two annotations onto one live mark and let
+        // removing either delete the other's anchor. The random suffix makes that
+        // effectively impossible without needing a real UUID source.
+        const stamp = Math.floor(performance.now() * 1000).toString(36);
+        const random = Math.random().toString(36).slice(2, 10);
+        return `anno-${stamp}-${random}-${globalThis.isSecureContext ? 's' : 'u'}`;
+    }, []);
+    // Marks placed by a create whose anchor read hasn't run yet. The wrap is
+    // synchronous but the read-back is deferred, so between the two the mark
+    // exists in the document while its id exists nowhere else — the host has not
+    // been told, and `AnnotationMarkerPlugin` walks only host-supplied
+    // annotations. Dropping one there would strand a bare `<mark>` the user
+    // cannot dismiss until the document is reparsed (review finding,
+    // @handarbeit-pruefer). The teardown effect below retracts whatever is left.
+    //
+    // Held in a ref, not an effect-local, so it survives a re-run of the
+    // command-registration effect: a create in flight belongs to the plugin, not
+    // to the effect run that happened to register the handler.
+    const pendingIdsRef = useRef(new Set());
+    // Cancellation is a property of the plugin's *lifetime*, not of one effect
+    // run. Scoping it per-run would make correctness depend on React flushing the
+    // cleanup after the pending microtask: that holds on the default async render
+    // path (verified by test), but a synchronous re-render — `flushSync`, or a
+    // discrete input forcing one — runs the cleanup first, and a create in flight
+    // would be silently dropped with the host never told (review finding,
+    // CodeRabbit). Tying the flag to unmount makes the ordering irrelevant.
+    const unmountedRef = useRef(false);
+    useEffect(() => {
+        unmountedRef.current = false;
+        const pendingIds = pendingIdsRef.current;
+        return () => {
+            // Runs only on unmount (`editor` is stable for the composer's lifetime),
+            // which is exactly the case where a deferred read must not proceed: it
+            // would touch a torn-down editor and call the host back with a stale rect
+            // and a stale closure.
+            unmountedRef.current = true;
+            // Retract regardless of the kind's `retainMarkOnCreate`: a retained mark
+            // is only safe to leave behind because the host owns it from the moment
+            // `onCreateAnnotation` fires, and that never happened for these.
+            //
+            // Safe to touch the editor here: this cleanup runs as ordinary React
+            // work, not inside the Lexical update the command handler ran in, so the
+            // queued wrap has already been applied by the time we get here.
+            if (pendingIds.size > 0) {
+                removeMarksForAnnotations(editor, [...pendingIds]);
+                pendingIds.clear();
+            }
+        };
+    }, [editor]);
+    useEffect(() => {
+        const pendingIds = pendingIdsRef.current;
+        const unregister = editor.registerCommand(OPEN_ANNOTATION_COMPOSER_COMMAND, ({ kind }) => {
+            const config = kinds[kind];
+            if (!config) {
+                // An unconfigured kind is a host wiring mistake, not a crash (edge
+                // case in the spec): warn through the injected logger and decline.
+                logger?.warn(`[annotations] ignoring create for unconfigured kind "${kind}"`);
+                return false;
+            }
+            if (!config.createAffordance) {
+                logger?.warn(`[annotations] kind "${kind}" is host-injected only; no create affordance`);
+                return false;
+            }
+            // Read the on-screen rect while the selection is still live and before
+            // wrapping mutates the DOM around it.
+            const nativeSelection = window.getSelection();
+            if (!nativeSelection || nativeSelection.rangeCount === 0 || nativeSelection.isCollapsed)
+                return false;
+            const nativeRange = nativeSelection.getRangeAt(0);
+            const rect = nativeRange.getBoundingClientRect();
+            const id = mintId();
+            const retainMark = config.retainMarkOnCreate ?? false;
+            // Wrap now, while the native range still points at live DOM — but read
+            // the anchor back on a microtask rather than inline.
+            //
+            // A command handler runs *inside* an active Lexical update, so the
+            // update `wrapNativeRangeInMark` performs is nested: Lexical queues it
+            // and applies it when the outer update completes, which means its
+            // result is not observable synchronously here. Reading the anchor
+            // inline would read the pre-mark state and always come back null. The
+            // microtask runs after the outer update has flushed, so the mark is
+            // really in the tree by then.
+            wrapNativeRangeInMark(editor, nativeRange, id);
+            // The mark is now in the tree but its id has not been reported to the
+            // host yet, so nothing outside this plugin can clean it up. Tracked
+            // until the microtask hands it over (or the cleanup retracts it).
+            pendingIds.add(id);
+            queueMicrotask(() => {
+                if (unmountedRef.current)
+                    return;
+                pendingIds.delete(id);
+                const anchor = readAnchorFields(editor, id, { wikiLinkPromotion });
+                // Comments keep the mark (it is their live anchor and the composer's
+                // highlight); corrections discard it so nothing ever paints.
+                if (!retainMark)
+                    removeMarksForAnnotation(editor, id);
+                onCreateAnnotation({ kind, id, anchor, rect });
+            });
+            return true;
+        }, COMMAND_PRIORITY_CRITICAL);
+        // Only the registration is scoped to this effect run; cancellation and the
+        // pending-mark retraction live in the teardown effect above.
+        return unregister;
+    }, [editor, kinds, onCreateAnnotation, logger, mintId, wikiLinkPromotion]);
+    return null;
+}

package/dist/app/editor/AnnotationSurface.d.ts

@@ -0,0 +1,34 @@
+import type { MutableRefObject } from 'react';
+import { type Annotation, type AnnotationEditorHandle, type AnnotationKindConfigs } from '../../annotations/types.js';
+import type { OffsetSpan } from '../mapper/mdastToLexical.js';
+import type { WikiLinkPromotionMode } from '../mapper/lexicalToMdast.js';
+import { type AnnotationCreateEvent } from './AnnotationPlugin.js';
+export interface AnnotationSurfaceProps {
+    kinds: AnnotationKindConfigs;
+    annotations: Annotation[];
+    activeAnnotationId: string | null;
+    scrollToAnnotation?: {
+        id: string;
+        nonce: number;
+    } | null;
+    onCreateAnnotation?: (event: AnnotationCreateEvent) => void;
+    onActivateAnnotation?: (id: string) => void;
+    editorHandleRef?: MutableRefObject<AnnotationEditorHandle | null>;
+    offsetSpansRef: MutableRefObject<OffsetSpan[]>;
+    markdownTextRef: MutableRefObject<string>;
+    offsetsVersion: number;
+    logger?: {
+        warn: (message: string, ...args: unknown[]) => void;
+    };
+    /** Forwarded to the anchor-capture export pass — see `Editor`'s own prop of the same name. */
+    wikiLinkPromotion?: WikiLinkPromotionMode;
+}
+/**
+ * The entire annotation feature surface, behind one lazily-imported boundary.
+ *
+ * Nothing here is reachable from `Editor.tsx` by static import: the editor
+ * loads this module only when a host actually configures annotation kinds
+ * (FR-004/SC-004). That is why the create plugin, marker plugin, placement and
+ * editor handle are assembled here rather than mounted individually.
+ */
+export default function AnnotationSurface({ kinds, annotations, activeAnnotationId, scrollToAnnotation, onCreateAnnotation, onActivateAnnotation, editorHandleRef, offsetSpansRef, markdownTextRef, offsetsVersion, logger, wikiLinkPromotion, }: AnnotationSurfaceProps): import("react").JSX.Element;

package/dist/app/editor/AnnotationSurface.js

@@ -0,0 +1,115 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { deriveMarkerTargets, } from '../../annotations/types.js';
+import { collectLiveAnchorSnapshots, placeMarksForAnchors, removeMarksForAnnotation, removeMarksForAnnotations, } from './annotation-marks.js';
+import { AnnotationPlugin } from './AnnotationPlugin.js';
+import { AnnotationMarkerPlugin } from './AnnotationMarkerPlugin.js';
+import { registerMarkOverlapResolver } from './mark-overlap-resolver.js';
+/**
+ * Places a live `MarkNode` for every marker target — the set `deriveMarkerTargets`
+ * already narrowed by each kind's live-mark policy.
+ *
+ * This is also where the spec's "document edited mid-resolution" edge case is
+ * handled, and it needs no dedicated guard: `placeMarkForAnchor` re-verifies
+ * the anchor's target text against the *current* offset spans and returns
+ * false rather than placing on unrelated text. A stale anchor therefore
+ * no-ops, and the next parse bumps `offsetsVersion`, which re-runs this pass
+ * against fresh spans. Placement is never applied on the strength of an
+ * out-of-date resolution.
+ */
+function AnnotationMarkPlacementPlugin({ offsetSpansRef, markdownTextRef, targets, offsetsVersion, }) {
+    const [editor] = useLexicalComposerContext();
+    // Ids this plugin has placed a mark for. Retracting a mark is keyed off this
+    // rather than off "every mark in the document" on purpose: a comment created
+    // through `AnnotationPlugin` with `retainMarkOnCreate` keeps its mark while
+    // the host is still deciding whether to persist it, and that mark is not
+    // ours to remove.
+    const placedRef = useRef(new Set());
+    useEffect(() => {
+        // No outcome filter here: `deriveMarkerTargets` has already applied each
+        // kind's `livemarkPolicy` (defaulting to `shouldPlaceLiveMark` over the
+        // outcome). Re-testing the outcome would let the policy only ever subtract
+        // — a host that deliberately opts a `flagged` annotation into a live mark
+        // would get a marker target the marker plugin then decorates but nothing
+        // ever places, which is the one inconsistency the single policy exists to
+        // prevent.
+        const eligible = new Set(targets.map((target) => target.annotationId));
+        // Retract first: an annotation the host removed, or whose outcome or
+        // live-mark policy now declines it, must lose the mark it was given.
+        // Without this the MarkNode survives every later pass — still in the
+        // document, still rendering as a bare <mark>, and no longer decorated by
+        // the marker plugin (which only walks current targets), so it becomes an
+        // undismissable highlight with nothing behind it.
+        // Batched for the same reason placement is: a host dropping a set of live
+        // annotations at once would otherwise pay one synchronous Lexical
+        // reconciliation per id (review finding, @handarbeit-pruefer).
+        const retract = [...placedRef.current].filter((id) => !eligible.has(id));
+        if (retract.length > 0) {
+            removeMarksForAnnotations(editor, retract);
+            for (const id of retract)
+                placedRef.current.delete(id);
+        }
+        // One batched update for the whole set, not one per annotation: an
+        // `offsetsVersion` bump re-runs this pass over every target, and a
+        // per-target `editor.update()` would force a synchronous Lexical
+        // reconciliation each time (review finding, @handarbeit-pruefer).
+        const placed = placeMarksForAnchors(editor, offsetSpansRef.current, markdownTextRef.current, targets.map((target) => ({ anchor: target.anchor, id: target.annotationId })));
+        for (const id of placed)
+            placedRef.current.add(id);
+        // The two refs are read fresh on every run; offsetsVersion (bumped whenever
+        // a (re)parse produces new spans) is what should actually re-trigger this.
+    }, [editor, targets, offsetsVersion, offsetSpansRef, markdownTextRef]);
+    return null;
+}
+/**
+ * Keeps overlapping annotations on *shared* MarkNodes rather than nested ones
+ * — see `mark-overlap-resolver.ts`. Mounted here because it is only meaningful
+ * once annotation kinds are configured, and this whole module is lazily loaded
+ * on exactly that condition.
+ */
+function MarkOverlapResolverPlugin() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => registerMarkOverlapResolver(editor), [editor]);
+    return null;
+}
+/**
+ * Publishes the live-mark mechanism to the host via an imperative ref — the
+ * host lives outside this LexicalComposer tree and has no other way to reach
+ * the editor instance.
+ */
+function AnnotationEditorHandlePlugin({ handleRef, wikiLinkPromotion, }) {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        handleRef.current = {
+            removeMarksForAnnotation: (id) => removeMarksForAnnotation(editor, id),
+            collectLiveAnchorSnapshots: (markdownText) => collectLiveAnchorSnapshots(editor, markdownText, { wikiLinkPromotion }),
+        };
+        return () => {
+            handleRef.current = null;
+        };
+    }, [editor, handleRef, wikiLinkPromotion]);
+    return null;
+}
+/**
+ * The entire annotation feature surface, behind one lazily-imported boundary.
+ *
+ * Nothing here is reachable from `Editor.tsx` by static import: the editor
+ * loads this module only when a host actually configures annotation kinds
+ * (FR-004/SC-004). That is why the create plugin, marker plugin, placement and
+ * editor handle are assembled here rather than mounted individually.
+ */
+export default function AnnotationSurface({ kinds, annotations, activeAnnotationId, scrollToAnnotation, onCreateAnnotation, onActivateAnnotation, editorHandleRef, offsetSpansRef, markdownTextRef, offsetsVersion, logger, wikiLinkPromotion, }) {
+    const targets = useMemo(() => deriveMarkerTargets(annotations, kinds), [annotations, kinds]);
+    // An annotation whose kind has no configuration is dropped by
+    // deriveMarkerTargets; surface that as a warning rather than silently
+    // ignoring the host's data.
+    useEffect(() => {
+        for (const annotation of annotations) {
+            if (!kinds[annotation.kind]) {
+                logger?.warn(`[annotations] annotation ${annotation.id} has unconfigured kind "${annotation.kind}"; ignoring`);
+            }
+        }
+    }, [annotations, kinds, logger]);
+    return (_jsxs(_Fragment, { children: [_jsx(MarkOverlapResolverPlugin, {}), onCreateAnnotation && (_jsx(AnnotationPlugin, { kinds: kinds, onCreateAnnotation: onCreateAnnotation, logger: logger, wikiLinkPromotion: wikiLinkPromotion })), _jsx(AnnotationMarkPlacementPlugin, { offsetSpansRef: offsetSpansRef, markdownTextRef: markdownTextRef, targets: targets, offsetsVersion: offsetsVersion }), _jsx(AnnotationMarkerPlugin, { targets: targets, kinds: kinds, activeAnnotationId: activeAnnotationId, onActivateAnnotation: onActivateAnnotation ?? (() => undefined), scrollToAnnotation: scrollToAnnotation }), editorHandleRef && (_jsx(AnnotationEditorHandlePlugin, { handleRef: editorHandleRef, wikiLinkPromotion: wikiLinkPromotion }))] }));
+}

package/dist/app/editor/AssetContext.d.ts

@@ -0,0 +1,20 @@
+import type { ImagePathResolution } from '../../types.js';
+interface AssetContextValue {
+    assetBaseUri: string | undefined;
+    documentDirUri: string | undefined;
+    imagePathResolution: ImagePathResolution;
+    resolveAssetPath: (path: string) => string;
+    /** Resolve a workspace-relative file path to a data URL for display */
+    resolveLocalAsset?: (relativePath: string) => Promise<string | null>;
+}
+export declare const AssetContext: import("react").Context<AssetContextValue>;
+export declare function useAssetContext(): AssetContextValue;
+export interface AssetContextOptions {
+    assetBaseUri?: string;
+    documentDirUri?: string;
+    imagePathResolution?: ImagePathResolution;
+    /** Resolve a workspace-relative file path to a data URL for display */
+    resolveLocalAsset?: (relativePath: string) => Promise<string | null>;
+}
+export declare function createAssetContextValue(options: AssetContextOptions): AssetContextValue;
+export {};

package/dist/app/editor/AssetContext.js

@@ -0,0 +1,81 @@
+import { createContext, useContext } from 'react';
+export const AssetContext = createContext({
+    assetBaseUri: undefined,
+    documentDirUri: undefined,
+    imagePathResolution: 'document',
+    resolveAssetPath: (path) => path,
+});
+export function useAssetContext() {
+    return useContext(AssetContext);
+}
+/**
+ * Normalize a relative path by resolving . and .. segments
+ * Examples:
+ *   "./images/photo.png" -> "images/photo.png"
+ *   "../assets/image.png" -> "../assets/image.png" (kept as-is, resolved by browser)
+ *   "assets/../images/photo.png" -> "images/photo.png"
+ */
+function normalizePath(path) {
+    // Remove leading ./ (current directory reference)
+    const normalized = path.replace(/^\.\//, '');
+    // Split into segments and resolve . and ..
+    const segments = normalized.split('/');
+    const result = [];
+    for (const segment of segments) {
+        if (segment === '.' || segment === '') {
+            // Skip current directory references and empty segments
+            continue;
+        }
+        else if (segment === '..') {
+            // Go up one directory if possible
+            if (result.length > 0 && result[result.length - 1] !== '..') {
+                result.pop();
+            }
+            else {
+                // Keep leading .. segments (they go above the base)
+                result.push(segment);
+            }
+        }
+        else {
+            result.push(segment);
+        }
+    }
+    return result.join('/');
+}
+export function createAssetContextValue(options) {
+    const { assetBaseUri, documentDirUri, imagePathResolution = 'document', resolveLocalAsset, } = options;
+    return {
+        assetBaseUri,
+        documentDirUri,
+        imagePathResolution,
+        resolveLocalAsset,
+        resolveAssetPath: (path) => {
+            // If it's already an absolute URL (http, https, vscode-webview-resource, data), return as-is
+            if (path.startsWith('http://') ||
+                path.startsWith('https://') ||
+                path.startsWith('vscode-webview-resource:') ||
+                path.startsWith('data:')) {
+                return path;
+            }
+            // Paths starting with / are absolute from workspace root, regardless of
+            // imagePathResolution setting. Strip the leading / so the path is
+            // workspace-relative (readBinaryFile joins with workspace root).
+            // Check BEFORE normalizePath which strips the leading /.
+            if (path.startsWith('/')) {
+                return normalizePath(path.slice(1));
+            }
+            // Normalize the path to handle ./ and ../ correctly
+            const normalizedPath = normalizePath(path);
+            // Choose the base URI based on settings
+            const baseUri = imagePathResolution === 'document' ? documentDirUri : assetBaseUri;
+            // If we have a base URI, resolve relative paths and normalize the
+            // combined result so that "../" segments are resolved (e.g.
+            // "notes/sub/" + "../assets/img.svg" → "notes/assets/img.svg")
+            if (baseUri) {
+                return normalizePath(baseUri + normalizedPath);
+            }
+            // Fallback to original path
+            return path;
+        },
+    };
+}

package/dist/app/editor/BlockClickPlugin.d.ts

@@ -0,0 +1,8 @@
+/**
+ * BlockClickPlugin - Enables clicking to the right of blocks to place cursor
+ *
+ * When clicking in empty space to the right of a block's content,
+ * this selects that block. For non-editable blocks (images, HRs),
+ * pressing Enter will then create a new paragraph below.
+ */
+export declare function BlockClickPlugin(): null;

package/dist/app/editor/BlockClickPlugin.js

@@ -0,0 +1,126 @@
+import { useEffect } from 'react';
+import { useLexicalComposerContext } from '@lexical/react/LexicalComposerContext';
+import { $getNodeByKey, $isDecoratorNode, $createParagraphNode, $getRoot, $getNearestNodeFromDOMNode, COMMAND_PRIORITY_LOW, KEY_ENTER_COMMAND, } from 'lexical';
+/**
+ * BlockClickPlugin - Enables clicking to the right of blocks to place cursor
+ *
+ * When clicking in empty space to the right of a block's content,
+ * this selects that block. For non-editable blocks (images, HRs),
+ * pressing Enter will then create a new paragraph below.
+ */
+export function BlockClickPlugin() {
+    const [editor] = useLexicalComposerContext();
+    useEffect(() => {
+        const rootElement = editor.getRootElement();
+        if (!rootElement)
+            return;
+        const handleClick = (event) => {
+            // Only handle left clicks
+            if (event.button !== 0)
+                return;
+            const clickX = event.clientX;
+            const clickY = event.clientY;
+            // Get the content editable bounds
+            const rootRect = rootElement.getBoundingClientRect();
+            // Must be within editor bounds
+            if (clickY < rootRect.top || clickY > rootRect.bottom)
+                return;
+            if (clickX < rootRect.left || clickX > rootRect.right)
+                return;
+            // Find which block element the click Y coordinate corresponds to
+            const targetBlock = findBlockAtY(rootElement, clickY);
+            if (!targetBlock) {
+                return;
+            }
+            const blockRect = targetBlock.getBoundingClientRect();
+            // Check if click is to the RIGHT of the block's actual content
+            // (not inside the block itself)
+            if (clickX <= blockRect.right) {
+                return;
+            }
+            // We clicked in the empty space to the right of the block
+            event.preventDefault();
+            event.stopPropagation();
+            // Use Lexical's method to find the node from DOM element
+            editor.update(() => {
+                const node = $getNearestNodeFromDOMNode(targetBlock);
+                if (!node) {
+                    return;
+                }
+                // Get the top-level block (direct child of root)
+                let topLevelNode = node;
+                const root = $getRoot();
+                while (topLevelNode && topLevelNode.getParent() !== root) {
+                    topLevelNode = topLevelNode.getParent();
+                }
+                if (topLevelNode) {
+                    selectAfterNode(topLevelNode);
+                }
+            });
+            // Focus the editor
+            editor.focus();
+        };
+        // Use mousedown instead of click to capture before other handlers
+        rootElement.addEventListener('mousedown', handleClick);
+        return () => {
+            rootElement.removeEventListener('mousedown', handleClick);
+        };
+    }, [editor]);
+    // Handle Enter key when a decorator node is selected to insert paragraph after
+    useEffect(() => {
+        return editor.registerCommand(KEY_ENTER_COMMAND, (event) => {
+            // Check if we have an element selection on a decorator node
+            return editor.getEditorState().read(() => {
+                const sel = editor.getEditorState()._selection;
+                if (sel?.getNodes().length !== 1)
+                    return false;
+                const node = sel.getNodes()[0];
+                if (!$isDecoratorNode(node))
+                    return false;
+                // Insert a new paragraph after the decorator node
+                editor.update(() => {
+                    const decoratorNode = $getNodeByKey(node.getKey());
+                    if (!decoratorNode)
+                        return;
+                    const paragraph = $createParagraphNode();
+                    decoratorNode.insertAfter(paragraph);
+                    paragraph.select();
+                });
+                event?.preventDefault();
+                return true;
+            });
+        }, COMMAND_PRIORITY_LOW);
+    }, [editor]);
+    return null;
+}
+/**
+ * Find the top-level block element at a given Y coordinate
+ */
+function findBlockAtY(rootElement, y) {
+    const children = Array.from(rootElement.children);
+    for (const child of children) {
+        const rect = child.getBoundingClientRect();
+        if (y >= rect.top && y <= rect.bottom) {
+            return child;
+        }
+    }
+    // If click is below all blocks, return the last block
+    if (children.length > 0) {
+        const lastChild = children[children.length - 1];
+        const lastRect = lastChild.getBoundingClientRect();
+        if (y > lastRect.bottom) {
+            return lastChild;
+        }
+    }
+    return null;
+}
+/**
+ * Select after a node - inserts a new paragraph after the block and selects it
+ */
+function selectAfterNode(node) {
+    // For all block-level nodes, insert a new paragraph after and select it
+    // This gives the user a clear place to type
+    const paragraph = $createParagraphNode();
+    node.insertAfter(paragraph);
+    paragraph.select();
+}

package/dist/app/editor/CodeBlockPlugin.d.ts

@@ -0,0 +1 @@
+export declare function CodeBlockPlugin(): import("react").JSX.Element;