@astrosheep/keiyaku 2.9.13 → 4.0.0

package/build/core/markdown/lex.js

@@ -1,274 +0,0 @@
-const FENCE_DELIMITERS = ["`", "~"];
-function countLeadingSpaces(line) {
-    let idx = 0;
-    while (idx < line.length && line[idx] === " ") {
-        idx += 1;
-    }
-    return idx;
-}
-function parseFence(trimmedLine) {
-    const delimiter = FENCE_DELIMITERS.find((candidate) => trimmedLine.startsWith(candidate.repeat(3)));
-    if (!delimiter)
-        return null;
-    let idx = 0;
-    while (idx < trimmedLine.length && trimmedLine[idx] === delimiter) {
-        idx += 1;
-    }
-    if (idx < 3)
-        return null;
-    return {
-        delimiter,
-        length: idx,
-        info: trimmedLine.slice(idx).trim(),
-    };
-}
-function isAsciiDigit(char) {
-    return char !== undefined && char >= "0" && char <= "9";
-}
-function isSpaceOrTab(char) {
-    return char === " " || char === "\t";
-}
-function parseHeader(trimmedLine) {
-    let level = 0;
-    while (level < trimmedLine.length && trimmedLine[level] === "#") {
-        level += 1;
-    }
-    if (level === 0)
-        return null;
-    if (!isSpaceOrTab(trimmedLine[level]))
-        return null;
-    const text = trimmedLine.slice(level).trim();
-    if (!text)
-        return null;
-    return { level, text };
-}
-function parseSetextUnderline(trimmedLine) {
-    if (/^=+$/.test(trimmedLine)) {
-        return { level: 1 };
-    }
-    if (/^-+$/.test(trimmedLine)) {
-        return { level: 2 };
-    }
-    return null;
-}
-function parseBlockquote(line) {
-    let idx = 0;
-    while (idx < line.length && line[idx] === " ") {
-        idx += 1;
-    }
-    if (idx > 3 || line[idx] !== ">")
-        return null;
-    let markerEnd = idx + 1;
-    if (line[markerEnd] === " ") {
-        markerEnd += 1;
-    }
-    return {
-        marker: line.slice(0, markerEnd),
-        body: line.slice(markerEnd),
-    };
-}
-function stripUtf8Bom(content) {
-    if (!content.startsWith("\uFEFF"))
-        return content;
-    return content.slice(1);
-}
-const YAML_FRONT_MATTER_DELIMITER = "---";
-const FRONT_MATTER_ENTRY_PATTERN = /^([A-Za-z0-9_.-]+)\s*:\s*(.*)$/;
-function stripQuotedValue(rawValue) {
-    const value = rawValue.trim();
-    if (value.length < 2)
-        return value;
-    const quote = value[0];
-    if ((quote === "'" || quote === '"') && value[value.length - 1] === quote) {
-        return value.slice(1, -1);
-    }
-    return value;
-}
-function parseFrontMatterLines(lines) {
-    const entries = {};
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.length === 0)
-            continue;
-        const match = trimmed.match(FRONT_MATTER_ENTRY_PATTERN);
-        if (!match)
-            continue;
-        const key = match[1] ?? "";
-        const rawValue = match[2] ?? "";
-        entries[key] = stripQuotedValue(rawValue);
-    }
-    return entries;
-}
-function consumeLeadingYamlFrontMatter(lines) {
-    if ((lines[0] ?? "").trim() !== YAML_FRONT_MATTER_DELIMITER) {
-        return { contentLines: lines };
-    }
-    let closingIndex = -1;
-    for (let index = 1; index < lines.length; index += 1) {
-        if ((lines[index] ?? "").trim() === YAML_FRONT_MATTER_DELIMITER) {
-            closingIndex = index;
-            break;
-        }
-    }
-    if (closingIndex === -1) {
-        return { contentLines: lines };
-    }
-    const frontMatterLines = lines.slice(1, closingIndex);
-    const raw = lines.slice(0, closingIndex + 1).join("\n");
-    return {
-        token: {
-            type: "front_matter",
-            raw,
-            entries: parseFrontMatterLines(frontMatterLines),
-        },
-        contentLines: lines.slice(closingIndex + 1),
-    };
-}
-function parseListMarker(line) {
-    let indent = 0;
-    while (indent < line.length && line[indent] === " ") {
-        indent += 1;
-    }
-    const markerStart = indent;
-    const markerChar = line[markerStart];
-    let markerEnd = markerStart;
-    let ordered = false;
-    if (markerChar === "-" || markerChar === "*" || markerChar === "+") {
-        markerEnd += 1;
-    }
-    else if (isAsciiDigit(markerChar)) {
-        while (isAsciiDigit(line[markerEnd])) {
-            markerEnd += 1;
-        }
-        const orderedSuffix = line[markerEnd];
-        if (orderedSuffix !== "." && orderedSuffix !== ")")
-            return null;
-        markerEnd += 1;
-        ordered = true;
-    }
-    else {
-        return null;
-    }
-    if (!isSpaceOrTab(line[markerEnd]))
-        return null;
-    let contentStart = markerEnd;
-    while (isSpaceOrTab(line[contentStart])) {
-        contentStart += 1;
-    }
-    return {
-        indent,
-        ordered,
-        marker: line.slice(markerStart, markerEnd),
-        body: line.slice(contentStart),
-    };
-}
-function isBlankLine(line) {
-    return line.trim().length === 0;
-}
-export function stripTrailingBlankLines(lines) {
-    const trimmed = [...lines];
-    while (trimmed.length > 0 && isBlankLine(trimmed[trimmed.length - 1])) {
-        trimmed.pop();
-    }
-    return trimmed;
-}
-export function isSectionHeaderToken(token) {
-    // Column-0 only: indented ATX-looking lines remain content, not structure.
-    return token.type === "header" && token.leadingSpaces === 0 && (token.level === 1 || token.level === 2);
-}
-export function isFenceClosingToken(token, fence) {
-    return token.type === "fence" && token.delimiter === fence.delimiter && token.length >= fence.length;
-}
-export function lexMarkdown(content) {
-    const lines = stripUtf8Bom(content).split(/\r?\n/);
-    const tokens = [];
-    const frontMatter = consumeLeadingYamlFrontMatter(lines);
-    const contentLines = frontMatter.contentLines;
-    let activeFence = null;
-    if (frontMatter.token) {
-        tokens.push(frontMatter.token);
-    }
-    for (let index = 0; index < contentLines.length; index += 1) {
-        const line = contentLines[index] ?? "";
-        const leadingSpaces = countLeadingSpaces(line);
-        if (leadingSpaces <= 3) {
-            const trimmedLine = line.trimStart();
-            const fence = parseFence(trimmedLine);
-            if (fence) {
-                tokens.push({
-                    type: "fence",
-                    raw: line,
-                    leadingSpaces,
-                    delimiter: fence.delimiter,
-                    length: fence.length,
-                    info: fence.info,
-                });
-                if (!activeFence) {
-                    activeFence = { delimiter: fence.delimiter, length: fence.length };
-                }
-                else if (activeFence.delimiter === fence.delimiter && fence.length >= activeFence.length) {
-                    activeFence = null;
-                }
-                continue;
-            }
-            if (!activeFence) {
-                const header = parseHeader(trimmedLine);
-                if (header) {
-                    tokens.push({
-                        type: "header",
-                        raw: line,
-                        leadingSpaces,
-                        level: header.level,
-                        text: header.text,
-                    });
-                    continue;
-                }
-                const nextLine = contentLines[index + 1];
-                if (trimmedLine.trim().length > 0 && nextLine !== undefined && countLeadingSpaces(nextLine) <= 3) {
-                    const setext = parseSetextUnderline(nextLine.trim());
-                    if (setext) {
-                        tokens.push({
-                            type: "header",
-                            raw: line,
-                            leadingSpaces,
-                            level: setext.level,
-                            text: trimmedLine.trim(),
-                        });
-                        index += 1;
-                        continue;
-                    }
-                }
-            }
-        }
-        const marker = parseListMarker(line);
-        if (marker) {
-            tokens.push({
-                type: "list_marker",
-                raw: line,
-                leadingSpaces,
-                indent: marker.indent,
-                ordered: marker.ordered,
-                marker: marker.marker,
-                body: marker.body,
-            });
-            continue;
-        }
-        const blockquote = parseBlockquote(line);
-        if (blockquote) {
-            tokens.push({
-                type: "blockquote",
-                raw: line,
-                leadingSpaces,
-                marker: blockquote.marker,
-                body: blockquote.body,
-            });
-            continue;
-        }
-        tokens.push({
-            type: "text",
-            raw: line,
-            leadingSpaces,
-        });
-    }
-    return tokens;
-}

