@pecot/visual-mcp 0.0.0-stage → 1.1.0

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@pecot/visual-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.0",
+  "type": "module",
+  "description": "pecotv MCP server (standalone distribution)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pecotcraft/pecot.git",
+    "directory": "plugins/pecot-visual"
+  },
+  "bin": {
+    "pecot-visual-mcp": "bin/pecot-visual-mcp.mjs"
+  },
+  "engines": {
+    "node": "^24.22.1 || >=26.12.1"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/server": "^2.4.0",
+    "@xmldom/xmldom": "^0.9.12",
+    "commander": "^15.0.0",
+    "mime-types": "^2.1.35",
+    "playwright": "^1.64.1",
+    "xpath": "^0.0.34",
+    "yaml": "2.9.1",
+    "yauzl": "^3.4.0",
+    "yazl": "^3.3.1",
+    "zod": "^4.6.7",
+    "eslint": "^10.13.0",
+    "@eslint/markdown": "^8.0.3",
+    "js-yaml": "^4.3.2",
+    "synckit": "^0.12.3",
+    "ajv": "^6.15.0",
+    "@cffnpwr/textlint-plugin-comments": "1.0.0",
+    "@textlint-ja/textlint-rule-preset-ai-writing": "^1.7.0",
+    "@textlint/kernel": "^15.8.0",
+    "@textlint/module-interop": "^15.8.0",
+    "@textlint/textlint-plugin-markdown": "^15.8.0",
+    "textlint": "^15.8.0",
+    "textlint-rule-preset-ai-words-ja": "1.2.1",
+    "textlint-rule-preset-ja-technical-writing": "^12.0.2",
+    "web-tree-sitter": "0.27.1"
+  }
+}

package/vendor/text-rules/dist/bin/pecot-text-lint.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=pecot-text-lint.d.ts.map

package/vendor/text-rules/dist/bin/pecot-text-lint.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { main, REAL_DEPS } from '../lib/main.js';
+// `process.exit` は使わず `exitCode` に積み、標準出力を書き切ってから終わらせる。
+process.exitCode = await main(process.argv.slice(2), REAL_DEPS);
+//# sourceMappingURL=pecot-text-lint.js.map

package/vendor/text-rules/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { PRESET_NAMES, EXCLUDED_RULE_IDS, buildRules } from './lib/rules.js';
+export { lintText } from './lib/lint-text.js';
+export type { TextMode, TextFinding } from './lib/lint-text.js';
+export type { TextlintKernelRule } from '@textlint/kernel';
+//# sourceMappingURL=index.d.ts.map

package/vendor/text-rules/dist/index.js

@@ -0,0 +1,3 @@
+export { PRESET_NAMES, EXCLUDED_RULE_IDS, buildRules } from './lib/rules.js';
+export { lintText } from './lib/lint-text.js';
+//# sourceMappingURL=index.js.map

package/vendor/text-rules/dist/lib/byte-order-mark.d.ts

@@ -0,0 +1,2 @@
+export declare const BYTE_ORDER_MARK: RegExp;
+//# sourceMappingURL=byte-order-mark.d.ts.map

package/vendor/text-rules/dist/lib/byte-order-mark.js

@@ -0,0 +1,3 @@
+// kernel は本文から BOM を落として数えるので、bin と strings plugin が同じ正規表現で落として位置をそろえる。
+export const BYTE_ORDER_MARK = /^\u{FEFF}/u;
+//# sourceMappingURL=byte-order-mark.js.map

package/vendor/text-rules/dist/lib/descriptor.d.ts

@@ -0,0 +1,3 @@
+import { TextlintKernelDescriptor } from '@textlint/kernel';
+export declare function buildDescriptor(): TextlintKernelDescriptor;
+//# sourceMappingURL=descriptor.d.ts.map

package/vendor/text-rules/dist/lib/descriptor.js

