pr-shepherd 0.38.1 → 0.40.0

package/bin/journal/markdown-container.mjs

@@ -0,0 +1,110 @@
+function visualColumn(line, end) {
+    let column = 0;
+    for (let i = 0; i < end; i++)
+        column = line[i] === "\t" ? column + (4 - (column % 4)) : column + 1;
+    return column;
+}
+function quoteEnd(line, offset) {
+    let marker = offset;
+    while (marker < offset + 3 && line[marker] === " ")
+        marker++;
+    if (line[marker] !== ">")
+        return null;
+    marker++;
+    return line[marker] === " " || line[marker] === "\t" ? marker + 1 : marker;
+}
+function listEnd(line, offset) {
+    let marker = offset;
+    while (marker < offset + 3 && line[marker] === " ")
+        marker++;
+    const match = line.slice(marker).match(/^(?:[-+*]|\d{1,9}[.)])/)?.[0];
+    if (!match)
+        return null;
+    let end = marker + match.length;
+    const paddingStart = end;
+    const startColumn = visualColumn(line, offset);
+    let column = visualColumn(line, end);
+    let padding = 0;
+    while (line[end] === " " || line[end] === "\t") {
+        const nextColumn = line[end] === "\t" ? column + (4 - (column % 4)) : column + 1;
+        padding += nextColumn - column;
+        column = nextColumn;
+        end++;
+    }
+    if (padding === 0)
+        return null;
+    if (padding > 4) {
+        end = paddingStart + 1;
+        const actualWidth = visualColumn(line, end) - visualColumn(line, paddingStart);
+        column = visualColumn(line, paddingStart) + 1;
+        return { end, indent: actualWidth - 1, width: column - startColumn };
+    }
+    return { end, indent: 0, width: column - startColumn };
+}
+export function markdownContainer(line) {
+    const tokens = [];
+    let indent = 0;
+    let offset = 0;
+    while (true) {
+        const quote = quoteEnd(line, offset);
+        if (quote !== null) {
+            tokens.push({ kind: "quote" });
+            offset = quote;
+            continue;
+        }
+        const list = listEnd(line, offset);
+        if (!list)
+            break;
+        tokens.push({ kind: "list", width: list.width });
+        offset = list.end;
+        indent = list.indent;
+        if (indent)
+            break;
+    }
+    return { content: line.slice(offset), indent, tokens };
+}
+export function resolveMarkdownContainer(line, active) {
+    for (let depth = active.length; depth > 0; depth--) {
+        const retained = active.slice(0, depth);
+        const continuation = stripMarkdownContainer(line, retained);
+        if (continuation === null)
+            continue;
+        const nested = markdownContainer(continuation);
+        return {
+            content: nested.content,
+            indent: nested.indent,
+            tokens: [...retained, ...nested.tokens],
+        };
+    }
+    return markdownContainer(line);
+}
+export function fenceStart(line, parsed = markdownContainer(line)) {
+    const match = `${" ".repeat(parsed.indent)}${parsed.content}`.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+    return match && !(match[1][0] === "`" && match[2].includes("`"))
+        ? { container: parsed.tokens, length: match[1].length, marker: match[1][0] }
+        : null;
+}
+export function stripMarkdownContainer(line, tokens) {
+    let offset = 0;
+    for (const [index, token] of tokens.entries()) {
+        if (token.kind === "quote") {
+            const end = quoteEnd(line, offset);
+            if (end === null)
+                return null;
+            offset = end;
+            continue;
+        }
+        if (line.slice(offset).trim() === "" &&
+            tokens.slice(index).every((item) => item.kind === "list"))
+            return "";
+        const startColumn = visualColumn(line, offset);
+        let column = startColumn;
+        while (column - startColumn < token.width && (line[offset] === " " || line[offset] === "\t")) {
+            column = line[offset] === "\t" ? column + (4 - (column % 4)) : column + 1;
+            offset++;
+        }
+        if (column - startColumn < token.width)
+            return null;
+    }
+    return line.slice(offset);
+}

package/bin/journal/markdown-html.d.mts

@@ -0,0 +1,20 @@
+import { type MarkdownContainer } from "./markdown-container.mts";
+export type RawHtmlBlock = {
+    container: MarkdownContainer;
+    kind: "closing-tag";
+    tag: string;
+} | {
+    container: MarkdownContainer;
+    kind: "blank-line";
+} | {
+    container: MarkdownContainer;
+    kind: "terminator";
+    terminator: string;
+};
+export declare function rawHtmlStart(line: string, parsed?: {
+    content: string;
+    indent: number;
+    tokens: MarkdownContainer;
+}): RawHtmlBlock | null;
+export declare function rawHtmlEnd(block: RawHtmlBlock, content: string): number | null;
+export declare function inQuotedHtmlAttribute(line: string, offset: number): boolean;

