@blankdotpage/cake 0.1.7 → 0.1.10

package/dist/cake/engine/selection/selection-layout.d.ts

@@ -52,3 +52,4 @@ export declare function resolveOffsetToLine(lines: LineInfo[], offset: number):
     lineIndex: number;
     offsetInLine: number;
 };
+//# sourceMappingURL=selection-layout.d.ts.map

package/dist/cake/engine/selection/selection-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-layout.d.ts","sourceRoot":"","sources":["../../../../src/cake/engine/selection/selection-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAS,GAAG,EAAU,MAAM,kBAAkB,CAAC;AAG3D,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,UAAU,CAAC;IACpB,IAAI,EAAE,SAAS,EAAE,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,UAAU,CAAC;IACtB,KAAK,EAAE,UAAU,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,UAAU,CAAC;IACpB,IAAI,EAAE,SAAS,EAAE,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,UAAU,CAAC;IACtB,WAAW,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,eAAe,CAAC;CAC/D,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,EAAE,EACjB,QAAQ,EAAE,cAAc,GACvB,WAAW,CAqCb;AAOD,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,GAAG,QAAQ,EAAE,CAchD;AA6BD,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,EAAE,CAW1D;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,EAAE,MAAM,GACb;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAsB7C"}

package/dist/cake/engine/selection/selection-layout.js

@@ -0,0 +1,128 @@
+import { graphemeSegments } from "../../shared/segmenter";
+export function buildLayoutModel(lines, measurer) {
+    const layouts = [];
+    let top = measurer.container.top;
+    let lineStartOffset = 0;
+    lines.forEach((line) => {
+        const measurement = measurer.measureLine({
+            lineIndex: line.lineIndex,
+            lineText: line.text,
+            lineLength: line.cursorLength,
+            lineHasNewline: line.hasNewline,
+            top,
+        });
+        layouts.push({
+            lineIndex: line.lineIndex,
+            lineStartOffset,
+            lineLength: line.cursorLength,
+            lineHasNewline: line.hasNewline,
+            lineBox: measurement.lineBox,
+            rows: measurement.rows,
+        });
+        top = measurement.lineBox.top + measurement.lineBox.height;
+        lineStartOffset += line.cursorLength + (line.hasNewline ? 1 : 0);
+    });
+    const height = Math.max(measurer.container.height, top - measurer.container.top);
+    return {
+        container: {
+            ...measurer.container,
+            height,
+        },
+        lines: layouts,
+    };
+}
+export function getDocLines(doc) {
+    const flattenedLines = flattenBlocksWithAtomicInfo(doc.blocks);
+    return flattenedLines.map((line, index) => {
+        const cursorToCodeUnit = buildCursorToCodeUnit(line.text);
+        const cursorLength = Math.max(0, cursorToCodeUnit.length - 1);
+        return {
+            lineIndex: index,
+            text: line.text,
+            cursorLength,
+            hasNewline: index < flattenedLines.length - 1,
+            cursorToCodeUnit,
+            isAtomic: line.isAtomic,
+        };
+    });
+}
+function flattenBlocksWithAtomicInfo(blocks) {
+    const lines = [];
+    blocks.forEach((block) => {
+        lines.push(...flattenBlockWithAtomicInfo(block));
+    });
+    if (lines.length === 0) {
+        lines.push({ text: "", isAtomic: false });
+    }
+    return lines;
+}
+function flattenBlockWithAtomicInfo(block) {
+    if (block.type === "paragraph") {
+        return [
+            { text: block.content.map(flattenInline).join(""), isAtomic: false },
+        ];
+    }
+    if (block.type === "block-wrapper") {
+        return flattenBlocksWithAtomicInfo(block.blocks);
+    }
+    if (block.type === "block-atom") {
+        // Atomic blocks are represented as empty lines for layout purposes
+        return [{ text: "", isAtomic: true }];
+    }
+    return [];
+}
+export function getLineOffsets(lines) {
+    const offsets = [];
+    let current = 0;
+    lines.forEach((line) => {
+        offsets.push(current);
+        current += line.cursorLength;
+        if (line.hasNewline) {
+            current += 1;
+        }
+    });
+    return offsets;
+}
+export function resolveOffsetToLine(lines, offset) {
+    if (lines.length === 0) {
+        return { lineIndex: 0, offsetInLine: 0 };
+    }
+    const lineOffsets = getLineOffsets(lines);
+    const totalLength = lineOffsets[lineOffsets.length - 1] + lines[lines.length - 1].cursorLength;
+    const clamped = Math.max(0, Math.min(offset, totalLength));
+    for (let index = 0; index < lines.length; index += 1) {
+        const lineStart = lineOffsets[index];
+        const lineEnd = lineStart + lines[index].cursorLength;
+        if (clamped <= lineEnd || index === lines.length - 1) {
+            return { lineIndex: index, offsetInLine: clamped - lineStart };
+        }
+    }
+    const lastIndex = lines.length - 1;
+    return {
+        lineIndex: lastIndex,
+        offsetInLine: lines[lastIndex].cursorLength,
+    };
+}
+function flattenInline(inline) {
+    if (inline.type === "text") {
+        return inline.text;
+    }
+    if (inline.type === "inline-wrapper") {
+        return inline.children.map(flattenInline).join("");
+    }
+    if (inline.type === "inline-atom") {
+        return " ";
+    }
+    return "";
+}
+function buildCursorToCodeUnit(text) {
+    const segments = graphemeSegments(text);
+    const mapping = [0];
+    for (const segment of segments) {
+        mapping.push(segment.index + segment.segment.length);
+    }
+    if (mapping.length === 0) {
+        mapping.push(0);
+    }
+    return mapping;
+}

