@astrosheep/keiyaku 0.1.47 → 0.1.49

package/build/utils/keiyaku-document.js

@@ -1,539 +0,0 @@
-export class KeiyakuParseError extends Error {
-    constructor(message, cause) {
-        super(message, cause === undefined ? undefined : { cause });
-        this.name = "KeiyakuParseError";
-    }
-}
-function countLeadingSpaces(line) {
-    let idx = 0;
-    while (idx < line.length && line[idx] === " ") {
-        idx += 1;
-    }
-    return idx;
-}
-function parseFence(trimmedLine) {
-    if (!trimmedLine.startsWith("```"))
-        return null;
-    let idx = 0;
-    while (idx < trimmedLine.length && trimmedLine[idx] === "`") {
-        idx += 1;
-    }
-    if (idx < 3)
-        return null;
-    return {
-        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 stripUtf8Bom(content) {
-    if (!content.startsWith("\uFEFF"))
-        return content;
-    return content.slice(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;
-}
-function stripTrailingBlankLines(lines) {
-    const trimmed = [...lines];
-    while (trimmed.length > 0 && isBlankLine(trimmed[trimmed.length - 1])) {
-        trimmed.pop();
-    }
-    return trimmed;
-}
-function normalizeSectionTitle(title) {
-    return title.trim().toLowerCase().replace(/\s+/g, " ");
-}
-function isSectionHeaderToken(token) {
-    return token.type === "header" && (token.level === 1 || token.level === 2);
-}
-function isFenceClosingToken(token, fence) {
-    return token.type === "fence" && token.length >= fence.length;
-}
-function lexMarkdown(content) {
-    const lines = stripUtf8Bom(content).split(/\r?\n/);
-    const tokens = [];
-    for (const line of lines) {
-        const leadingSpaces = countLeadingSpaces(line);
-        if (leadingSpaces <= 3) {
-            const trimmedLine = line.trimStart();
-            const fence = parseFence(trimmedLine);
-            if (fence) {
-                tokens.push({
-                    type: "fence",
-                    raw: line,
-                    leadingSpaces,
-                    length: fence.length,
-                    info: fence.info,
-                });
-                continue;
-            }
-            const header = parseHeader(trimmedLine);
-            if (header) {
-                tokens.push({
-                    type: "header",
-                    raw: line,
-                    leadingSpaces,
-                    level: header.level,
-                    text: header.text,
-                });
-                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;
-        }
-        tokens.push({
-            type: "text",
-            raw: line,
-            leadingSpaces,
-        });
-    }
-    return tokens;
-}
-class MarkdownParser {
-    tokens;
-    options;
-    index = 0;
-    constructor(tokens, options) {
-        this.tokens = tokens;
-        this.options = options;
-    }
-    parseDocument() {
-        return {
-            type: "document",
-            children: this.parseBlocks(() => false),
-        };
-    }
-    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;
-            }
-            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 = { 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,
-        };
-    }
-    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 = { 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 (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;
-    }
-}
-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");
-}
-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 "text":
-            return node.value;
-        case "heading":
-            return `${"#".repeat(node.level)} ${node.text}`;
-    }
-}
-export function parseToAST(content, options = {}) {
-    const parser = new MarkdownParser(lexMarkdown(content), {
-        allowSections: options.allowSections ?? true,
-    });
-    return parser.parseDocument();
-}
-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 "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;
-}
-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 hasTopLevelHeaders(text) {
-    const ast = parseToAST(text, { allowSections: false });
-    return (() => {
-        const stack = [ast];
-        while (stack.length > 0) {
-            const node = stack.pop();
-            if (!node)
-                continue;
-            if (node.type === "heading" && node.level <= 2)
-                return true;
-            // We intentionally do not inspect code block lines for headings.
-            if (node.type === "code_block" || node.type === "text")
-                continue;
-            if (node.type === "document" || node.type === "section" || node.type === "list_item") {
-                stack.push(...node.children);
-            }
-            else if (node.type === "list") {
-                stack.push(...node.items);
-            }
-        }
-        return false;
-    })();
-}
-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 };
-}