package/bin/journal/markdown-html.mjs

@@ -0,0 +1,119 @@
+import { markdownContainer } from "./markdown-container.mjs";
+const BLOCK_TAGS = new Set([
+    "address",
+    "article",
+    "aside",
+    "base",
+    "basefont",
+    "blockquote",
+    "body",
+    "caption",
+    "center",
+    "col",
+    "colgroup",
+    "dd",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "dt",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "footer",
+    "form",
+    "frame",
+    "frameset",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "hr",
+    "html",
+    "iframe",
+    "legend",
+    "li",
+    "link",
+    "main",
+    "menu",
+    "menuitem",
+    "nav",
+    "noframes",
+    "ol",
+    "optgroup",
+    "option",
+    "p",
+    "param",
+    "plaintext",
+    "search",
+    "section",
+    "table",
+    "tbody",
+    "td",
+    "tfoot",
+    "th",
+    "thead",
+    "title",
+    "tr",
+    "track",
+    "ul",
+    "wbr",
+]);
+export function rawHtmlStart(line, parsed = markdownContainer(line)) {
+    const { content, indent, tokens } = parsed;
+    const visible = `${" ".repeat(indent)}${content}`;
+    const tag = visible.match(/^ {0,3}<(pre|script|style|textarea)(?:\s|>|$)/i)?.[1];
+    if (tag)
+        return { container: tokens, kind: "closing-tag", tag };
+    if (/^ {0,3}<\?(?:.|\n)*/.test(visible))
+        return { container: tokens, kind: "terminator", terminator: "?>" };
+    if (/^ {0,3}<!\[CDATA\[/.test(visible))
+        return { container: tokens, kind: "terminator", terminator: "]]>" };
+    if (/^ {0,3}<![A-Z]/.test(visible))
+        return { container: tokens, kind: "terminator", terminator: ">" };
+    const block = visible
+        .match(/^ {0,3}<\/?([A-Za-z][A-Za-z0-9-]*)(?:\s|\/?>|$)/)?.[1]
+        ?.toLowerCase();
+    if (!block || block === "details" || block === "summary")
+        return null;
+    if (!BLOCK_TAGS.has(block) &&
+        !/^ {0,3}<\/?[A-Za-z][A-Za-z0-9-]*(?:\s[^<>]*?|\/?)>$/.test(visible))
+        return null;
+    return { container: tokens, kind: "blank-line" };
+}
+export function rawHtmlEnd(block, content) {
+    if (block.kind === "blank-line")
+        return content.trim() === "" ? 0 : null;
+    if (block.kind === "terminator") {
+        const index = content.indexOf(block.terminator);
+        return index === -1 ? null : index + block.terminator.length;
+    }
+    const close = new RegExp(`</${block.tag}>`, "i").exec(content);
+    return close ? close.index + close[0].length : null;
+}
+export function inQuotedHtmlAttribute(line, offset) {
+    let inTag = false;
+    let quote = null;
+    for (let i = 0; i < offset; i++) {
+        const char = line[i];
+        if (!inTag) {
+            if (char === "<" && /^\/?[A-Za-z]/.test(line.slice(i + 1)))
+                inTag = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'")
+            quote = char;
+        else if (char === ">")
+            inTag = false;
+    }
+    return inTag && quote !== null;
+}

package/bin/journal/markdown-line.d.mts

@@ -0,0 +1,8 @@
+type MarkdownLine = {
+    ignored: boolean;
+    nested: boolean;
+    visiblePrefix: string;
+};
+export declare const scanMarkdownLines: (lines: string[]) => MarkdownLine[];
+export declare const isSafeMarkdownInsertionPoint: (lines: string[]) => boolean;
+export {};

package/bin/journal/markdown-line.mjs

@@ -0,0 +1,166 @@
+import { fenceStart, resolveMarkdownContainer, stripMarkdownContainer, } from "./markdown-container.mjs";
+import { inQuotedHtmlAttribute, rawHtmlEnd, rawHtmlStart, } from "./markdown-html.mjs";
+import { backtickRuns, nextBacktickRun, nextCodeOpener } from "./markdown-backticks.mjs";
+import { isIndentedCode, structuralDetailsStart } from "./markdown-structure.mjs";
+function interruptsInlineContent(line) {
+    return (line.trim() === "" ||
+        /^ {0,3}(?:#{1,6}(?:[ \t]+|$)|>)/.test(line) ||
+        /^ {0,3}(?:[-+*]|\d{1,9}[.)])[ \t]+/.test(line) ||
+        /^ {0,3}(?:(?:\*[ \t]*){3,}|-+[ \t]*|(?:_[ \t]*){3,}|=+[ \t]*)$/.test(line) ||
+        fenceStart(line) !== null ||
+        rawHtmlStart(line) !== null ||
+        structuralDetailsStart(line) !== null);
+}
+function hasCloser(lines, lineIndex, offset, length) {
+    for (let i = lineIndex; i < lines.length; i++) {
+        if (i > lineIndex && interruptsInlineContent(lines[i]))
+            return false;
+        if (backtickRuns(lines[i]).some((run) => run.length === length && (i > lineIndex || run.index > offset)))
+            return true;
+    }
+    return false;
+}
+function scanMarkdown(lines) {
+    const result = [];
+    let codeSpan = null;
+    let comment = null;
+    let fence = null;
+    let html = null;
+    let activeContainer = [];
+    let indentedCodeContainer = null;
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex];
+        const container = resolveMarkdownContainer(line, activeContainer);
+        activeContainer = container.tokens;
+        const nested = container.tokens.length > 0;
+        const push = (ignored, visiblePrefix) => result.push({ ignored, nested, visiblePrefix });
+        if (indentedCodeContainer) {
+            if (stripMarkdownContainer(line, indentedCodeContainer) !== null) {
+                push(true, "");
+                continue;
+            }
+            indentedCodeContainer = null;
+        }
+        let allowCodeOpeners = true;
+        let forceIgnored = false;
+        let scanOffset = 0;
+        if (html) {
+            const content = stripMarkdownContainer(line, html.container);
+            if (content === null)
+                html = null;
+            else {
+                const end = rawHtmlEnd(html, content);
+                if (end === null) {
+                    push(true, "");
+                    continue;
+                }
+                html = null;
+                allowCodeOpeners = false;
+                forceIgnored = true;
+                scanOffset = line.length - content.length + end;
+            }
+        }
+        if (!forceIgnored && fence) {
+            const content = stripMarkdownContainer(line, fence.container);
+            if (content === null)
+                fence = null;
+            else {
+                const match = content.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+                if (match &&
+                    match[1][0] === fence.marker &&
+                    match[1].length >= fence.length &&
+                    /^[ \t]*$/.test(match[2]))
+                    fence = null;
+                push(true, "");
+                continue;
+            }
+        }
+        if (comment &&
+            (stripMarkdownContainer(line, comment.container) === null ||
+                (comment.inline && line.trim() === "")))
+            comment = null;
+        if (!forceIgnored && codeSpan === null && !comment) {
+            if (isIndentedCode(`${" ".repeat(container.indent)}${container.content}`)) {
+                if (container.tokens.length)
+                    indentedCodeContainer = container.tokens;
+                push(true, "");
+                continue;
+            }
+            const openingFence = fenceStart(line, container);
+            if (openingFence) {
+                fence = openingFence;
+                push(true, "");
+                continue;
+            }
+            const openingHtml = rawHtmlStart(line, container);
+            if (openingHtml) {
+                const content = stripMarkdownContainer(line, openingHtml.container) ?? "";
+                const end = rawHtmlEnd(openingHtml, content);
+                if (end === null) {
+                    html = openingHtml;
+                    push(true, "");
+                    continue;
+                }
+                allowCodeOpeners = false;
+                forceIgnored = true;
+                scanOffset = line.length - content.length + end;
+            }
+        }
+        const startsMasked = forceIgnored || codeSpan !== null || comment !== null;
+        const visible = line.split("");
+        const runs = backtickRuns(line);
+        const mask = (start, end) => visible.fill(" ", start, end);
+        let offset = scanOffset;
+        while (offset < line.length) {
+            if (comment) {
+                const close = /--!?>/.exec(line.slice(offset));
+                const end = close === null ? line.length : offset + close.index + close[0].length;
+                mask(offset, end);
+                if (close === null)
+                    break;
+                comment = null;
+                offset = end;
+                continue;
+            }
+            if (codeSpan !== null) {
+                const close = nextBacktickRun(runs, offset, codeSpan);
+                mask(offset, close ? close.index + close.length : line.length);
+                if (!close)
+                    break;
+                codeSpan = null;
+                offset = close.index + close.length;
+                continue;
+            }
+            const commentAt = line.indexOf("<!--", offset);
+            const nextRun = allowCodeOpeners ? nextCodeOpener(runs, offset) : undefined;
+            if (commentAt !== -1 && (!nextRun || commentAt < nextRun.index)) {
+                let slashes = 0;
+                while (line[commentAt - slashes - 1] === "\\")
+                    slashes++;
+                if (slashes % 2 === 1 || inQuotedHtmlAttribute(line, commentAt)) {
+                    offset = commentAt + 4;
+                    continue;
+                }
+                mask(commentAt, commentAt + 4);
+                comment = { container: activeContainer, inline: line.slice(0, commentAt).trim() !== "" };
+                offset = commentAt + 4;
+                continue;
+            }
+            if (!nextRun)
+                break;
+            if (!nextRun.escaped && hasCloser(lines, lineIndex, nextRun.index, nextRun.length)) {
+                codeSpan = nextRun.length;
+                mask(nextRun.index, nextRun.index + nextRun.length);
+            }
+            offset = nextRun.index + nextRun.length;
+        }
+        const visiblePrefix = visible.join("");
+        push(startsMasked || visiblePrefix === "", visiblePrefix);
+    }
+    return {
+        lines: result,
+        safeAtEof: comment === null && fence === null && (html === null || html.kind === "blank-line"),
+    };
+}
+export const scanMarkdownLines = (lines) => scanMarkdown(lines).lines;
+export const isSafeMarkdownInsertionPoint = (lines) => scanMarkdown(lines).safeAtEof;

package/bin/journal/markdown-setext.d.mts

@@ -0,0 +1,7 @@
+type MarkdownLine = {
+    ignored: boolean;
+    nested: boolean;
+    visiblePrefix: string;
+};
+export declare function setextParagraphStart(lines: string[], syntax: MarkdownLine[], underline: number): number | null;
+export {};

package/bin/journal/markdown-setext.mjs

@@ -0,0 +1,15 @@
+const NON_PARAGRAPH = /^ {0,3}(?:#{1,6}(?:[ \t]+|$)|>|(?:[-+*]|\d{1,9}[.)])[ \t]+)/;
+function isParagraphText(line, syntax) {
+    return (!syntax.ignored &&
+        !syntax.nested &&
+        line.trim() !== "" &&
+        !NON_PARAGRAPH.test(syntax.visiblePrefix));
+}
+export function setextParagraphStart(lines, syntax, underline) {
+    let start = underline - 1;
+    if (start < 0 || !isParagraphText(lines[start], syntax[start]))
+        return null;
+    while (start > 0 && isParagraphText(lines[start - 1], syntax[start - 1]))
+        start--;
+    return start;
+}

package/bin/journal/markdown-structure.d.mts

@@ -0,0 +1,2 @@
+export declare function isIndentedCode(line: string): boolean;
+export declare function structuralDetailsStart(line: string): number | null;

package/bin/journal/markdown-structure.mjs

@@ -0,0 +1,35 @@
+export function isIndentedCode(line) {
+    let columns = 0;
+    for (const char of line) {
+        if (char !== " " && char !== "\t")
+            break;
+        columns += char === "\t" ? 4 - (columns % 4) : 1;
+    }
+    return columns >= 4;
+}
+export function structuralDetailsStart(line) {
+    let index = 0;
+    while (line[index] === " " && index < 4)
+        index++;
+    if (index > 3 || line[index] === "\t")
+        return null;
+    if (/^<(?:details(?:\s+[^>]*)?\/?|\/details)>/i.test(line.slice(index)))
+        return index;
+    const marker = line.slice(index).match(/^(?:[-+*]|\d{1,9}[.)])/);
+    if (!marker)
+        return null;
+    index += marker[0].length;
+    let column = index;
+    let padding = 0;
+    while (line[index] === " " || line[index] === "\t") {
+        const nextColumn = line[index] === "\t" ? column + (4 - (column % 4)) : column + 1;
+        padding += nextColumn - column;
+        column = nextColumn;
+        index++;
+    }
+    return padding > 0 &&
+        padding <= 4 &&
+        /^<(?:details(?:\s+[^>]*)?\/?|\/details)>/i.test(line.slice(index))
+        ? index
+        : null;
+}

package/bin/journal/reconcile.d.mts

@@ -0,0 +1,17 @@
+export type ShepherdJournalReconcileResult = {
+    body: string;
+    ok: true;
+} | {
+    error: string;
+    ok: false;
+};
+export type ShepherdJournalBounds = {
+    contentEnd: number;
+    contentStart: number;
+    end: number;
+    format: "details" | "legacy";
+    start: number;
+};
+export declare function scanShepherdJournal(lines: string[]): ShepherdJournalBounds | null | "error";
+export declare function containsJournalEntry(lines: string[], item: string): boolean;
+export declare function reconcileShepherdJournal(suppliedBody: string, liveBody: string): ShepherdJournalReconcileResult;