package/dist/cake/engine/selection/selection-navigation.d.ts

@@ -19,3 +19,4 @@ export declare function moveSelectionVertically(params: {
     } | null;
 }): VerticalNavigationResult | null;
 export {};
+//# sourceMappingURL=selection-navigation.d.ts.map

package/dist/cake/engine/selection/selection-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-navigation.d.ts","sourceRoot":"","sources":["../../../../src/cake/engine/selection/selection-navigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAa,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAG3E,KAAK,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AAEvC,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,EAAE,SAAS,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAsIF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC9C,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,MAAM,EAAE,WAAW,CAAC;IACpB,SAAS,EAAE,SAAS,CAAC;IACrB,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC;IACzB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,CAChB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,KACN;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,QAAQ,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CAC7E,GAAG,wBAAwB,GAAG,IAAI,CA+JlC"}

package/dist/cake/engine/selection/selection-navigation.js

@@ -0,0 +1,229 @@
+import { resolveOffsetToLine } from "./selection-layout";
+function rectRight(rect) {
+    return rect.left + rect.width;
+}
+function clampNumber(value, min, max) {
+    return Math.max(min, Math.min(value, max));
+}
+function resolveSelectionAffinity(selection) {
+    if (selection.start === selection.end) {
+        return selection.affinity ?? "backward";
+    }
+    return selection.affinity ?? "forward";
+}
+function resolveSelectionAnchorAndFocus(selection) {
+    if (selection.start === selection.end) {
+        return { anchor: selection.start, focus: selection.start };
+    }
+    const affinity = resolveSelectionAffinity(selection);
+    if (affinity === "backward") {
+        return { anchor: selection.end, focus: selection.start };
+    }
+    return { anchor: selection.start, focus: selection.end };
+}
+function findRowIndexForOffset(rows, offsetInLine, affinity) {
+    if (rows.length === 0) {
+        return 0;
+    }
+    for (let index = 0; index < rows.length; index += 1) {
+        const row = rows[index];
+        if (offsetInLine === row.startOffset) {
+            if (affinity === "backward" && index > 0) {
+                return index - 1;
+            }
+            return index;
+        }
+        if (offsetInLine === row.endOffset) {
+            if (affinity === "forward" && index + 1 < rows.length) {
+                return index + 1;
+            }
+            return index;
+        }
+        if (offsetInLine > row.startOffset && offsetInLine < row.endOffset) {
+            return index;
+        }
+    }
+    return rows.length - 1;
+}
+function asSingleRow(line) {
+    return {
+        startOffset: 0,
+        endOffset: line.lineLength,
+        rect: line.lineBox,
+    };
+}
+function rowOffsetToX(params) {
+    const { row, offsetInLine } = params;
+    const rowRight = rectRight(row.rect);
+    const clampedOffset = clampNumber(offsetInLine, row.startOffset, row.endOffset);
+    if (row.endOffset <= row.startOffset || row.rect.width <= 0) {
+        return row.rect.left;
+    }
+    if (clampedOffset === row.endOffset) {
+        return rowRight;
+    }
+    const rowLength = row.endOffset - row.startOffset;
+    const fraction = (clampedOffset - row.startOffset) / rowLength;
+    return row.rect.left + row.rect.width * fraction;
+}
+function rowXToOffset(params) {
+    const { row, x } = params;
+    const rowRight = rectRight(row.rect);
+    if (x <= row.rect.left) {
+        return { offsetInLine: row.startOffset, affinity: "forward" };
+    }
+    if (x >= rowRight) {
+        return { offsetInLine: row.endOffset, affinity: "backward" };
+    }
+    const rowLength = row.endOffset - row.startOffset;
+    if (rowLength <= 0 || row.rect.width <= 0) {
+        return { offsetInLine: row.startOffset, affinity: "forward" };
+    }
+    const fraction = (x - row.rect.left) / row.rect.width;
+    const raw = row.startOffset + fraction * rowLength;
+    const rounded = Math.round(raw);
+    const offsetInLine = clampNumber(rounded, row.startOffset, row.endOffset);
+    return { offsetInLine, affinity: "forward" };
+}
+function resolveTargetLineIndex(params) {
+    const delta = params.direction === "down" ? 1 : -1;
+    let index = params.fromLineIndex + delta;
+    while (index >= 0 && index < params.lines.length) {
+        if (!params.lines[index]?.isAtomic) {
+            return index;
+        }
+        index += delta;
+    }
+    return null;
+}
+export function moveSelectionVertically(params) {
+    const { lines, layout, direction } = params;
+    if (layout.lines.length === 0 || lines.length === 0) {
+        return null;
+    }
+    const affinity = resolveSelectionAffinity(params.selection);
+    const { anchor, focus } = resolveSelectionAnchorAndFocus(params.selection);
+    const focusResolved = resolveOffsetToLine(lines, focus);
+    const focusLineLayout = layout.lines[focusResolved.lineIndex];
+    if (!focusLineLayout) {
+        return null;
+    }
+    const focusRows = focusLineLayout.rows.length > 0
+        ? focusLineLayout.rows
+        : [asSingleRow(focusLineLayout)];
+    let focusRowIndex = params.focusRowIndex ??
+        findRowIndexForOffset(focusRows, focusResolved.offsetInLine, affinity);
+    focusRowIndex = clampNumber(focusRowIndex, 0, Math.max(0, focusRows.length - 1));
+    const focusRow = focusRows[focusRowIndex] ?? focusRows[focusRows.length - 1];
+    if (!focusRow) {
+        return null;
+    }
+    const goalX = params.goalX ??
+        rowOffsetToX({ row: focusRow, offsetInLine: focusResolved.offsetInLine });
+    let targetLineIndex = focusResolved.lineIndex;
+    let targetRowIndex = focusRowIndex;
+    if (direction === "up") {
+        if (focusRowIndex > 0) {
+            targetRowIndex = focusRowIndex - 1;
+        }
+        else {
+            const nextLineIndex = resolveTargetLineIndex({
+                lines,
+                fromLineIndex: focusResolved.lineIndex,
+                direction: "up",
+            });
+            if (nextLineIndex === null) {
+                return null;
+            }
+            targetLineIndex = nextLineIndex;
+            targetRowIndex = Number.POSITIVE_INFINITY;
+        }
+    }
+    else {
+        if (focusRowIndex + 1 < focusRows.length) {
+            targetRowIndex = focusRowIndex + 1;
+        }
+        else {
+            const nextLineIndex = resolveTargetLineIndex({
+                lines,
+                fromLineIndex: focusResolved.lineIndex,
+                direction: "down",
+            });
+            if (nextLineIndex === null) {
+                return null;
+            }
+            targetLineIndex = nextLineIndex;
+            targetRowIndex = 0;
+        }
+    }
+    const targetLineLayout = layout.lines[targetLineIndex];
+    if (!targetLineLayout) {
+        return null;
+    }
+    const targetRows = targetLineLayout.rows.length > 0
+        ? targetLineLayout.rows
+        : [asSingleRow(targetLineLayout)];
+    const resolvedTargetRowIndex = targetRowIndex === Number.POSITIVE_INFINITY
+        ? Math.max(0, targetRows.length - 1)
+        : clampNumber(targetRowIndex, 0, Math.max(0, targetRows.length - 1));
+    const targetRow = targetRows[resolvedTargetRowIndex] ?? targetRows[targetRows.length - 1];
+    if (!targetRow) {
+        return null;
+    }
+    const targetLineStart = targetLineLayout.lineStartOffset;
+    const targetLineEnd = targetLineStart + targetLineLayout.lineLength;
+    if (params.hitTestCursorAt) {
+        const midY = targetRow.rect.top + targetRow.rect.height / 2;
+        const rowLeft = targetRow.rect.left;
+        const rowRight = rectRight(targetRow.rect);
+        const hitX = rowRight - rowLeft > 1
+            ? clampNumber(goalX, rowLeft + 0.5, rowRight - 0.5)
+            : goalX;
+        let hit = params.hitTestCursorAt(hitX, midY);
+        // If we're in trailing whitespace, some caret APIs will return the end of
+        // the whole line (last visual row). Nudge left until we get a hit that
+        // actually lands on the requested visual row.
+        if (hit && hit.cursorOffset === focus) {
+            for (let attempt = 0; attempt < 80; attempt += 1) {
+                const nudgedX = hitX - (attempt + 1) * 1;
+                if (nudgedX <= rowLeft + 0.5) {
+                    break;
+                }
+                const next = params.hitTestCursorAt(nudgedX, midY);
+                const matchesRow = next?.caretTop === undefined ||
+                    Math.abs(next.caretTop - targetRow.rect.top) <= 2;
+                if (next && next.cursorOffset !== focus && matchesRow) {
+                    hit = next;
+                    break;
+                }
+            }
+        }
+        const matchesRow = hit?.caretTop === undefined ||
+            Math.abs(hit.caretTop - targetRow.rect.top) <= 2;
+        if (hit &&
+            matchesRow &&
+            hit.cursorOffset >= targetLineStart &&
+            hit.cursorOffset <= targetLineEnd) {
+            const normalizedAffinity = targetLineLayout.lineLength === 0 ? "forward" : hit.affinity;
+            const nextSelection = anchor === focus
+                ? {
+                    start: hit.cursorOffset,
+                    end: hit.cursorOffset,
+                    affinity: normalizedAffinity,
+                }
+                : { start: anchor, end: hit.cursorOffset, affinity: normalizedAffinity };
+            return { selection: nextSelection, goalX };
+        }
+    }
+    const rowHit = rowXToOffset({ row: targetRow, x: goalX });
+    const nextPos = targetLineStart + rowHit.offsetInLine;
+    const normalizedAffinity = targetLineLayout.lineLength === 0 ? "forward" : rowHit.affinity;
+    const nextSelection = anchor === focus
+        ? { start: nextPos, end: nextPos, affinity: normalizedAffinity }
+        : {
+            start: anchor,
+            end: nextPos,
+            affinity: normalizedAffinity,
+        };
+    return { selection: nextSelection, goalX };
+}