package/build/core/markdown/parser.js

@@ -1,260 +0,0 @@
-import { isFenceClosingToken, isSectionHeaderToken, lexMarkdown, stripTrailingBlankLines } from "./lex.js";
-import { KeiyakuParseError, } from "./types.js";
-class MarkdownParser {
-    tokens;
-    options;
-    index = 0;
-    constructor(tokens, options) {
-        this.tokens = tokens;
-        this.options = options;
-    }
-    parseDocument() {
-        const frontmatter = this.parseFrontMatter();
-        return {
-            type: "document",
-            frontmatter,
-            children: this.parseBlocks(() => false),
-        };
-    }
-    parseFrontMatter() {
-        const token = this.peek();
-        if (!token || token.type !== "front_matter")
-            return undefined;
-        this.consume();
-        return {
-            type: "front_matter",
-            entries: token.entries,
-        };
-    }
-    parseBlocks(shouldStop) {
-        const blocks = [];
-        while (!this.isEof()) {
-            if (shouldStop())
-                break;
-            const token = this.peek();
-            if (!token)
-                break;
-            if (this.options.allowSections && isSectionHeaderToken(token)) {
-                blocks.push(this.parseSection());
-                continue;
-            }
-            if (token.type === "fence") {
-                blocks.push(this.parseCodeBlock());
-                continue;
-            }
-            if (token.type === "header") {
-                blocks.push(this.parseHeading());
-                continue;
-            }
-            if (token.type === "list_marker" && token.indent <= 3) {
-                blocks.push(this.parseList(token.indent, token.ordered));
-                continue;
-            }
-            if (token.type === "blockquote") {
-                blocks.push(this.parseBlockquote());
-                continue;
-            }
-            if (token.type === "front_matter") {
-                this.consume();
-                continue;
-            }
-            blocks.push(this.parseText(shouldStop));
-        }
-        return blocks;
-    }
-    parseSection() {
-        const header = this.consume();
-        if (!header || !isSectionHeaderToken(header)) {
-            throw new KeiyakuParseError("invalid markdown parse state: expected section header");
-        }
-        const children = this.parseBlocks(() => {
-            const next = this.peek();
-            return next ? this.options.allowSections && isSectionHeaderToken(next) : false;
-        });
-        return {
-            type: "section",
-            level: header.level,
-            title: header.text,
-            children,
-        };
-    }
-    parseCodeBlock() {
-        const opener = this.consume();
-        if (!opener || opener.type !== "fence") {
-            throw new KeiyakuParseError("invalid markdown parse state: expected code fence");
-        }
-        const lines = [opener.raw];
-        const fence = { delimiter: opener.delimiter, length: opener.length };
-        while (!this.isEof()) {
-            const token = this.consume();
-            if (!token)
-                break;
-            lines.push(token.raw);
-            if (isFenceClosingToken(token, fence)) {
-                break;
-            }
-        }
-        return {
-            type: "code_block",
-            fenceLength: opener.length,
-            info: opener.info,
-            lines,
-        };
-    }
-    parseHeading() {
-        const header = this.consume();
-        if (!header || header.type !== "header") {
-            throw new KeiyakuParseError("invalid markdown parse state: expected heading");
-        }
-        return {
-            type: "heading",
-            level: header.level,
-            text: header.text,
-        };
-    }
-    parseBlockquote() {
-        const lines = [];
-        let marker = "> ";
-        while (!this.isEof()) {
-            const token = this.peek();
-            if (!token || token.type !== "blockquote")
-                break;
-            marker = token.marker;
-            lines.push(token.body);
-            this.consume();
-        }
-        return {
-            type: "blockquote",
-            marker,
-            lines,
-            value: lines.join("\n"),
-        };
-    }
-    parseList(indent, ordered) {
-        const items = [];
-        while (!this.isEof()) {
-            const token = this.peek();
-            if (!token || token.type !== "list_marker")
-                break;
-            if (token.indent !== indent)
-                break;
-            if (token.ordered !== ordered)
-                break;
-            this.consume();
-            items.push(this.parseListItem(token, indent));
-        }
-        return {
-            type: "list",
-            ordered,
-            indent,
-            items,
-        };
-    }
-    parseListItem(markerToken, listIndent) {
-        const lines = [markerToken.body];
-        let itemFence = null;
-        while (!this.isEof()) {
-            const token = this.peek();
-            if (!token)
-                break;
-            if (itemFence) {
-                const consumed = this.consume();
-                if (!consumed)
-                    break;
-                lines.push(consumed.raw);
-                if (isFenceClosingToken(consumed, itemFence)) {
-                    itemFence = null;
-                }
-                continue;
-            }
-            if (this.options.allowSections && isSectionHeaderToken(token)) {
-                break;
-            }
-            if (token.type === "header" && token.leadingSpaces <= listIndent) {
-                break;
-            }
-            if (token.type === "fence" && token.leadingSpaces <= listIndent) {
-                break;
-            }
-            if (token.type === "list_marker") {
-                if (token.indent < listIndent) {
-                    break;
-                }
-                if (token.indent === listIndent) {
-                    if (token.ordered !== markerToken.ordered) {
-                        break;
-                    }
-                    break;
-                }
-            }
-            const consumed = this.consume();
-            if (!consumed)
-                break;
-            lines.push(consumed.raw);
-            if (consumed.type === "fence") {
-                itemFence = { delimiter: consumed.delimiter, length: consumed.length };
-            }
-        }
-        const normalizedLines = stripTrailingBlankLines(lines);
-        const body = normalizedLines.join("\n");
-        const children = parseToAST(body, { allowSections: false }).children;
-        return {
-            type: "list_item",
-            marker: markerToken.marker,
-            indent: markerToken.indent,
-            children,
-        };
-    }
-    parseText(shouldStop) {
-        const lines = [];
-        while (!this.isEof()) {
-            if (shouldStop())
-                break;
-            const token = this.peek();
-            if (!token)
-                break;
-            if (token.type === "fence")
-                break;
-            if (token.type === "header")
-                break;
-            if (token.type === "list_marker" && token.indent <= 3)
-                break;
-            if (token.type === "blockquote")
-                break;
-            if (token.type === "front_matter")
-                break;
-            if (this.options.allowSections && isSectionHeaderToken(token))
-                break;
-            lines.push(token.raw);
-            this.consume();
-        }
-        if (lines.length === 0) {
-            const fallback = this.consume();
-            if (fallback) {
-                lines.push(fallback.raw);
-            }
-        }
-        return {
-            type: "text",
-            lines,
-            value: lines.join("\n"),
-        };
-    }
-    peek() {
-        return this.tokens[this.index];
-    }
-    consume() {
-        const token = this.tokens[this.index];
-        this.index += 1;
-        return token;
-    }
-    isEof() {
-        return this.index >= this.tokens.length;
-    }
-}
-export function parseToAST(content, options = {}) {
-    const parser = new MarkdownParser(lexMarkdown(content), {
-        allowSections: options.allowSections ?? true,
-    });
-    return parser.parseDocument();
-}

