@pecot/visual-mcp 0.0.0-stage → 1.0.0

package/vendor/text-rules/dist/lib/plugins/scan.js

@@ -0,0 +1,228 @@
+import { parseAllDocuments, visit } from 'yaml';
+function lineEnd(text, index) {
+    const newline = text.indexOf('\n', index);
+    return newline === -1 ? text.length : newline;
+}
+// バックスラッシュと、その直後の 1 文字（CRLF は 2 文字）を飛ばす長さ
+function escapeLength(text, index) {
+    return text.startsWith('\r\n', index + 1) ? 3 : 2;
+}
+// from から closer まで読み、本文の end と次に読む位置を返す。
+// 閉じていない文字列は、複数行を許さなければ行末で、許せば入力の末尾で止める。
+function readQuoted(text, from, rule) {
+    let index = from;
+    while (index < text.length) {
+        if (rule.escapable && text.charAt(index) === '\\') {
+            index += escapeLength(text, index);
+        }
+        else if (text.startsWith(rule.closer, index)) {
+            return { end: index, next: index + rule.closer.length };
+        }
+        else if (!rule.multiline && text.charAt(index) === '\n') {
+            return { end: index, next: index };
+        }
+        else {
+            index += 1;
+        }
+    }
+    return { end: text.length, next: text.length };
+}
+function quotedStep(text, opener, rule) {
+    const { end, next } = readQuoted(text, opener, rule);
+    return { next, segment: rule.escapable ? { start: opener, end, hasEscapes: true } : { start: opener, end } };
+}
+// 1 文字ずつ表で引き、表に無い文字は 1 文字進める。
+function* scanWith(text, handlers) {
+    let index = 0;
+    while (index < text.length) {
+        const step = handlers.get(text.charAt(index))?.(text, index) ?? { next: index + 1 };
+        if (step.segment !== undefined) {
+            yield step.segment;
+        }
+        index = step.next;
+    }
+}
+const skipLineComment = (text, index) => ({ next: lineEnd(text, index) });
+// Python。接頭辞（r b f u t）は走査に影響しないので見ない。
+const pythonQuote = (text, index) => {
+    const quote = text.charAt(index);
+    const isTriple = text.startsWith(quote.repeat(3), index);
+    const width = isTriple ? 3 : 1;
+    return quotedStep(text, index + width, { closer: quote.repeat(width), escapable: true, multiline: isTriple });
+};
+const PYTHON_HANDLERS = new Map([
+    ['#', skipLineComment],
+    ['"', pythonQuote],
+    ['\'', pythonQuote],
+]);
+export function pythonStrings(text) {
+    return [...scanWith(text, PYTHON_HANDLERS)];
+}
+// JSON / JSONC。キーは文字列の直後に `:` が来るもので、値だけを返す。
+const KEY_SUFFIX = /\s*:/y;
+const JSON_QUOTE = { closer: '"', escapable: true, multiline: false };
+const jsonString = (text, index) => {
+    const step = quotedStep(text, index + 1, JSON_QUOTE);
+    KEY_SUFFIX.lastIndex = step.next;
+    return KEY_SUFFIX.test(text) ? { next: step.next } : step;
+};
+const jsonSlash = (text, index) => {
+    if (text.startsWith('//', index)) {
+        return { next: lineEnd(text, index) };
+    }
+    if (text.startsWith('/*', index)) {
+        const close = text.indexOf('*/', index + 2);
+        return { next: close === -1 ? text.length : close + 2 };
+    }
+    return { next: index + 1 };
+};
+const JSON_HANDLERS = new Map([
+    ['"', jsonString],
+    ['/', jsonSlash],
+]);
+export function jsonStrings(text) {
+    return [...scanWith(text, JSON_HANDLERS)];
+}
+const HEREDOC = /<<(-?)[ \t]*['"\\]?(\w[\w.-]*)['"]?/y;
+const WORD_START = ' \t\n;|&(';
+// 終端語の行の直後（改行の位置）を返す。見つからなければ何も飛ばさない。
+// `1 << 2` のような算術の左シフトが本文を飲み込まないようにするため。
+function skipHeredocBody(text, from, heredoc) {
+    let line = from;
+    while (line < text.length) {
+        const end = lineEnd(text, line);
+        const content = text.slice(line, end).replace(/\r$/, '');
+        if ((heredoc.stripTabs ? content.replace(/^\t+/, '') : content) === heredoc.delimiter) {
+            return end;
+        }
+        line = end + 1;
+    }
+    return from;
+}
+// heredoc の宣言は行をまたいで持ち越すので、走査ごとに状態を持つ表を作る。
+function shellHandlers() {
+    const pending = [];
+    const newline = (text, index) => {
+        let next = index + 1;
+        for (const heredoc of pending) {
+            next = skipHeredocBody(text, next, heredoc);
+        }
+        pending.length = 0;
+        return { next };
+    };
+    const heredoc = (text, index) => {
+        if (text.startsWith('<<<', index)) {
+            return { next: index + 3 };
+        }
+        HEREDOC.lastIndex = index;
+        const match = HEREDOC.exec(text);
+        if (match === null) {
+            return { next: index + 1 };
+        }
+        pending.push({ delimiter: match[2] ?? '', stripTabs: match[1] === '-' });
+        return { next: index + match[0].length };
+    };
+    return new Map([
+        ['#', (text, index) => ({ next: index === 0 || WORD_START.includes(text.charAt(index - 1)) ? lineEnd(text, index) : index + 1 })],
+        ['\'', (text, index) => quotedStep(text, index + 1, { closer: '\'', escapable: text.charAt(index - 1) === '$', multiline: true })],
+        ['"', (text, index) => quotedStep(text, index + 1, { closer: '"', escapable: true, multiline: true })],
+        ['\\', (text, index) => ({ next: index + escapeLength(text, index) })],
+        ['<', heredoc],
+        ['\n', newline],
+    ]);
+}
+export function shellStrings(text) {
+    return [...scanWith(text, shellHandlers())];
+}
+const quotedBody = (_text, start, valueEnd) => ({ start: start + 1, end: valueEnd - 1 });
+// 二重引用符のスカラーだけが、バックスラッシュのエスケープを持つ。
+const escapedQuotedBody = (_text, start, valueEnd) => ({ start: start + 1, end: valueEnd - 1, hasEscapes: true });
+const plainBody = (_text, start, valueEnd) => ({ start, end: valueEnd });
+// ブロックスカラーは `|` や `>-` の指示子の行を除いた、次の行から。
+const blockBody = (text, start, valueEnd) => {
+    const newline = text.indexOf('\n', start);
+    return { start: newline === -1 ? valueEnd : newline + 1, end: valueEnd };
+};
+const YAML_SEGMENTERS = new Map([
+    ['PLAIN', plainBody],
+    ['QUOTE_DOUBLE', escapedQuotedBody],
+    ['QUOTE_SINGLE', quotedBody],
+    ['BLOCK_LITERAL', blockBody],
+    ['BLOCK_FOLDED', blockBody],
+]);
+function yamlSegment(text, type, range) {
+    const segmenter = YAML_SEGMENTERS.get(type);
+    const [start, valueEnd] = range ?? [];
+    return segmenter === undefined || start === undefined || valueEnd === undefined ? undefined : segmenter(text, start, valueEnd);
+}
+function yamlScalars(text) {
+    const found = [];
+    let isValid = true;
+    for (const document of parseAllDocuments(text)) {
+        isValid &&= document.errors.length === 0;
+        visit(document, {
+            Scalar(key, node) {
+                const segment = key === 'key' ? undefined : yamlSegment(text, String(node.type), node.range);
+                if (segment !== undefined) {
+                    found.push(segment);
+                }
+            },
+        });
+    }
+    return { segments: found, isValid };
+}
+export function yamlStrings(text) {
+    return yamlScalars(text).segments;
+}
+function bodyLines(text, segment) {
+    const lines = [];
+    let cursor = segment.start;
+    while (cursor <= segment.end) {
+        const newline = text.indexOf('\n', cursor);
+        const end = newline === -1 || newline > segment.end ? segment.end : newline;
+        lines.push({ start: cursor, end });
+        cursor = end + 1;
+    }
+    return lines;
+}
+const FRONTMATTER_FENCE = '---';
+function leadingSpaces(line) {
+    return line.length - line.trimStart().length;
+}
+// 本文の最初の空でない行が `---` だけで、後にもう 1 本 `---` だけの行があるとき、その間を YAML として読む。
+// インデントを除いた本文を読み、行ごとの表で元ファイルのオフセットへ戻す。
+// frontmatter でないときと、間が YAML として読めない（構文エラー）ときは undefined を返す。
+export function frontmatterOf(text, segment) {
+    const lines = bodyLines(text, segment);
+    const isFence = (line) => text.slice(line.start, line.end).trim() === FRONTMATTER_FENCE;
+    const firstIndex = lines.findIndex(line => text.slice(line.start, line.end).trim() !== '');
+    const first = lines.at(firstIndex);
+    const closerIndex = lines.findIndex((line, index) => index > firstIndex && isFence(line));
+    const closer = lines.at(closerIndex);
+    if (first === undefined || closer === undefined || firstIndex === -1 || closerIndex === -1 || !isFence(first)) {
+        return undefined;
+    }
+    const rows = lines.slice(firstIndex + 1, closerIndex).map((line) => {
+        const raw = text.slice(line.start, line.end);
+        return { line, raw, leading: leadingSpaces(raw) };
+    });
+    const indent = Math.min(...rows.filter(row => row.raw.trim() !== '').map(row => row.leading));
+    // 空行は indent より短いことがあるので、除く長さは行の先頭の空白までにとどめる。
+    const pieces = rows.map(({ line, raw, leading }) => ({ origin: line.start + Math.min(indent, leading), body: raw.slice(Math.min(indent, leading)) }));
+    const pieceStarts = pieces.map((_piece, index) => pieces.slice(0, index).reduce((sum, piece) => sum + piece.body.length + 1, 0));
+    const scalars = yamlScalars(pieces.map(piece => piece.body).join('\n'));
+    if (!scalars.isValid) {
+        return undefined;
+    }
+    const locate = (offset) => {
+        const index = pieceStarts.findLastIndex(start => start <= offset);
+        return (pieces.at(index)?.origin ?? 0) + offset - (pieceStarts.at(index) ?? 0);
+    };
+    const values = scalars.segments.map(({ start, end }) => {
+        const mapped = locate(start);
+        return { start: mapped, end: end > start ? locate(end - 1) + 1 : mapped };
+    });
+    const rest = { start: Math.min(closer.end + 1, segment.end), end: segment.end };
+    return { values, rest: segment.hasEscapes === true ? { ...rest, hasEscapes: true } : rest };
+}
+//# sourceMappingURL=scan.js.map

package/vendor/text-rules/dist/lib/plugins/strings.d.ts

@@ -0,0 +1,30 @@
+import type { TextlintPluginProcessor } from '@textlint/types';
+import type { CodeNode, InlineNode, Position, StringNode } from './inline-spans.js';
+interface Location {
+    readonly start: Position;
+    readonly end: Position;
+}
+type Range = readonly [number, number];
+interface Span {
+    readonly raw: string;
+    readonly range: Range;
+    readonly loc: Location;
+}
+interface BreakNode extends Span {
+    readonly type: 'Break';
+}
+interface ParagraphNode extends Span {
+    readonly type: 'Paragraph';
+    readonly children: readonly (StringNode | InlineNode | CodeNode | BreakNode)[];
+}
+export declare function stringParagraphs(text: string, extension: string, lineStarts?: readonly number[]): Promise<readonly ParagraphNode[]>;
+export { documentOf } from './inline-spans.js';
+declare class StringsProcessor {
+    availableExtensions(): string[];
+    processor(extension: string): ReturnType<TextlintPluginProcessor['processor']>;
+}
+declare const _default: {
+    Processor: typeof StringsProcessor;
+};
+export default _default;
+//# sourceMappingURL=strings.d.ts.map

package/vendor/text-rules/dist/lib/plugins/strings.js

@@ -0,0 +1,330 @@
+import { BYTE_ORDER_MARK } from '../byte-order-mark.js';
+import { documentOf, listMarkerLength, splitString } from './inline-spans.js';
+import { loadCommentsPlugin } from './load.js';
+import { frontmatterOf, jsonStrings, pythonStrings, shellStrings, yamlStrings } from './scan.js';
+import { typescriptStrings } from './typescript.js';
+import { vueScripts, vueStrings } from './vue.js';
+const SCANNERS = new Map([
+    ['.py', pythonStrings],
+    ['.pyi', pythonStrings],
+    ['.sh', shellStrings],
+    ['.bash', shellStrings],
+    ['.json', jsonStrings],
+    ['.jsonc', jsonStrings],
+    ['.yaml', yamlStrings],
+    ['.yml', yamlStrings],
+    ['.ts', typescriptStrings('typescript')],
+    ['.mts', typescriptStrings('typescript')],
+    ['.cts', typescriptStrings('typescript')],
+    ['.tsx', typescriptStrings('tsx')],
+    ['.js', typescriptStrings('javascript')],
+    ['.mjs', typescriptStrings('javascript')],
+    ['.cjs', typescriptStrings('javascript')],
+    ['.jsx', typescriptStrings('javascript')],
+    ['.vue', vueStrings],
+]);
+// .vue の script のコメントを comments plugin に読ませるときの拡張子。
+const SCRIPT_EXTENSIONS = new Map([
+    ['typescript', '.ts'],
+    ['tsx', '.tsx'],
+    ['javascript', '.js'],
+]);
+const JAPANESE = /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/u;
+// `/* */` の行頭の `*`（前後の空白を含む）。
+const BLOCK_COMMENT_PREFIX = /^[\t ]*\*[\t ]*/;
+// テンプレート文字列の ${} の位置に置く仮の文字。小文字や全角の文字は和欧間の規則を増やす。
+const PLACEHOLDER = 'X';
+// 行の先頭オフセット表。column は 0 始まり、line は 1 始まり。
+function lineStartsOf(text) {
+    const starts = text.matchAll(/\n/g).map(match => match.index + 1).toArray();
+    return [0, ...starts];
+}
+function spanOf(text, lineStarts, start, end) {
+    const locate = (offset) => {
+        const line = lineStarts.findLastIndex(lineStart => lineStart <= offset);
+        return { line: line + 1, column: offset - (lineStarts.at(line) ?? 0) };
+    };
+    return { raw: text.slice(start, end), range: [start, end], loc: { start: locate(start), end: locate(end) } };
+}
+const TAB_WIDTH = 4;
+const CODE_INDENT = 4;
+const FENCE_OPEN = /^(`{3,}|~{3,})/;
+const HTML_BLOCK_STARTS = [
+    { start: /^<(?:pre|script|style|textarea)(?:[\s>]|$)/i, end: /<\/(?:pre|script|style|textarea)>/i },
+    { start: /^<!--/, end: /-->/ },
+    { start: /^<\?/, end: /\?>/ },
+    { start: /^<![a-z]/i, end: />/ },
+    { start: /^<!\[CDATA\[/, end: /\]\]>/ },
+];
+// type 6 は CommonMark が挙げるブロック要素の名前。基準は、.md を読む textlint の Markdown plugin（micromark 2.11.4）が使う CommonMark 0.29 の一覧。
+// 0.31 で足された search と、外された source は、この一覧に従う。
+// type 7 は行に他の文字を続けない単独のタグ（名前の後ろは空白・`/`・`>`）。
+const HTML_TYPE_6 = /^<\/?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?:[\s>]|\/>|$)/i;
+const HTML_TYPE_7 = /^(?:<[a-z][\w-]*(?=[\s/>])[^<>]*|<\/[a-z][\w-]*\s*)>$/i;
+// 前後の空白。エスケープを解かない本文では、エスケープの `\t` も空白として読む。
+const ESCAPED_LEADING = /^(?:\s|\\t)*/;
+const ESCAPED_TRAILING = /(?:\s|\\t)*$/;
+const ESCAPED_LINE_BREAK = /^\\(?:r\\n|n)/;
+function indentOf(line, hasEscapes) {
+    let width = 0;
+    let index = 0;
+    while (index < line.length) {
+        if (hasEscapes && line.startsWith('\\t', index)) {
+            width += TAB_WIDTH;
+            index += 2;
+        }
+        else if (line.charAt(index) === ' ') {
+            width += 1;
+            index += 1;
+        }
+        else if (line.charAt(index) === '\t') {
+            width += TAB_WIDTH;
+            index += 1;
+        }
+        else {
+            break;
+        }
+    }
+    return width;
+}
+// from から limit までで最初の行の区切りと、次の行の始まりを返す。区切りが無ければ limit で終わる。
+// エスケープを解かない本文では、エスケープの `\n` と `\r\n` も区切りにする（`\\` は対で飛ばす）。
+function lineBreakIn(text, from, limit, hasEscapes) {
+    for (let index = from; index < limit; index += 1) {
+        if (text.charAt(index) === '\n') {
+            return { end: index, next: index + 1 };
+        }
+        if (!hasEscapes || text.charAt(index) !== '\\') {
+            continue;
+        }
+        const escape = ESCAPED_LINE_BREAK.exec(text.slice(index, index + 4))?.[0];
+        if (escape !== undefined) {
+            return { end: index, next: index + escape.length };
+        }
+        index += text.charAt(index + 1) === '\\' ? 1 : 0;
+    }
+    return { end: limit, next: limit + 1 };
+}
+function bodyLinesOf(text, segment) {
+    const hasEscapes = segment.hasEscapes === true;
+    const lines = [];
+    let cursor = segment.start;
+    while (cursor < segment.end) {
+        const { end, next } = lineBreakIn(text, cursor, segment.end, hasEscapes);
+        const line = text.slice(cursor, end);
+        const prefix = segment.blockComment === true ? BLOCK_COMMENT_PREFIX : (hasEscapes ? ESCAPED_LEADING : undefined);
+        const leading = prefix?.exec(line)?.[0].length ?? line.length - line.trimStart().length;
+        const trimmedLength = hasEscapes ? line.length - (ESCAPED_TRAILING.exec(line)?.[0].length ?? 0) : line.trimEnd().length;
+        lines.push({ start: cursor + leading, end: cursor + trimmedLength, indent: segment.blockComment === true ? 0 : indentOf(line, hasEscapes) });
+        cursor = next;
+    }
+    return lines;
+}
+// 1 行目を除いた、空でない行の字下げの最小値。
+function commonIndent(lines) {
+    const indents = lines.slice(1).filter(line => line.start < line.end).map(line => line.indent);
+    return indents.length === 0 ? 0 : Math.min(...indents);
+}
+const NO_HTML_BLOCK = { kind: 'none' };
+function htmlBlockOf(content, canStartSingleTag) {
+    const typed = HTML_BLOCK_STARTS.find(candidate => candidate.start.test(content));
+    if (typed === undefined) {
+        return HTML_TYPE_6.test(content) || (canStartSingleTag && HTML_TYPE_7.test(content)) ? { kind: 'open' } : NO_HTML_BLOCK;
+    }
+    return typed.end.test(content) ? { kind: 'single' } : { kind: 'open', end: typed.end };
+}
+function isFenceClose(content, marker) {
+    const run = /^(`+|~+)\s*$/.exec(content)?.[1];
+    return run !== undefined && run.startsWith(marker.charAt(0)) && run.length >= marker.length;
+}
+function trimmedParagraphs(text, segment) {
+    const lines = bodyLinesOf(text, segment);
+    const common = commonIndent(lines);
+    const isMarkdown = segment.blockComment !== true;
+    const paragraphs = [];
+    let current = [];
+    // 直前のリスト項目の内容の字下げ。コードの字下げは、これに 4 を足した幅から。
+    let itemIndent = 0;
+    let block;
+    const flush = () => {
+        if (current.length === 0) {
+            return;
+        }
+        paragraphs.push(current);
+        current = [];
+    };
+    for (const [index, line] of lines.entries()) {
+        const content = text.slice(line.start, line.end);
+        const isBlank = line.start >= line.end;
+        const indent = index === 0 ? 0 : Math.max(line.indent - common, 0);
+        if (!isBlank && current.length === 0 && indent < itemIndent) {
+            itemIndent = 0;
+        }
+        const codeIndent = itemIndent + CODE_INDENT;
+        if (block?.kind === 'fence') {
+            block = isMarkdown && indent < codeIndent && isFenceClose(content, block.marker) ? undefined : block;
+            continue;
+        }
+        if (block?.kind === 'html') {
+            block = block.end === undefined ? (isBlank ? undefined : block) : (block.end.test(content) ? undefined : block);
+            continue;
+        }
+        if (block?.kind === 'code') {
+            if (isBlank || indent >= codeIndent) {
+                continue;
+            }
+            block = undefined;
+        }
+        if (isBlank) {
+            flush();
+            continue;
+        }
+        if (isMarkdown) {
+            const opening = indent < codeIndent ? FENCE_OPEN.exec(content)?.[1] : undefined;
+            const html = indent < codeIndent ? htmlBlockOf(content, current.length === 0) : NO_HTML_BLOCK;
+            if (indent >= codeIndent && current.length === 0) {
+                block = { kind: 'code' };
+                continue;
+            }
+            if (opening !== undefined && !(opening.startsWith('`') && content.slice(opening.length).includes('`'))) {
+                flush();
+                block = { kind: 'fence', marker: opening };
+                continue;
+            }
+            if (html.kind !== 'none') {
+                flush();
+                block = html.kind === 'single' ? undefined : (html.end === undefined ? { kind: 'html' } : { kind: 'html', end: html.end });
+                continue;
+            }
+        }
+        // リストの記号で始まる行は新しい段落の始まりで、Str には記号を含めない。
+        const marker = listMarkerLength(content);
+        if (marker !== undefined) {
+            flush();
+            itemIndent = indent + marker;
+        }
+        current.push({ start: line.start + (marker ?? 0), end: line.end });
+    }
+    flush();
+    return paragraphs;
+}
+// 行の中の ${} は 1 文字の X として読む（lintText の断片と同じ）。
+// code span・インライン HTML・URL は ${} を X に置き換えた本文で見つけるので、${} をまたいでも 1 つにまとまる。
+// Str に含まれる ${} は value が X の Code にして切り出し、Code・Html・Link に含まれる ${} は、その中に残す。
+function lineNodes(text, view, lineStarts, line, holes) {
+    const inside = holes.filter(candidate => candidate.start >= line.start && candidate.end <= line.end);
+    const body = view.slice(line.start, line.end);
+    const pieces = splitString({ type: 'Str', value: body, ...spanOf(view, lineStarts, line.start, line.end) });
+    const originalOf = (node) => {
+        const raw = text.slice(node.range[0], node.range[1]);
+        return node.type === 'Link'
+            ? { ...node, raw, children: node.children.map(child => ({ ...child, raw: text.slice(child.range[0], child.range[1]) })) }
+            : { ...node, raw };
+    };
+    return pieces.flatMap((piece) => {
+        if (piece.type !== 'Str') {
+            return [originalOf(piece)];
+        }
+        const nodes = [];
+        let cursor = piece.range[0];
+        const addString = (end) => {
+            if (cursor < end) {
+                nodes.push({ type: 'Str', value: text.slice(cursor, end), ...spanOf(text, lineStarts, cursor, end) });
+            }
+        };
+        const holesInPiece = inside.filter(candidate => candidate.start >= piece.range[0] && candidate.end <= piece.range[1]);
+        for (const hole of holesInPiece) {
+            addString(hole.start);
+            nodes.push({ type: 'Code', value: PLACEHOLDER, ...spanOf(text, lineStarts, hole.start, hole.end) });
+            cursor = hole.end;
+        }
+        addString(piece.range[1]);
+        return nodes;
+    });
+}
+// 行ごとの Str と、行の間の Break で段落を組む。Str の range は引用符を含めない。
+function paragraphOf(text, view, lineStarts, lines, holes) {
+    const first = lines[0];
+    const last = lines.at(-1);
+    if (first === undefined || last === undefined) {
+        return undefined;
+    }
+    const children = lines.flatMap((line, index) => {
+        const previous = lines[index - 1];
+        const nodes = lineNodes(text, view, lineStarts, line, holes);
+        return previous === undefined ? [...nodes] : [{ type: 'Break', ...spanOf(text, lineStarts, previous.end, line.start) }, ...nodes];
+    });
+    return { type: 'Paragraph', children, ...spanOf(text, lineStarts, first.start, last.end) };
+}
+// 本文が frontmatter で始まるときは、値ごとの Segment と、閉じた `---` より後の本文に分ける。
+// 読めない frontmatter は分けず、全体を 1 つの本文として扱う。${} を持つ本文は holes を保つため分けない。
+function bodiesOf(text, segment) {
+    const frontmatter = segment.holes === undefined ? frontmatterOf(text, segment) : undefined;
+    return frontmatter === undefined ? [segment] : [...frontmatter.values.flatMap(value => bodiesOf(text, value)), frontmatter.rest];
+}
+// ${} を X に置き換えた、同じ長さの本文。行の分け方と日本語の判定は、${} の中身を見ずにこの本文で行う。
+// ${} ごとに全体を切り直さず、holes の間の断片を積んで 1 回だけつなぐ。
+function viewOf(text, segment) {
+    const holes = segment.holes ?? [];
+    if (holes.length === 0) {
+        return text;
+    }
+    const pieces = [];
+    let cursor = 0;
+    for (const hole of holes) {
+        pieces.push(text.slice(cursor, hole.start), PLACEHOLDER.repeat(hole.end - hole.start));
+        cursor = hole.end;
+    }
+    pieces.push(text.slice(cursor));
+    return pieces.join('');
+}
+// 日本語を含む文字列だけを対象にし、段落ごとの Paragraph にする。
+function paragraphsOf(text, lineStarts, segment) {
+    const view = viewOf(text, segment);
+    const paragraphs = trimmedParagraphs(view, segment);
+    const first = paragraphs[0]?.[0];
+    const last = paragraphs.at(-1)?.at(-1);
+    return first === undefined || last === undefined || !JAPANESE.test(view.slice(first.start, last.end))
+        ? []
+        : paragraphs.flatMap(lines => paragraphOf(text, view, lineStarts, lines, segment.holes ?? []) ?? []);
+}
+export async function stringParagraphs(text, extension, lineStarts = lineStartsOf(text)) {
+    const scanner = SCANNERS.get(extension);
+    if (scanner === undefined) {
+        throw new RangeError(`${extension} は strings plugin の対象外の拡張子です`);
+    }
+    const segments = await scanner(text);
+    return segments.flatMap(segment => bodiesOf(text, segment)).flatMap(body => paragraphsOf(text, lineStarts, body));
+}
+export { documentOf } from './inline-spans.js';
+const EXTENSIONS = SCANNERS.keys().toArray();
+// 文字列の外にあるコメントの Paragraph。.vue は comments plugin が読めないので、script の中身だけを残した本文を拡張子ごとに読ませる。
+async function commentNodes(text, extension) {
+    const Processor = loadCommentsPlugin().Processor;
+    if (extension !== '.vue') {
+        return documentOf(await new Processor().processor(extension).preProcess(text)).children;
+    }
+    const documents = await Promise.all(vueScripts(text).map(async ({ grammar, masked }) => documentOf(await new Processor().processor(SCRIPT_EXTENSIONS.get(grammar) ?? '.js').preProcess(masked)).children));
+    return documents.flat();
+}
+class StringsProcessor {
+    availableExtensions() {
+        return [...EXTENSIONS];
+    }
+    processor(extension) {
+        return {
+            // kernel は本文から BOM を落として数えるので、ここでも落として同じ位置にそろえる。
+            async preProcess(original) {
+                const text = original.replace(BYTE_ORDER_MARK, '');
+                const lineStarts = lineStartsOf(text);
+                const children = [...await commentNodes(text, extension), ...await stringParagraphs(text, extension, lineStarts)].toSorted((a, b) => a.range[0] - b.range[0]);
+                return { type: 'Document', children, ...spanOf(text, lineStarts, 0, text.length) };
+            },
+            postProcess(messages, filePath = '') {
+                return { messages, filePath };
+            },
+        };
+    }
+}
+export default { Processor: StringsProcessor };
+//# sourceMappingURL=strings.js.map