package/dist/cake/engine/selection/visible-text.d.ts

@@ -2,3 +2,4 @@ import { type LineInfo } from "./selection-layout";
 export declare function getVisibleText(lines: LineInfo[]): string;
 export declare function visibleOffsetToCursorOffset(lines: LineInfo[], visibleOffset: number): number | null;
 export declare function cursorOffsetToVisibleOffset(lines: LineInfo[], cursorOffset: number): number;
+//# sourceMappingURL=visible-text.d.ts.map

package/dist/cake/engine/selection/visible-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visible-text.d.ts","sourceRoot":"","sources":["../../../../src/cake/engine/selection/visible-text.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,QAAQ,EACd,MAAM,oBAAoB,CAAC;AAuB5B,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,CAKxD;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,QAAQ,EAAE,EACjB,aAAa,EAAE,MAAM,GACpB,MAAM,GAAG,IAAI,CA2Bf;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,QAAQ,EAAE,EACjB,YAAY,EAAE,MAAM,GACnB,MAAM,CAsBR"}

package/dist/cake/engine/selection/visible-text.js

@@ -0,0 +1,66 @@
+import { getLineOffsets, resolveOffsetToLine, } from "./selection-layout";
+function cursorOffsetFromCodeUnit(line, codeUnitOffset) {
+    const maxCodeUnit = line.cursorToCodeUnit[line.cursorToCodeUnit.length - 1] ?? 0;
+    const clamped = Math.max(0, Math.min(codeUnitOffset, maxCodeUnit));
+    for (let i = 0; i < line.cursorToCodeUnit.length; i += 1) {
+        if (line.cursorToCodeUnit[i] === clamped) {
+            return i;
+        }
+        if (line.cursorToCodeUnit[i] > clamped) {
+            return Math.max(0, i - 1);
+        }
+    }
+    return line.cursorLength;
+}
+export function getVisibleText(lines) {
+    if (lines.length === 0) {
+        return "";
+    }
+    return lines.map((line) => line.text).join("\n");
+}
+export function visibleOffsetToCursorOffset(lines, visibleOffset) {
+    if (lines.length === 0) {
+        return 0;
+    }
+    const clampedOffset = Math.max(0, visibleOffset);
+    const lineOffsets = getLineOffsets(lines);
+    let codeUnitIndex = 0;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const lineStart = codeUnitIndex;
+        const lineEnd = lineStart + line.text.length;
+        if (clampedOffset <= lineEnd || index === lines.length - 1) {
+            const offsetInLine = Math.max(0, Math.min(clampedOffset - lineStart, line.text.length));
+            const cursorOffsetInLine = cursorOffsetFromCodeUnit(line, offsetInLine);
+            const lineStartOffset = lineOffsets[index] ?? 0;
+            return lineStartOffset + cursorOffsetInLine;
+        }
+        codeUnitIndex = lineEnd + (line.hasNewline ? 1 : 0);
+        if (line.hasNewline && clampedOffset === codeUnitIndex) {
+            const lineStartOffset = lineOffsets[index] ?? 0;
+            return lineStartOffset + line.cursorLength + 1;
+        }
+    }
+    return null;
+}
+export function cursorOffsetToVisibleOffset(lines, cursorOffset) {
+    if (lines.length === 0) {
+        return 0;
+    }
+    const lineOffsets = getLineOffsets(lines);
+    const { lineIndex, offsetInLine } = resolveOffsetToLine(lines, cursorOffset);
+    let codeUnitIndex = 0;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (index === lineIndex) {
+            const offset = Math.max(0, Math.min(offsetInLine, line.cursorLength));
+            return codeUnitIndex + (line.cursorToCodeUnit[offset] ?? 0);
+        }
+        codeUnitIndex += line.text.length + (line.hasNewline ? 1 : 0);
+    }
+    const lastLine = lines[lines.length - 1];
+    const lastStart = lineOffsets[lineOffsets.length - 1] ?? 0;
+    const lastOffset = Math.max(0, cursorOffset - lastStart);
+    return (codeUnitIndex +
+        (lastLine.cursorToCodeUnit[lastOffset] ?? lastLine.text.length));
+}