package/build/core/markdown/render.js

@@ -1,68 +0,0 @@
-function renderListItemFirstLine(item) {
-    const content = renderNodeContent(item);
-    if (!content) {
-        return `${" ".repeat(item.indent)}${item.marker}`;
-    }
-    const [firstLine, ...rest] = content.split("\n");
-    const prefix = `${" ".repeat(item.indent)}${item.marker}${firstLine.length > 0 ? " " : ""}${firstLine}`;
-    if (rest.length === 0) {
-        return prefix;
-    }
-    return [prefix, ...rest].join("\n");
-}
-export function renderBlock(node) {
-    switch (node.type) {
-        case "section": {
-            const header = `${"#".repeat(node.level)} ${node.title}`;
-            const body = renderNodeContent(node);
-            return body ? `${header}\n${body}` : header;
-        }
-        case "list":
-            return node.items.map((item) => renderListItemFirstLine(item)).join("\n");
-        case "code_block":
-            return node.lines.join("\n");
-        case "blockquote":
-            return node.lines.map((line) => `${node.marker}${line}`).join("\n");
-        case "text":
-            return node.value;
-        case "heading":
-            return `${"#".repeat(node.level)} ${node.text}`;
-    }
-}
-export function renderNodeContent(node) {
-    switch (node.type) {
-        case "document":
-            return node.children.map((child) => renderBlock(child)).join("\n");
-        case "section":
-            return node.children.map((child) => renderBlock(child)).join("\n");
-        case "list":
-            return renderBlock(node);
-        case "list_item":
-            return node.children.map((child) => renderBlock(child)).join("\n");
-        case "code_block":
-            return node.lines.join("\n");
-        case "blockquote":
-            return node.lines.map((line) => `${node.marker}${line}`).join("\n");
-        case "text":
-            return node.value;
-        case "heading":
-            return `${"#".repeat(node.level)} ${node.text}`;
-    }
-}
-export function renderSectionContent(sectionNode) {
-    return sectionNode.children.map((child) => renderBlock(child)).join("\n");
-}
-export function extractListItems(sectionNode) {
-    const items = [];
-    for (const child of sectionNode.children) {
-        if (child.type !== "list")
-            continue;
-        for (const item of child.items) {
-            const rendered = renderNodeContent(item).trimEnd();
-            if (rendered.trim().length > 0) {
-                items.push(rendered);
-            }
-        }
-    }
-    return items;
-}