package/vendor/text-rules/dist/lib/plugins/typescript.d.ts

@@ -0,0 +1,4 @@
+import type { Scanner } from './scan.js';
+export type Grammar = 'typescript' | 'tsx' | 'javascript';
+export declare function typescriptStrings(grammar: Grammar): Scanner;
+//# sourceMappingURL=typescript.d.ts.map

package/vendor/text-rules/dist/lib/plugins/typescript.js

@@ -0,0 +1,56 @@
+import { readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { Language, Parser } from 'web-tree-sitter';
+// 置き場の解決はモジュールの読み込みでなく解析のときに行う。失敗は plugin-error として bin の終了コード 2 になる。
+function wasmDirectory() {
+    return path.join(path.dirname(createRequire(import.meta.url).resolve('@cffnpwr/textlint-plugin-comments/package.json')), 'wasm');
+}
+const state = {};
+const languages = new Map();
+async function loadLanguage(grammar) {
+    // eslint-disable-next-line security/detect-non-literal-fs-filename -- 文法名は 3 値の型で、同梱の wasm を読む
+    const bytes = await readFile(path.join(wasmDirectory(), `tree-sitter-${grammar}.wasm`));
+    return Language.load(bytes);
+}
+async function languageOf(grammar) {
+    state.initialization ??= Parser.init();
+    await state.initialization;
+    const loaded = languages.get(grammar) ?? loadLanguage(grammar);
+    languages.set(grammar, loaded);
+    return loaded;
+}
+const STRING_TYPES = ['string', 'template_string', 'jsx_text'];
+// 本文は前後の引用符を除いた区間。テンプレート文字列は `${}` を holes にする。
+// 文字列とテンプレート文字列はエスケープを解かずに含み、JSX のテキストは引用符を持たない。
+function bodyOf(type, start, end, substitutions) {
+    if (type === 'jsx_text') {
+        return { start, end };
+    }
+    return type === 'template_string' ? { start: start + 1, end: end - 1, holes: substitutions, hasEscapes: true } : { start: start + 1, end: end - 1, hasEscapes: true };
+}
+export function typescriptStrings(grammar) {
+    return async (text) => {
+        const language = await languageOf(grammar);
+        const parser = new Parser();
+        try {
+            parser.setLanguage(language);
+            const tree = parser.parse(text);
+            // rootNode.hasError では止めない。この文法は String.raw のタグ付きテンプレートの不正なエスケープ（`\ubuntu` など）も、正しいコードなのに誤りにする。
+            // 構文の誤りそのものは各パッケージの tsc が commit の前に止める。誤りの部分木に入っても、文字列は拾う。
+            if (tree === null) {
+                throw new Error('構文木を作れませんでした');
+            }
+            try {
+                return tree.rootNode.descendantsOfType(STRING_TYPES).filter(node => node.isNamed).map(node => bodyOf(node.type, node.startIndex, node.endIndex, node.children.filter(child => child.type === 'template_substitution').map(child => ({ start: child.startIndex, end: child.endIndex }))));
+            }
+            finally {
+                tree.delete();
+            }
+        }
+        finally {
+            parser.delete();
+        }
+    };
+}
+//# sourceMappingURL=typescript.js.map

package/vendor/text-rules/dist/lib/plugins/vue.d.ts

@@ -0,0 +1,9 @@
+import type { Scanner } from './scan.js';
+import type { Grammar } from './typescript.js';
+export interface VueScript {
+    readonly grammar: Grammar;
+    readonly masked: string;
+}
+export declare function vueScripts(text: string): readonly VueScript[];
+export declare const vueStrings: Scanner;
+//# sourceMappingURL=vue.d.ts.map