package/dist/cake/extensions/blockquote/blockquote.d.ts

@@ -1 +1,2 @@
 export declare const blockquoteExtension: import("../../..").CakeExtension;
+//# sourceMappingURL=blockquote.d.ts.map

package/dist/cake/extensions/blockquote/blockquote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockquote.d.ts","sourceRoot":"","sources":["../../../../src/cake/extensions/blockquote/blockquote.ts"],"names":[],"mappings":"AAsIA,eAAO,MAAM,mBAAmB,kCA8F9B,CAAC"}

package/dist/cake/extensions/blockquote/blockquote.js

@@ -0,0 +1,177 @@
+import { defineExtension, } from "../../core/runtime";
+import { CursorSourceBuilder } from "../../core/mapping/cursor-source-map";
+const BLOCKQUOTE_KIND = "blockquote";
+const PREFIX = "> ";
+const BLOCKQUOTE_PATTERN = /^> /;
+function findLineStartInSource(source, sourceOffset) {
+    let lineStart = sourceOffset;
+    while (lineStart > 0 && source[lineStart - 1] !== "\n") {
+        lineStart--;
+    }
+    return lineStart;
+}
+function isInsideBlockquote(source, sourcePos) {
+    const lineStart = findLineStartInSource(source, sourcePos);
+    const lineContent = source.slice(lineStart, source.indexOf("\n", lineStart) === -1
+        ? source.length
+        : source.indexOf("\n", lineStart));
+    return BLOCKQUOTE_PATTERN.test(lineContent);
+}
+function handleExitBlockquote(state) {
+    const { source, selection, map, runtime } = state;
+    const cursorPos = Math.min(selection.start, selection.end);
+    const sourcePos = map.cursorToSource(cursorPos, selection.affinity ?? "forward");
+    // Only handle if we're inside a blockquote
+    if (!isInsideBlockquote(source, sourcePos)) {
+        return null;
+    }
+    // Find the end of the current line
+    let lineEnd = source.indexOf("\n", sourcePos);
+    if (lineEnd === -1) {
+        lineEnd = source.length;
+    }
+    // Insert a newline after the current line (exits the blockquote)
+    const newSource = source.slice(0, lineEnd) + "\n" + source.slice(lineEnd);
+    // Position cursor at the start of the new line (after the blockquote)
+    const next = runtime.createState(newSource);
+    const newCursorOffset = lineEnd + 1;
+    const caretCursor = next.map.sourceToCursor(newCursorOffset, "forward");
+    return {
+        source: newSource,
+        selection: {
+            start: caretCursor.cursorOffset,
+            end: caretCursor.cursorOffset,
+            affinity: "forward",
+        },
+    };
+}
+function handleToggleBlockquote(state) {
+    const { source, selection, map, runtime } = state;
+    // Get the cursor's source position
+    const cursorPos = Math.min(selection.start, selection.end);
+    const sourcePos = map.cursorToSource(cursorPos, selection.affinity ?? "forward");
+    // Find line boundaries in source
+    const lineStart = findLineStartInSource(source, sourcePos);
+    let lineEnd = source.indexOf("\n", lineStart);
+    if (lineEnd === -1) {
+        lineEnd = source.length;
+    }
+    const lineContent = source.slice(lineStart, lineEnd);
+    const blockquoteMatch = lineContent.match(BLOCKQUOTE_PATTERN);
+    let newSource;
+    let newCursorOffset;
+    if (blockquoteMatch) {
+        // Line is already a blockquote - remove the prefix
+        newSource =
+            source.slice(0, lineStart) +
+                lineContent.slice(PREFIX.length) +
+                source.slice(lineEnd);
+        // Adjust cursor position - move back by prefix length
+        const cursorLineOffset = sourcePos - lineStart;
+        if (cursorLineOffset >= PREFIX.length) {
+            newCursorOffset = sourcePos - PREFIX.length;
+        }
+        else {
+            newCursorOffset = lineStart;
+        }
+    }
+    else {
+        // Line is not a blockquote - add the prefix
+        newSource =
+            source.slice(0, lineStart) + PREFIX + lineContent + source.slice(lineEnd);
+        // Cursor moves forward by prefix length
+        newCursorOffset = sourcePos + PREFIX.length;
+    }
+    // Create new state and map cursor through it
+    const next = runtime.createState(newSource);
+    const caretCursor = next.map.sourceToCursor(newCursorOffset, "forward");
+    return {
+        source: newSource,
+        selection: {
+            start: caretCursor.cursorOffset,
+            end: caretCursor.cursorOffset,
+            affinity: "forward",
+        },
+    };
+}
+export const blockquoteExtension = defineExtension({
+    name: "blockquote",
+    onEdit(command, state) {
+        if (command.type === "toggle-blockquote") {
+            return handleToggleBlockquote(state);
+        }
+        // Handle insert-hard-line-break (Cmd+Enter) to exit blockquote
+        if (command.type === "insert-hard-line-break") {
+            return handleExitBlockquote(state);
+        }
+        return null;
+    },
+    parseBlock(source, start, context) {
+        if (source.slice(start, start + PREFIX.length) !== PREFIX) {
+            return null;
+        }
+        const blocks = [];
+        let pos = start;
+        while (pos < source.length) {
+            if (source.slice(pos, pos + PREFIX.length) !== PREFIX) {
+                break;
+            }
+            let lineEnd = source.indexOf("\n", pos);
+            if (lineEnd === -1) {
+                lineEnd = source.length;
+            }
+            const contentStart = pos + PREFIX.length;
+            const content = context.parseInline(source, contentStart, lineEnd);
+            const paragraph = {
+                type: "paragraph",
+                content,
+            };
+            blocks.push(paragraph);
+            if (lineEnd >= source.length) {
+                pos = lineEnd;
+                break;
+            }
+            const nextLineStart = lineEnd + 1;
+            if (source.slice(nextLineStart, nextLineStart + PREFIX.length) === PREFIX) {
+                pos = nextLineStart;
+                continue;
+            }
+            pos = lineEnd;
+            break;
+        }
+        return {
+            block: {
+                type: "block-wrapper",
+                kind: BLOCKQUOTE_KIND,
+                blocks,
+            },
+            nextPos: pos,
+        };
+    },
+    serializeBlock(block, context) {
+        if (block.type !== "block-wrapper" || block.kind !== BLOCKQUOTE_KIND) {
+            return null;
+        }
+        const builder = new CursorSourceBuilder();
+        block.blocks.forEach((child, index) => {
+            builder.appendSourceOnly(PREFIX);
+            const serialized = context.serializeBlock(child);
+            builder.appendSerialized(serialized);
+            if (index < block.blocks.length - 1) {
+                builder.appendText("\n");
+            }
+        });
+        return builder.build();
+    },
+    renderBlock(block, context) {
+        if (block.type !== "block-wrapper" || block.kind !== BLOCKQUOTE_KIND) {
+            return null;
+        }
+        const element = document.createElement("blockquote");
+        element.setAttribute("data-block-wrapper", BLOCKQUOTE_KIND);
+        for (const node of context.renderBlocks(block.blocks)) {
+            element.append(node);
+        }
+        return element;
+    },
+});

package/dist/cake/extensions/blockquote/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./blockquote";
+//# sourceMappingURL=index.d.ts.map

package/dist/cake/extensions/blockquote/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cake/extensions/blockquote/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/cake/extensions/blockquote/index.js

@@ -0,0 +1 @@
+export * from "./blockquote";

package/dist/cake/extensions/bold/bold.d.ts

@@ -1 +1,2 @@
 export declare const boldExtension: import("../../..").CakeExtension;
+//# sourceMappingURL=bold.d.ts.map

package/dist/cake/extensions/bold/bold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bold.d.ts","sourceRoot":"","sources":["../../../../src/cake/extensions/bold/bold.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,aAAa,kCAuGxB,CAAC"}