@@ -0,0 +1,18 @@
+import { TextlintKernelDescriptor } from '@textlint/kernel';
+import { loadCommentsPlugin, loadMarkdownPlugin } from './plugins/load.js';
+import strings from './plugins/strings.js';
+import { buildRules } from './rules.js';
+// kernel は拡張子に先頭一致した plugin 1 つだけで解析するので、strings を comments より前に置く。
+// strings は comments を内包し、.py .sh .json .yaml のコメントと文字列を 1 つの Document にする。
+export function buildDescriptor() {
+    return new TextlintKernelDescriptor({
+        rules: buildRules(),
+        filterRules: [],
+        plugins: [
+            { pluginId: 'markdown', plugin: loadMarkdownPlugin() },
+            { pluginId: 'strings', plugin: strings },
+            { pluginId: 'comments', plugin: loadCommentsPlugin() },
+        ],
+    });
+}
+//# sourceMappingURL=descriptor.js.map

package/vendor/text-rules/dist/lib/findings.d.ts

@@ -0,0 +1,6 @@
+export declare const SUMMARY_PREFIX = "\u3010\u30C6\u30AF\u30CB\u30AB\u30EB\u30E9\u30A4\u30C6\u30A3\u30F3\u30B0\u54C1\u8CEA\u5206\u6790\u3011";
+export declare function oneLine(message: string): string;
+export declare function withoutSummary<T extends {
+    readonly message: string;
+}>(messages: readonly T[]): T[];
+//# sourceMappingURL=findings.d.ts.map

package/vendor/text-rules/dist/lib/findings.js

@@ -0,0 +1,11 @@
+// ai-tech-writing-guideline の件数要約は個別指摘の重複なので除く
+export const SUMMARY_PREFIX = '【テクニカルライティング品質分析】';
+// message 内の改行は 1 行にまとめる
+export function oneLine(message) {
+    return message.replaceAll(/\s*\n\s*/g, ' ').trim();
+}
+// 件数要約の message を除き、個別の指摘だけ残す。
+export function withoutSummary(messages) {
+    return messages.filter(found => !found.message.startsWith(SUMMARY_PREFIX));
+}
+//# sourceMappingURL=findings.js.map

package/vendor/text-rules/dist/lib/lint-text.d.ts

@@ -0,0 +1,9 @@
+export type TextMode = 'fragment' | 'markdown';
+export interface TextFinding {
+    ruleId: string;
+    message: string;
+    line: number;
+    column: number;
+}
+export declare function lintText(text: string, mode: TextMode): Promise<readonly TextFinding[]>;
+//# sourceMappingURL=lint-text.d.ts.map

package/vendor/text-rules/dist/lib/lint-text.js