package/build/core/markdown/sections.js

@@ -1,80 +0,0 @@
-import { parseToAST } from "./parser.js";
-import { extractListItems, renderBlock, renderSectionContent } from "./render.js";
-import { KeiyakuParseError } from "./types.js";
-import { normalizeSectionTitle } from "./titles.js";
-function splitByHeadingBlocks(sectionNode) {
-    const groups = [];
-    let currentGroup = [];
-    const commitGroup = () => {
-        if (currentGroup.length === 0)
-            return;
-        const rendered = currentGroup.map((node) => renderBlock(node)).join("\n").trim();
-        if (rendered.length > 0) {
-            groups.push(rendered);
-        }
-        currentGroup = [];
-    };
-    for (const child of sectionNode.children) {
-        if (child.type === "heading" && child.level >= 2) {
-            commitGroup();
-            currentGroup = [child];
-            continue;
-        }
-        currentGroup.push(child);
-    }
-    commitGroup();
-    return groups;
-}
-export function parseMarkdownListSection(text) {
-    const ast = parseToAST(text, { allowSections: false });
-    const pseudoSection = {
-        type: "section",
-        level: 2,
-        title: "",
-        children: ast.children,
-    };
-    const listItems = extractListItems(pseudoSection);
-    if (listItems.length > 0) {
-        return listItems;
-    }
-    const nonHeadingSection = {
-        type: "section",
-        level: 2,
-        title: "",
-        children: pseudoSection.children.filter((child) => child.type !== "heading"),
-    };
-    const fallback = renderSectionContent(nonHeadingSection).trim();
-    return fallback ? [fallback] : [];
-}
-export function parseMarkdownSections(text) {
-    const ast = parseToAST(text, { allowSections: false });
-    const pseudoSection = {
-        type: "section",
-        level: 2,
-        title: "",
-        children: ast.children,
-    };
-    return splitByHeadingBlocks(pseudoSection);
-}
-export function parseMarkdownStructure(content) {
-    const ast = parseToAST(content);
-    const sections = new Map();
-    let title;
-    for (const node of ast.children) {
-        if (node.type !== "section")
-            continue;
-        if (node.level === 1 && !title) {
-            title = node.title.trim() || undefined;
-            continue;
-        }
-        if (node.level !== 2)
-            continue;
-        const normalizedSection = normalizeSectionTitle(node.title);
-        if (sections.has(normalizedSection)) {
-            throw new KeiyakuParseError(`invalid keiyaku draft: duplicate section header '${normalizedSection}'`);
-        }
-        const body = renderSectionContent(node).trim();
-        sections.set(normalizedSection, body ? body.split("\n") : []);
-    }
-    return { title, sections };
-}

package/build/core/markdown/titles.js

@@ -1,9 +0,0 @@
-export function normalizeInlineTitle(value) {
-    return value.trim().replace(/\s+/g, " ");
-}
-export function normalizeLookupTitle(value) {
-    return normalizeInlineTitle(value).toLowerCase();
-}
-export function normalizeSectionTitle(value) {
-    return normalizeLookupTitle(value);
-}

package/build/core/markdown/types.js

@@ -1,6 +0,0 @@
-export class KeiyakuParseError extends Error {
-    constructor(message, cause) {
-        super(message, cause === undefined ? undefined : { cause });
-        this.name = "KeiyakuParseError";
-    }
-}