@pecot/visual-mcp 0.0.0-stage → 1.0.0

package/assets/slidev/scripts/eslint/_shared/dist/lib/drawio-geometry.js

@@ -0,0 +1,382 @@
+/**
+ * draw.io（.drawio）XML の幾何を、描画結果を見ずに XML だけから求める純関数群。
+ *
+ * - セル解決: セル ID → 図座標の絶対矩形（入れ子 parent の offset を加算）。
+ * - 外接矩形: 表示される vertex の矩形（枠線の半幅を含む）と edge の経由点の和。
+ * - フィットモデル: diagrams.net viewer が図をパネルへ収める規則を再現する。
+ *   viewer は LDrawioDiagramBare の srcdoc 設定 border: 20 で動く。
+ *   図座標を、パネル座標へ写す。
+ *
+ * フィット規則（viewer-static.min.js の描画を計測して確定）:
+ * - 図座標 x はキャンバス座標 x + tx に置かれる。tx = floor(20 - minX)。
+ * - キャンバス幅 = ceil(maxX + tx + 40)（外接矩形が整数なら W + 60）。高さも同様。
+ * - 各図形は線幅 max(1, round(strokeWidth)) が奇数のとき (0.5, 0.5) ずれて描かれる。
+ * - s = min(1, パネル幅 / キャンバス幅, パネル高 / キャンバス高)。キャンバスはパネル中央。
+ * - 描画上の外接矩形は、枠線のある vertex で線幅の半分だけ広がる。
+ *   edge の経由点では線幅だけ広がる（枠線なしは半分。shape=flexArrow は 0）。
+ *   矢じり・影・図形からはみ出すラベルによる広がりは扱わない。
+ *   （図の外周に置かなければ影響しない）。
+ *
+ * DOMParser に依存しない。
+ * アルゴリズムはテーマ側のレイアウトの実行時が使う実装と同じ結果を返す（同値テストで固定している）。
+ * 非対応の図・解決できないセルは DrawioGeometryError（code 付き）を投げる。
+ */
+/** srcdoc の viewer 設定 border。図の原点を置くキャンバス上の位置 */
+export const VIEWER_BORDER = 20;
+/**
+ * 縮小なしで描ける外接矩形（線幅を含む）の上限。
+ * パネルの寸法はテーマの宣言（drawio.panels）が持つ。
+ * fitDiagram の式に合わせ、キャンバスは外接矩形の左に tx（= VIEWER_BORDER）を足す。
+ * 右には VIEWER_BORDER × 2 を足す。
+ * そのためパネルから、3 × VIEWER_BORDER = 60 を引く。
+ */
+export function maxDiagramBounds(panel) {
+    const margin = VIEWER_BORDER * 3;
+    return { width: panel.width - margin, height: panel.height - margin };
+}
+export class DrawioGeometryError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'DrawioGeometryError';
+        this.code = code;
+    }
+}
+const ENTITY_RE = /&(?:#(\d+)|#x([0-9A-Fa-f]+)|(lt|gt|amp|quot|apos));/g;
+const NAMED_ENTITIES = { lt: '<', gt: '>', amp: '&', quot: '"', apos: "'" };
+function decodeEntities(text) {
+    return text.replace(ENTITY_RE, (_match, dec, hex, name) => {
+        if (dec)
+            return String.fromCodePoint(Number(dec));
+        if (hex)
+            return String.fromCodePoint(parseInt(hex, 16));
+        return NAMED_ENTITIES[name];
+    });
+}
+const ATTR_RE = /([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+function parseAttrs(source) {
+    const attrs = {};
+    ATTR_RE.lastIndex = 0;
+    let m;
+    while ((m = ATTR_RE.exec(source)) !== null) {
+        attrs[m[1]] = decodeEntities(m[2] ?? m[3] ?? '');
+    }
+    return attrs;
+}
+function num(value, fallback = 0) {
+    if (value === undefined || value === '')
+        return fallback;
+    const n = Number(value);
+    return Number.isFinite(n) ? n : fallback;
+}
+function point(attrs) {
+    return { x: num(attrs.x), y: num(attrs.y) };
+}
+/** style 文字列（"text;html=1;strokeColor=none;"）を名前付きスタイルとキー値に分ける */
+function parseStyle(style) {
+    const names = [];
+    const values = {};
+    for (const token of (style ?? '').split(';')) {
+        if (!token)
+            continue;
+        const eq = token.indexOf('=');
+        if (eq < 0)
+            names.push(token);
+        else
+            values[token.slice(0, eq)] = token.slice(eq + 1);
+    }
+    return { names, values };
+}
+// デフォルトで枠線を描かない名前付きスタイル・shape（draw.io のデフォルトスタイルシート）
+const STROKELESS_STYLES = new Set(['text', 'image', 'label', 'edgeLabel', 'group']);
+function strokeOf(style) {
+    const { names, values } = parseStyle(style);
+    const width = num(values.strokeWidth, 1);
+    let stroked;
+    if (values.strokeColor !== undefined)
+        stroked = values.strokeColor !== 'none';
+    else
+        stroked = !names.some((n) => STROKELESS_STYLES.has(n)) && !STROKELESS_STYLES.has(values.shape);
+    return { width, stroked };
+}
+/** mxShape の画素格子合わせ。線幅（枠線の有無によらない）が奇数なら 0.5 */
+function crispOffsetOf(strokeWidth) {
+    return Math.max(1, Math.round(strokeWidth)) % 2 === 1 ? 0.5 : 0;
+}
+const TAG_RE = /<(\/?)([A-Za-z_][\w:.-]*)((?:\s+[^\s=/>]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>/g;
+/**
+ * XML 文字列を mxCell の一覧に分解する。
+ */
+function scanCells(xml) {
+    if (typeof xml !== 'string' || xml.trim() === '') {
+        throw new DrawioGeometryError('empty-xml', 'draw.io の XML が空です');
+    }
+    const source = xml.replace(/<!--[\s\S]*?-->/g, '');
+    const cells = [];
+    let diagramCount = 0;
+    let modelCount = 0;
+    const stack = []; // 開いている要素。diagram 直下に要素が無い（= 圧縮）かの判定に使う
+    let current = null; // 開いている mxCell
+    let geometry = null; // 開いている mxGeometry
+    let inPoints = false; // <Array as="points"> の中
+    TAG_RE.lastIndex = 0;
+    let lastIndex = 0;
+    let m;
+    while ((m = TAG_RE.exec(source)) !== null) {
+        const [whole, closing, name, attrSource, selfClosing] = m;
+        const between = source.slice(lastIndex, m.index);
+        lastIndex = m.index + whole.length;
+        if (closing) {
+            const top = stack.pop();
+            if (top?.name === 'diagram' && !top.hasChild && between.trim() !== '') {
+                throw new DrawioGeometryError('compressed', '圧縮形式の <diagram> は非対応です。draw.io の「ファイル → プロパティ → 圧縮」を外して保存してください');
+            }
+            if (name === 'mxCell')
+                current = null;
+            else if (name === 'mxGeometry')
+                geometry = null;
+            else if (name === 'Array')
+                inPoints = false;
+            continue;
+        }
+        const parent = stack[stack.length - 1];
+        if (parent)
+            parent.hasChild = true;
+        if (name === 'object' || name === 'UserObject') {
+            throw new DrawioGeometryError('wrapped-cell', `<${name}> で包んだセルは非対応です（セルにプロパティやリンクを付けると生成されます）。プロパティを外した mxCell にしてください`);
+        }
+        if (name === 'diagram') {
+            diagramCount += 1;
+            if (diagramCount > 1) {
+                throw new DrawioGeometryError('multi-page', '複数ページの draw.io ファイルは非対応です。1 ページだけのファイルにしてください');
+            }
+        }
+        if (name === 'mxGraphModel')
+            modelCount += 1;
+        const attrs = parseAttrs(attrSource);
+        if (name === 'mxCell') {
+            const cell = {
+                id: attrs.id,
+                parent: attrs.parent ?? null,
+                vertex: attrs.vertex === '1',
+                edge: attrs.edge === '1',
+                visible: attrs.visible !== '0',
+                source: attrs.source ?? null,
+                target: attrs.target ?? null,
+                style: attrs.style ?? '',
+                geometry: null
+            };
+            cells.push(cell);
+            if (!selfClosing)
+                current = cell;
+        }
+        else if (name === 'mxGeometry' && current) {
+            const g = {
+                x: num(attrs.x),
+                y: num(attrs.y),
+                width: num(attrs.width),
+                height: num(attrs.height),
+                relative: attrs.relative === '1',
+                sourcePoint: null,
+                targetPoint: null,
+                points: []
+            };
+            current.geometry = g;
+            if (!selfClosing)
+                geometry = g;
+        }
+        else if (name === 'Array' && geometry && attrs.as === 'points') {
+            if (!selfClosing)
+                inPoints = true;
+        }
+        else if (name === 'mxPoint' && geometry) {
+            if (inPoints)
+                geometry.points.push(point(attrs));
+            else if (attrs.as === 'sourcePoint')
+                geometry.sourcePoint = point(attrs);
+            else if (attrs.as === 'targetPoint')
+                geometry.targetPoint = point(attrs);
+        }
+        if (!selfClosing)
+            stack.push({ name, hasChild: false });
+    }
+    if (modelCount === 0) {
+        throw new DrawioGeometryError('no-model', 'draw.io の XML に <mxGraphModel> がありません');
+    }
+    return cells;
+}
+/**
+ * draw.io XML を解析する。
+ * bounds は図形の geometry だけの外接矩形、visualBounds は枠線の半幅を含めた描画上の外接矩形。
+ */
+export function parseDrawio(xml) {
+    const cells = scanCells(xml);
+    const byId = new Map();
+    for (const cell of cells) {
+        if (cell.id !== undefined)
+            byId.set(cell.id, cell);
+    }
+    const isRoot = (cell) => !cell.parent || !byId.has(cell.parent);
+    const isLayer = (cell) => !isRoot(cell) && isRoot(byId.get(cell.parent));
+    // 祖先のどれかが visible="0" なら描画されない（レイヤ・グループの非表示を含む）
+    function isHidden(cell) {
+        for (let c = cell, depth = 0; c && depth < 1000; c = c.parent === null ? undefined : byId.get(c.parent), depth += 1) {
+            if (!c.visible)
+                return true;
+        }
+        return false;
+    }
+    // cell の子が使う座標系の原点（図座標）。座標を持たない親（edge・相対配置）なら null
+    function childOrigin(cell, depth = 0) {
+        if (depth > 1000)
+            return null;
+        if (isRoot(cell) || isLayer(cell))
+            return { x: 0, y: 0 };
+        if (!cell.vertex || !cell.geometry || cell.geometry.relative)
+            return null;
+        const base = childOrigin(byId.get(cell.parent), depth + 1);
+        if (!base)
+            return null;
+        return { x: base.x + cell.geometry.x, y: base.y + cell.geometry.y };
+    }
+    function originOf(cell) {
+        const parent = cell.parent === null ? undefined : byId.get(cell.parent);
+        return parent ? childOrigin(parent) : { x: 0, y: 0 };
+    }
+    /** vertex の絶対矩形。描画されない・座標を決められない vertex は null */
+    function vertexRect(cell) {
+        if (!cell.vertex || !cell.geometry || cell.geometry.relative || isHidden(cell))
+            return null;
+        const origin = originOf(cell);
+        if (!origin)
+            return null;
+        return {
+            x: origin.x + cell.geometry.x,
+            y: origin.y + cell.geometry.y,
+            width: cell.geometry.width,
+            height: cell.geometry.height
+        };
+    }
+    /** edge の経由点（図座標）。端点の座標は接続先が無いときだけ描画に使われる */
+    function edgePoints(cell) {
+        if (!cell.edge || !cell.geometry || isHidden(cell))
+            return [];
+        const origin = originOf(cell);
+        if (!origin)
+            return [];
+        const g = cell.geometry;
+        const pts = [...g.points];
+        if (g.sourcePoint && !cell.source)
+            pts.push(g.sourcePoint);
+        if (g.targetPoint && !cell.target)
+            pts.push(g.targetPoint);
+        return pts.map((p) => ({ x: origin.x + p.x, y: origin.y + p.y }));
+    }
+    const geo = { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };
+    const vis = { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };
+    const extend = (acc, x0, y0, x1, y1) => {
+        acc.minX = Math.min(acc.minX, x0);
+        acc.minY = Math.min(acc.minY, y0);
+        acc.maxX = Math.max(acc.maxX, x1);
+        acc.maxY = Math.max(acc.maxY, y1);
+    };
+    for (const cell of cells) {
+        const rect = vertexRect(cell);
+        if (rect) {
+            extend(geo, rect.x, rect.y, rect.x + rect.width, rect.y + rect.height);
+            const { width, stroked } = strokeOf(cell.style);
+            const half = stroked ? width / 2 : 0;
+            extend(vis, rect.x - half, rect.y - half, rect.x + rect.width + half, rect.y + rect.height + half);
+        }
+        const points = edgePoints(cell);
+        if (points.length > 0) {
+            // 線の描画上の広がり（計測: 枠線あり ±線幅、なし ±線幅/2、さらに格子合わせ分だけ
+            // 右下へずれる）。shape=flexArrow は先端が終点ちょうどで広がらない（計測）。
+            // 矢じり・flexArrow の胴の太さによる広がりは扱わない
+            const { width, stroked } = strokeOf(cell.style);
+            const flexArrow = parseStyle(cell.style).values.shape === 'flexArrow';
+            const grow = flexArrow ? 0 : stroked ? width : width / 2;
+            const crisp = flexArrow ? 0 : crispOffsetOf(width);
+            for (const p of points) {
+                extend(geo, p.x, p.y, p.x, p.y);
+                extend(vis, p.x - grow + crisp, p.y - grow + crisp, p.x + grow + crisp, p.y + grow + crisp);
+            }
+        }
+    }
+    const toRect = (acc) => Number.isFinite(acc.minX)
+        ? { x: acc.minX, y: acc.minY, width: acc.maxX - acc.minX, height: acc.maxY - acc.minY }
+        : null;
+    return { byId, bounds: toRect(geo), visualBounds: toRect(vis), isHidden, vertexRect };
+}
+/**
+ * セル ID から vertex の絶対矩形（図座標）と描画時の格子合わせ量を返す。
+ */
+export function resolveCellRect(model, cellId) {
+    const cell = model.byId.get(cellId);
+    if (!cell) {
+        throw new DrawioGeometryError('unknown-cell', `セル "${cellId}" が図にありません`);
+    }
+    if (cell.edge) {
+        throw new DrawioGeometryError('edge-cell', `セル "${cellId}" は線（edge）です。マーカーは図形（vertex）の ID を指定してください`);
+    }
+    if (!cell.vertex) {
+        throw new DrawioGeometryError('not-vertex', `セル "${cellId}" はレイヤ等の図形でないセルです。図形（vertex）の ID を指定してください`);
+    }
+    if (model.isHidden(cell)) {
+        throw new DrawioGeometryError('hidden-cell', `セル "${cellId}" は非表示（visible="0"）です`);
+    }
+    const rect = model.vertexRect(cell);
+    if (!rect) {
+        throw new DrawioGeometryError('relative-cell', `セル "${cellId}" は親に対する相対配置（relative="1"）のため位置を決められません`);
+    }
+    return { ...rect, crisp: crispOffsetOf(strokeOf(cell.style).width) };
+}
+const EPS = 1e-6;
+/**
+ * viewer のフィット規則で、描画上の外接矩形をパネルへ収める変換を求める。
+ */
+export function fitDiagram(visualBounds, panel) {
+    const tx = Math.floor(VIEWER_BORDER - visualBounds.x + EPS);
+    const ty = Math.floor(VIEWER_BORDER - visualBounds.y + EPS);
+    const canvasWidth = Math.ceil(visualBounds.x + visualBounds.width + tx + VIEWER_BORDER * 2 - EPS);
+    const canvasHeight = Math.ceil(visualBounds.y + visualBounds.height + ty + VIEWER_BORDER * 2 - EPS);
+    const scale = Math.min(1, panel.width / canvasWidth, panel.height / canvasHeight);
+    return {
+        tx,
+        ty,
+        scale,
+        canvasWidth,
+        canvasHeight,
+        // キャンバス左上のパネル座標
+        offsetX: (panel.width - canvasWidth * scale) / 2,
+        offsetY: (panel.height - canvasHeight * scale) / 2
+    };
+}
+/**
+ * 図座標の点をパネル座標へ写す。crisp はその図形の格子合わせ量（resolveCellRect の crisp）。
+ */
+export function toPanelPoint(fit, x, y, crisp = 0) {
+    return {
+        x: fit.offsetX + (x + fit.tx + crisp) * fit.scale,
+        y: fit.offsetY + (y + fit.ty + crisp) * fit.scale
+    };
+}
+/**
+ * 事前 export SVG（原点 = 描画上の外接矩形の左上）を viewer 描画と同じ位置に置く左上と縮尺。
+ * export SVG の図形には格子合わせが掛からないため、線幅 1 の図形に合わせて 0.5 を足す。
+ * 寸法は img の natural サイズ × scale で決める（export の外接矩形は矢印等を含み得る）。
+ */
+export function staticImageOrigin(fit, visualBounds) {
+    const p = toPanelPoint(fit, visualBounds.x, visualBounds.y, 0.5);
+    return { x: p.x, y: p.y, scale: fit.scale };
+}
+/**
+ * セル中心をパネル矩形に対する百分率（0〜100）で返す。SMarkerOverlay の {px, py}。
+ */
+export function cellCenterPercent(model, cellId, panel) {
+    const rect = resolveCellRect(model, cellId);
+    // vertex を 1 つ解決できた時点で visualBounds は必ずある
+    const fit = fitDiagram(model.visualBounds, panel);
+    const center = toPanelPoint(fit, rect.x + rect.width / 2, rect.y + rect.height / 2, rect.crisp);
+    return { px: (center.x / panel.width) * 100, py: (center.y / panel.height) * 100 };
+}

package/assets/slidev/scripts/eslint/_shared/dist/lib/field-resolver.d.ts

@@ -0,0 +1,11 @@
+export interface FieldSegment {
+    type: 'prop' | 'array';
+    name: string;
+}
+export interface ResolvedField {
+    value: unknown;
+    path: string;
+}
+export declare function parseFieldPath(fieldPath: string): FieldSegment[];
+export declare function resolveFieldValues(frontmatter: Record<string, unknown>, fieldPath: string): ResolvedField[];
+//# sourceMappingURL=field-resolver.d.ts.map

package/assets/slidev/scripts/eslint/_shared/dist/lib/field-resolver.js

@@ -0,0 +1,54 @@
+export function parseFieldPath(fieldPath) {
+    if (typeof fieldPath !== 'string' || fieldPath.length === 0) {
+        return [];
+    }
+    const segments = [];
+    const parts = fieldPath.split('.');
+    for (const part of parts) {
+        if (part.endsWith('[]')) {
+            const name = part.slice(0, -2);
+            if (name.length > 0) {
+                segments.push({ type: 'prop', name });
+            }
+            segments.push({ type: 'array', name: '' });
+        }
+        else {
+            segments.push({ type: 'prop', name: part });
+        }
+    }
+    return segments;
+}
+export function resolveFieldValues(frontmatter, fieldPath) {
+    const segments = parseFieldPath(fieldPath);
+    if (segments.length === 0) {
+        return [];
+    }
+    return resolve([{ value: frontmatter, path: '' }], segments, 0);
+}
+function resolve(current, segments, index) {
+    if (index >= segments.length) {
+        return current;
+    }
+    const segment = segments[index];
+    const next = [];
+    for (const entry of current) {
+        if (segment.type === 'prop') {
+            if (entry.value != null && typeof entry.value === 'object' && !Array.isArray(entry.value)) {
+                const obj = entry.value;
+                if (segment.name in obj) {
+                    const newPath = entry.path ? `${entry.path}.${segment.name}` : segment.name;
+                    next.push({ value: obj[segment.name], path: newPath });
+                }
+            }
+        }
+        else if (segment.type === 'array') {
+            if (Array.isArray(entry.value)) {
+                for (let i = 0; i < entry.value.length; i++) {
+                    const newPath = `${entry.path}[${i}]`;
+                    next.push({ value: entry.value[i], path: newPath });
+                }
+            }
+        }
+    }
+    return resolve(next, segments, index + 1);
+}

package/assets/slidev/scripts/eslint/_shared/dist/lib/frontmatter-parser.d.ts

@@ -0,0 +1,7 @@
+export declare function extractFrontmatterText(text: string): string | null;
+export declare function parseFrontmatter(text: string): unknown;
+export type FrontmatterBase = {
+    layout?: string;
+    [k: string]: unknown;
+};
+//# sourceMappingURL=frontmatter-parser.d.ts.map

package/assets/slidev/scripts/eslint/_shared/dist/lib/frontmatter-parser.js

@@ -0,0 +1,34 @@
+import yaml from 'js-yaml';
+const SEPARATOR_REGEX = /^---\s*$/;
+export function extractFrontmatterText(text) {
+    if (typeof text !== 'string' || text.length === 0) {
+        return null;
+    }
+    const lines = text.split('\n');
+    if (!SEPARATOR_REGEX.test(lines[0])) {
+        return null;
+    }
+    for (let i = 1; i < lines.length; i++) {
+        if (SEPARATOR_REGEX.test(lines[i])) {
+            const yamlLines = lines.slice(1, i);
+            return yamlLines.join('\n');
+        }
+    }
+    return null;
+}
+export function parseFrontmatter(text) {
+    const yamlText = extractFrontmatterText(text);
+    if (yamlText === null) {
+        return null;
+    }
+    try {
+        const result = yaml.load(yamlText);
+        if (result === null || result === undefined || typeof result !== 'object' || Array.isArray(result)) {
+            return null;
+        }
+        return result;
+    }
+    catch {
+        return null;
+    }
+}

package/assets/slidev/scripts/eslint/_shared/dist/lib/reference-loader.d.ts

@@ -0,0 +1,37 @@
+/**
+ * directories を先頭から順に探し、`<name>.yaml` が最初に見つかったものを返す。
+ * 先に置いたディレクトリが勝つ（talk-dir 側を先に渡すと、テーマ側を上書きできる）。
+ */
+export declare function loadLayoutReference(directories: readonly string[], layoutName: string): Record<string, unknown> | null;
+export interface ClicksValidationConfig {
+    type: string;
+    source_prop?: string;
+    per_page?: number;
+    offset?: number;
+    min_clicks?: number;
+    scroll_prop?: string;
+}
+export declare function getClicksValidation(reference: Record<string, unknown> | null | undefined): ClicksValidationConfig | null;
+export interface PropSchemaNode {
+    type?: string;
+    props?: Record<string, PropSchemaNode>;
+    items?: Record<string, PropSchemaNode>;
+    sameLengthAs?: string;
+}
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function getLayoutPropTree(reference: Record<string, unknown> | null | undefined, referencesDirectories?: readonly string[]): Record<string, PropSchemaNode>;
+export declare function getLayoutProps(reference: Record<string, unknown> | null | undefined, referencesDirectories?: readonly string[]): string[];
+export interface MatchingLengthDeclaration {
+    path: string;
+    target: string;
+}
+/**
+ * prop ツリー（getLayoutPropTree の戻り値）を走査し、same_length_as が宣言された
+ * 配列 prop を (自身のパス, 対にする相手のパス) の組として集める。
+ * Object 配下（node.props）だけを辿る。配列要素スキーマ（node.items）は辿らない
+ * （宣言対象はフロントマター直下から辿れる配列 prop パスであり、配列要素内の
+ * フィールド同士を比較する用途ではないため）。
+ */
+export declare function collectMatchingLengthDeclarations(tree: Record<string, PropSchemaNode>): MatchingLengthDeclaration[];
+export declare function clearCache(): void;
+//# sourceMappingURL=reference-loader.d.ts.map

package/assets/slidev/scripts/eslint/_shared/dist/lib/reference-loader.js

@@ -0,0 +1,151 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+const referenceCache = new Map();
+function loadReferenceFile(filePath) {
+    if (referenceCache.has(filePath)) {
+        return referenceCache.get(filePath) ?? null;
+    }
+    try {
+        if (!fs.existsSync(filePath)) {
+            referenceCache.set(filePath, null);
+            return null;
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const parsed = yaml.load(content);
+        if (parsed === null || parsed === undefined || typeof parsed !== 'object') {
+            referenceCache.set(filePath, null);
+            return null;
+        }
+        referenceCache.set(filePath, parsed);
+        return parsed;
+    }
+    catch {
+        referenceCache.set(filePath, null);
+        return null;
+    }
+}
+/**
+ * directories を先頭から順に探し、`<name>.yaml` が最初に見つかったものを返す。
+ * 先に置いたディレクトリが勝つ（talk-dir 側を先に渡すと、テーマ側を上書きできる）。
+ */
+export function loadLayoutReference(directories, layoutName) {
+    for (const directory of directories) {
+        const reference = loadReferenceFile(path.join(directory, `${layoutName}.yaml`));
+        if (reference) {
+            return reference;
+        }
+    }
+    return null;
+}
+export function getClicksValidation(reference) {
+    const clicks = reference?.clicks;
+    const validation = clicks?.validation;
+    if (!validation || typeof validation !== 'object') {
+        return null;
+    }
+    if (!validation.type) {
+        return null;
+    }
+    if (validation.type !== 'required' && !validation.source_prop) {
+        return null;
+    }
+    if (validation.type === 'pagination' && !validation.per_page) {
+        return null;
+    }
+    return validation;
+}
+export function isPlainObject(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+// prototype 汚染ガード。素の bracket 代入で __proto__ 等が prototype を
+// 書き換えるのを防ぐ。walker 側 getOwn（読み取り時 hasOwnProperty ガード）と対称。
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function setOwn(map, key, value) {
+    if (DANGEROUS_KEYS.has(key)) {
+        return;
+    }
+    map[key] = value;
+}
+function toSchemaNode(entry) {
+    const node = {};
+    if (isPlainObject(entry)) {
+        if (typeof entry.type === 'string') {
+            node.type = entry.type;
+        }
+        if (isPlainObject(entry.props)) {
+            node.props = buildNodeMap(entry.props);
+        }
+        if (isPlainObject(entry.items)) {
+            node.items = buildNodeMap(entry.items);
+        }
+        if (typeof entry.same_length_as === 'string' && entry.same_length_as.length > 0) {
+            node.sameLengthAs = entry.same_length_as;
+        }
+    }
+    return node;
+}
+function buildNodeMap(propsObj) {
+    const map = {};
+    for (const key of Object.keys(propsObj)) {
+        setOwn(map, key, toSchemaNode(propsObj[key]));
+    }
+    return map;
+}
+export function getLayoutPropTree(reference, referencesDirectories = []) {
+    const tree = {};
+    const includes = reference?.includes;
+    if (Array.isArray(includes) && referencesDirectories.length > 0) {
+        for (const name of includes) {
+            if (typeof name !== 'string') {
+                continue;
+            }
+            const shared = loadLayoutReference(referencesDirectories, name);
+            const sharedProps = shared?.props;
+            if (sharedProps && typeof sharedProps === 'object') {
+                const sharedMap = sharedProps;
+                for (const key of Object.keys(sharedMap)) {
+                    setOwn(tree, key, toSchemaNode(sharedMap[key]));
+                }
+            }
+        }
+    }
+    const refProps = reference?.props;
+    if (refProps && typeof refProps === 'object') {
+        const refMap = refProps;
+        for (const key of Object.keys(refMap)) {
+            setOwn(tree, key, toSchemaNode(refMap[key]));
+        }
+    }
+    return tree;
+}
+export function getLayoutProps(reference, referencesDirectories = []) {
+    return Object.keys(getLayoutPropTree(reference, referencesDirectories));
+}
+/**
+ * prop ツリー（getLayoutPropTree の戻り値）を走査し、same_length_as が宣言された
+ * 配列 prop を (自身のパス, 対にする相手のパス) の組として集める。
+ * Object 配下（node.props）だけを辿る。配列要素スキーマ（node.items）は辿らない
+ * （宣言対象はフロントマター直下から辿れる配列 prop パスであり、配列要素内の
+ * フィールド同士を比較する用途ではないため）。
+ */
+export function collectMatchingLengthDeclarations(tree) {
+    const declarations = [];
+    walkMatchingLength(tree, '', declarations);
+    return declarations;
+}
+function walkMatchingLength(props, basePath, declarations) {
+    for (const key of Object.keys(props)) {
+        const node = props[key];
+        const path = basePath ? `${basePath}.${key}` : key;
+        if (node.sameLengthAs) {
+            declarations.push({ path, target: node.sameLengthAs });
+        }
+        if (node.props) {
+            walkMatchingLength(node.props, path, declarations);
+        }
+    }
+}
+export function clearCache() {
+    referenceCache.clear();
+}