@@ -0,0 +1,29 @@
+import { TextlintKernel } from '@textlint/kernel';
+import { withoutSummary, oneLine } from './findings.js';
+import { loadMarkdownPlugin } from './plugins/load.js';
+import { buildRules } from './rules.js';
+const kernel = new TextlintKernel();
+const plugin = loadMarkdownPlugin();
+const rules = buildRules();
+// 項目文字列を Markdown として渡すため、行頭の記法がブロック要素にならないようエスケープする
+function escapeBlockSyntax(text) {
+    return text.replaceAll(/^(\d+)([.)])(\s)/gm, '$1\\$2$3').replaceAll(/^([-+*>#|])/gm, '\\$1');
+}
+export async function lintText(text, mode) {
+    if (text.trim() === '') {
+        return [];
+    }
+    const result = await kernel.lintText(mode === 'fragment' ? escapeBlockSyntax(text) : text, {
+        ext: '.md',
+        plugins: [{ pluginId: 'markdown', plugin }],
+        rules,
+    });
+    return withoutSummary(result.messages)
+        .map(message => ({
+        ruleId: message.ruleId,
+        message: oneLine(message.message),
+        line: message.loc.start.line,
+        column: message.loc.start.column,
+    }));
+}
+//# sourceMappingURL=lint-text.js.map

package/vendor/text-rules/dist/lib/main.d.ts

@@ -0,0 +1,33 @@
+import type { TextlintKernelDescriptor } from '@textlint/kernel';
+export interface MainDependencies {
+    readonly descriptor: () => TextlintKernelDescriptor;
+    readonly readFile: (file: string) => Promise<string>;
+    readonly stdout: (text: string) => void;
+    readonly stderr: (text: string) => void;
+}
+export declare const REAL_DEPS: MainDependencies;
+export interface Arguments {
+    readonly commitMsg: boolean;
+    readonly files: readonly string[];
+}
+export declare function parseArgv(argv: readonly string[]): Arguments;
+export interface CommitMessage {
+    readonly text: string;
+    readonly subjectLine: number;
+    readonly removed: number;
+}
+export declare function prepareCommitMessage(text: string): CommitMessage;
+export declare function stripCommitComments(text: string): string;
+export interface Finding {
+    readonly ruleId: string;
+    readonly message: string;
+    readonly loc: {
+        readonly start: {
+            readonly line: number;
+            readonly column: number;
+        };
+    };
+}
+export declare function formatMessage(file: string, message: Finding): string;
+export declare function main(argv: readonly string[], dependencies: MainDependencies): Promise<number>;
+//# sourceMappingURL=main.d.ts.map

package/vendor/text-rules/dist/lib/main.js

@@ -0,0 +1,97 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { TextlintKernel } from '@textlint/kernel';
+import { BYTE_ORDER_MARK } from './byte-order-mark.js';
+import { buildDescriptor } from './descriptor.js';
+import { oneLine, withoutSummary } from './findings.js';
+export const REAL_DEPS = {
+    descriptor: buildDescriptor,
+    // eslint-disable-next-line security/detect-non-literal-fs-filename -- 引数で渡されたパスを読むのがコマンドの役割
+    readFile: async (file) => readFile(file, 'utf8'),
+    stdout: (text) => {
+        process.stdout.write(text);
+    },
+    stderr: (text) => {
+        process.stderr.write(text);
+    },
+};
+export function parseArgv(argv) {
+    return { commitMsg: argv.includes('--commit-msg'), files: argv.filter(argument => argument !== '--commit-msg') };
+}
+// `git commit -v` はこの行の下に diff を置く。
+const SCISSORS = '# ------------------------ >8 ------------------------';
+// Conventional Commits の `type(scope)` と破壊的変更の印と `:`。type と scope は文章ではなく、
+// このリポジトリでは scope に変更した nx project を `,` 区切りで並べる書式を求めるため、チェックの入力から外す。
+// 取り除くので、件名の行の列は取り除いた長さを足してファイル上の位置に戻す（空白で埋めると 4 個以上でコードブロックになる）。
+const TYPE = /^[a-z]+/;
+const SCOPE = /^\([^)]*\)/;
+const BREAKING_AND_COLON = /^!?:[ \t]*/;
+function withoutConventionalPrefix(line) {
+    const type = TYPE.exec(line)?.[0] ?? '';
+    const afterType = line.slice(type.length);
+    const afterScope = afterType.replace(SCOPE, '');
+    const suffix = BREAKING_AND_COLON.exec(afterScope);
+    return type === '' || suffix === null ? line : afterScope.slice(suffix[0].length);
+}
+export function prepareCommitMessage(text) {
+    const lines = text.split('\n');
+    const scissors = lines.findIndex(line => line.replace(/\r$/, '') === SCISSORS);
+    const kept = scissors === -1 ? lines : lines.slice(0, scissors);
+    const stripped = kept.map(line => (line.startsWith('#') ? '' : line));
+    const subject = stripped.findIndex(line => line !== '');
+    const original = stripped.find(line => line !== '') ?? '';
+    const body = withoutConventionalPrefix(original);
+    const prepared = stripped.map((line, index) => (index === subject ? body : line)).join('\n');
+    return { text: prepared, subjectLine: subject + 1, removed: original.length - body.length };
+}
+export function stripCommitComments(text) {
+    return prepareCommitMessage(text).text;
+}
+export function formatMessage(file, message) {
+    return `${file}:${String(message.loc.start.line)}:${String(message.loc.start.column)} ${message.ruleId} ${oneLine(message.message)}`;
+}
+const PLUGIN_ERROR = 'plugin-error';
+// 違反があれば 1、無ければ 0、読み込みや解析の失敗は 2 を返す。
+export async function main(argv, dependencies) {
+    let violations = 0;
+    let current = '';
+    try {
+        const { commitMsg, files } = parseArgv(argv);
+        const descriptor = dependencies.descriptor();
+        const kernel = new TextlintKernel();
+        for (const file of files) {
+            current = file;
+            const extension = commitMsg ? '.md' : path.extname(file);
+            if (descriptor.findPluginDescriptorWithExt(extension) === undefined) {
+                continue;
+            }
+            // kernel は本文の BOM を落として数えるので、plugin にも同じ本文を渡して位置をそろえる。
+            const original = await dependencies.readFile(file);
+            const text = original.replace(BYTE_ORDER_MARK, '');
+            const prepared = commitMsg ? prepareCommitMessage(text) : { text, subjectLine: 0, removed: 0 };
+            const result = await kernel.lintText(prepared.text, {
+                ext: extension,
+                filePath: file,
+                ...descriptor.toKernelOptions(),
+            });
+            // kernel は plugin の例外を message に変えて正常終了するので、違反ではなく実行失敗として扱う。
+            const failure = result.messages.find(found => found.ruleId === PLUGIN_ERROR);
+            if (failure !== undefined) {
+                throw new Error(oneLine(failure.message));
+            }
+            for (const message of withoutSummary(result.messages)) {
+                const shift = message.loc.start.line === prepared.subjectLine ? prepared.removed : 0;
+                const located = { ...message, loc: { start: { line: message.loc.start.line, column: message.loc.start.column + shift } } };
+                dependencies.stdout(`${formatMessage(file, located)}\n`);
+                violations += 1;
+            }
+        }
+        return violations === 0 ? 0 : 1;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        dependencies.stderr(current === '' ? `pecot-text-lint: ${reason}\n` : `pecot-text-lint: ${current}: ${reason}\n`);
+        return 2;
+    }
+}
+//# sourceMappingURL=main.js.map

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

@@ -0,0 +1,31 @@
+import type { TextlintPluginCreator, TextlintPluginPreProcessResult } from '@textlint/types';
+type DocumentResult = Exclude<TextlintPluginPreProcessResult, {
+    readonly ast: unknown;
+}>;
+type Paragraph = Extract<DocumentResult['children'][number], {
+    readonly type: 'Paragraph';
+}>;
+type Phrasing = Paragraph['children'][number];
+export type StringNode = Extract<Phrasing, {
+    readonly type: 'Str';
+}>;
+export type CodeNode = Extract<Phrasing, {
+    readonly type: 'Code';
+}>;
+type HtmlNode = Extract<Phrasing, {
+    readonly type: 'Html';
+}>;
+type LinkNode = Extract<Phrasing, {
+    readonly type: 'Link';
+}>;
+export type InlineNode = StringNode | CodeNode | HtmlNode | LinkNode;
+export declare function documentOf(result: Readonly<TextlintPluginPreProcessResult>): DocumentResult;
+export interface Position {
+    readonly line: number;
+    readonly column: number;
+}
+export declare function splitString(node: StringNode): readonly InlineNode[];
+export declare function listMarkerLength(line: string): number | undefined;
+export declare function withInlineSpansPlugin(creator: Readonly<TextlintPluginCreator>): TextlintPluginCreator;
+export {};
+//# sourceMappingURL=inline-spans.d.ts.map

package/vendor/text-rules/dist/lib/plugins/inline-spans.js

@@ -0,0 +1,200 @@
+// 変換後の text を返す形式の plugin もあるので、Document だけを取り出す。
+export function documentOf(result) {
+    return 'ast' in result ? result.ast : result;
+}
+const BACKTICKS = /`+/y;
+const ANY_BACKTICKS = /`+/g;
+// CommonMark のインライン HTML のうち、コメントと開始・終了タグ。属性は `<` と `>` を含まない範囲を 1 まとまりで読む。
+const HTML_COMMENT = /<!--[\s\S]*?-->/y;
+const AUTOLINK = /<https?:\/\/[^\s<>]+>/y;
+const URL_START = /https?:\/\//y;
+const TRAILING_MARK = /^[!"'*,.:;?_~。、，．」』）】！？]$/;
+const HTML_TAG = /<\/?[a-z][\da-z-]*(?=[\s/>])[^<>]*>/iy;
+function isTrailing(url) {
+    const last = url.slice(-1);
+    return TRAILING_MARK.test(last) || (last === ')' && url.split(')').length > url.split('(').length);
+}
+// 素の URL は、空白か `<` までを読み、末尾の句読点と、対応する `(` の無い `)` を含めない（GFM の autolink literal に倣う）。
+function urlStep(raw, index) {
+    URL_START.lastIndex = index;
+    const scheme = URL_START.exec(raw)?.[0];
+    if (scheme === undefined) {
+        return { next: index + 1 };
+    }
+    const stop = raw.slice(index).search(/[\s<]/);
+    const limit = stop === -1 ? raw.length : index + stop;
+    let end = limit;
+    while (end > index + scheme.length && isTrailing(raw.slice(index, end))) {
+        end -= 1;
+    }
+    return end === index + scheme.length ? { next: limit } : { next: end, span: { kind: 'Link', start: index, end, width: 0 } };
+}
+// 同じ数のバッククォートで閉じる区間（CommonMark の code span）。閉じないバッククォートは文字として読み飛ばす。
+function codeStep(raw, index) {
+    BACKTICKS.lastIndex = index;
+    const opener = BACKTICKS.exec(raw)?.[0] ?? '`';
+    const from = index + opener.length;
+    ANY_BACKTICKS.lastIndex = from;
+    for (let run = ANY_BACKTICKS.exec(raw); run !== null; run = ANY_BACKTICKS.exec(raw)) {
+        if (run[0].length === opener.length) {
+            const end = run.index + run[0].length;
+            return { next: end, span: { kind: 'Code', start: index, end, width: opener.length } };
+        }
+    }
+    return { next: from };
+}
+function htmlStep(raw, index) {
+    AUTOLINK.lastIndex = index;
+    const autolink = AUTOLINK.exec(raw)?.[0];
+    if (autolink !== undefined) {
+        return { next: index + autolink.length, span: { kind: 'Link', start: index, end: index + autolink.length, width: 1 } };
+    }
+    const [comment, tag] = [HTML_COMMENT, HTML_TAG].map((pattern) => {
+        pattern.lastIndex = index;
+        return pattern.exec(raw)?.[0];
+    });
+    const matched = comment ?? tag;
+    return matched === undefined
+        ? { next: index + 1 }
+        : { next: index + matched.length, span: { kind: 'Html', start: index, end: index + matched.length, width: 0 } };
+}
+function stepAt(raw, index) {
+    const char = raw.charAt(index);
+    if (char === '`') {
+        return codeStep(raw, index);
+    }
+    if (char === '<') {
+        return htmlStep(raw, index);
+    }
+    return char === 'h' ? urlStep(raw, index) : { next: index + 1 };
+}
+// Markdown と同じく、Code（バッククォート）と Html（コメントと開始・終了タグ）の区間を左から順に返す。
+function inlineSpansOf(raw) {
+    const spans = [];
+    let index = 0;
+    while (index < raw.length) {
+        const step = stepAt(raw, index);
+        if (step.span !== undefined) {
+            spans.push(step.span);
+        }
+        index = step.next;
+    }
+    return spans;
+}
+// Str の raw 内のオフセットを、元ファイルの位置にする。raw は元ファイルの切り出しなので、改行は raw を数える。
+function positionAt(node, offset) {
+    const before = node.raw.slice(0, offset);
+    const lastBreak = before.lastIndexOf('\n');
+    return lastBreak === -1
+        ? { line: node.loc.start.line, column: node.loc.start.column + offset }
+        : { line: node.loc.start.line + before.split('\n').length - 1, column: offset - lastBreak - 1 };
+}
+function pieceOf(node, start, end) {
+    const raw = node.raw.slice(start, end);
+    return {
+        type: 'Str',
+        value: raw,
+        raw,
+        range: [node.range[0] + start, node.range[0] + end],
+        loc: { start: positionAt(node, start), end: positionAt(node, end) },
+    };
+}
+function inlineOf(node, span) {
+    const piece = pieceOf(node, span.start, span.end);
+    const inner = piece.raw.slice(span.width, piece.raw.length - span.width);
+    if (span.kind === 'Html') {
+        return { ...piece, type: 'Html' };
+    }
+    if (span.kind === 'Code') {
+        return { ...piece, type: 'Code', value: inner };
+    }
+    // Markdown の autolink と同じく、子は URL そのものの Str で、url 属性に URL を入れる。
+    const { type: _type, value: _value, ...position } = piece;
+    return { ...position, type: 'Link', url: inner, children: [pieceOf(node, span.start + span.width, span.end - span.width)] };
+}
+// Str を、Code・Html・Link の前後の Str と、Code・Html・Link に分ける。value と raw がずれる Str は位置を保てないので分けない。
+export function splitString(node) {
+    const spans = node.value === node.raw ? inlineSpansOf(node.raw) : [];
+    const pieces = [];
+    let cursor = 0;
+    for (const span of spans) {
+        if (span.start > cursor) {
+            pieces.push(pieceOf(node, cursor, span.start));
+        }
+        pieces.push(inlineOf(node, span));
+        cursor = span.end;
+    }
+    if (spans.length === 0) {
+        return [node];
+    }
+    return cursor < node.raw.length ? [...pieces, pieceOf(node, cursor, node.raw.length)] : pieces;
+}
+// 行頭のリストの記号（`- ` `* ` `+ ` `1. ` `1) `）と、その後ろの空白の長さ。記号が無ければ undefined。
+const LIST_MARKER = /^(?:[-*+]|\d{1,9}[.)])[\t ]+(?=\S)/;
+export function listMarkerLength(line) {
+    return LIST_MARKER.exec(line)?.[0].length;
+}
+function withoutMarker(node) {
+    const length = node.value === node.raw ? listMarkerLength(node.raw) : undefined;
+    return length === undefined ? undefined : pieceOf(node, length, node.raw.length);
+}
+function paragraphOf(paragraph, children) {
+    const first = children.at(0) ?? paragraph;
+    const last = children.at(-1) ?? paragraph;
+    return {
+        ...paragraph,
+        children,
+        raw: children.map(child => child.raw).join(''),
+        range: [first.range[0], last.range[1]],
+        loc: { start: first.loc.start, end: last.loc.end },
+    };
+}
+// リストの記号で始まる行の前で Paragraph を分け、記号を Str から除く。
+// 記号の無い続きの行は、直前の項目の段落に残す（Markdown の lazy continuation）。
+function splitLists(paragraph) {
+    const groups = [[]];
+    let isChanged = false;
+    for (const child of paragraph.children) {
+        const stripped = child.type === 'Str' ? withoutMarker(child) : undefined;
+        const current = groups.at(-1) ?? [];
+        if (stripped === undefined) {
+            current.push(child);
+        }
+        else {
+            isChanged = true;
+            if (current.at(-1)?.type === 'Break') {
+                current.pop();
+            }
+            groups.push([stripped]);
+        }
+    }
+    return isChanged ? groups.filter(group => group.length > 0).map(group => paragraphOf(paragraph, group)) : [paragraph];
+}
+function splitParagraph(paragraph) {
+    return { ...paragraph, children: paragraph.children.flatMap((child) => (child.type === 'Str' ? [...splitString(child)] : [child])) };
+}
+function withInlineSpans(document) {
+    return { ...document, children: document.children.flatMap((child) => (child.type === 'Paragraph' ? splitLists(child).map(paragraph => splitParagraph(paragraph)) : [child])) };
+}
+// plugin の Document の Paragraph に、Code への分割を後処理として掛ける。
+export function withInlineSpansPlugin(creator) {
+    class CodeSpanProcessor {
+        inner = new creator.Processor();
+        availableExtensions() {
+            return this.inner.availableExtensions();
+        }
+        processor(extension) {
+            const base = this.inner.processor(extension);
+            return {
+                async preProcess(text, filePath) {
+                    return withInlineSpans(documentOf(await base.preProcess(text, filePath)));
+                },
+                postProcess(messages, filePath) {
+                    return base.postProcess(messages, filePath);
+                },
+            };
+        }
+    }
+    return { Processor: CodeSpanProcessor };
+}
+//# sourceMappingURL=inline-spans.js.map

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

@@ -0,0 +1,5 @@
+import type { TextlintPluginCreator } from '@textlint/types';
+export declare function loadPlugin(name: string): TextlintPluginCreator;
+export declare function loadMarkdownPlugin(): TextlintPluginCreator;
+export declare function loadCommentsPlugin(): TextlintPluginCreator;
+//# sourceMappingURL=load.d.ts.map

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

@@ -0,0 +1,24 @@
+import { createRequire } from 'node:module';
+import { moduleInterop } from '@textlint/module-interop';
+import { withInlineSpansPlugin } from './inline-spans.js';
+// plugin には CJS だけのものと、ESM と CJS の両方を持つものがある。
+// textlint 自身の config-loader と同じく、同期で読み、moduleInterop で exports.default を剥がし、形を確認してから使う。
+const load = createRequire(import.meta.url);
+function isPluginCreator(value) {
+    return typeof value === 'object' && value !== null && 'Processor' in value;
+}
+export function loadPlugin(name) {
+    const raw = load(name);
+    const plugin = moduleInterop(raw);
+    if (!isPluginCreator(plugin)) {
+        throw new TypeError(`${name} は Processor を持つ plugin ではありません`);
+    }
+    return plugin;
+}
+export function loadMarkdownPlugin() {
+    return loadPlugin('@textlint/textlint-plugin-markdown');
+}
+export function loadCommentsPlugin() {
+    return withInlineSpansPlugin(loadPlugin('@cffnpwr/textlint-plugin-comments'));
+}
+//# sourceMappingURL=load.js.map

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

@@ -0,0 +1,18 @@
+export interface Segment {
+    readonly start: number;
+    readonly end: number;
+    readonly holes?: readonly Segment[];
+    readonly blockComment?: boolean;
+    readonly hasEscapes?: boolean;
+}
+export type Scanner = (text: string) => readonly Segment[] | Promise<readonly Segment[]>;
+export declare function pythonStrings(text: string): readonly Segment[];
+export declare function jsonStrings(text: string): readonly Segment[];
+export declare function shellStrings(text: string): readonly Segment[];
+export declare function yamlStrings(text: string): readonly Segment[];
+export interface Frontmatter {
+    readonly values: readonly Segment[];
+    readonly rest: Segment;
+}
+export declare function frontmatterOf(text: string, segment: Segment): Frontmatter | undefined;
+//# sourceMappingURL=scan.d.ts.map