@plebeiantech/lat.md 0.12.3-fork.2 → 0.12.3-fork.20

package/dist/src/code-refs.js

@@ -1,277 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { execFile } from 'node:child_process';
-import { join, relative } from 'node:path';
-import { toPosix, walkEntries } from './walk.js';
-/** Glob patterns used to exclude directories/files from code-ref scanning.
- *  Shared between rg args and the TS fallback's walkFiles filter. */
-const EXCLUDE_DIRS = ['lat.md', '.claude'];
-const EXCLUDE_GLOBS = ['*.md'];
-/** Walk project files for code-ref scanning. Uses walkEntries for .gitignore
- *  support, then additionally skips .md files, lat.md/, .claude/, and sub-projects. */
-export async function walkFiles(dir) {
-    const entries = await walkEntries(dir);
-    // Collect directories that contain their own lat.md/ (sub-projects)
-    const subProjects = new Set();
-    for (const e of entries) {
-        const i = e.indexOf('/lat.md/');
-        if (i !== -1)
-            subProjects.add(e.slice(0, i + 1));
-    }
-    return entries
-        .filter((e) => !e.endsWith('.md') &&
-        !e.startsWith('lat.md/') &&
-        !e.startsWith('.claude/') &&
-        ![...subProjects].some((prefix) => e.startsWith(prefix)))
-        .map((e) => join(dir, e));
-}
-/** Build a RegExp from a verbose template — whitespace is insignificant. */
-function re(flags) {
-    return (strings) => new RegExp(strings.raw[0].replace(/\s+/g, ''), flags);
-}
-// Line comment (// or #), then @lat: marker, then [[target]]
-export const LAT_REF_RE = re('gv') `
-  (?: // | # )
-  \s* @lat: \s*
-  \[\[
-    ( [^\]]+ )
-  \]\]
-`;
-/** Explicit opt-out: a standalone `lat:ignore` token anywhere on the line
- *  suppresses any @lat: match on that line. This gives an author documenting
- *  the syntax one obvious escape hatch when a match isn't inside a
- *  quoted/backticked literal (the common case handled by
- *  `isInsideQuotedSpan`). Word-boundary lookarounds (rather than `\b`, which
- *  treats `:` as a boundary on both sides already and wouldn't help) keep
- *  incidental substrings — `lat:ignore-config`, `mylat:ignore` — from
- *  suppressing a real ref on the same line, while still matching the token
- *  at the very start of a line or glued directly to a comment marker
- *  (`//lat:ignore`), since `/` isn't a word character either. */
-const LAT_IGNORE_RE = /(?<![\w])lat:ignore(?![-\w])/;
-/** Quote characters treated as delimiting a literal span: plain strings
- *  ('...' or "...") and backtick spans, which double as inline-code markers
- *  when a comment is documenting the @lat: syntax itself (e.g. `` `@lat:
- *  [[section-id]]` ``). A marker whose match falls inside such a span is an
- *  example, not a real reference, so it is not returned as a ref. */
-const QUOTE_CHARS = ['"', '`', "'"];
-/**
- * Returns true if `index` (an offset into `line`) falls inside a
- * quote-delimited span on that line. For each quote character, occurrences
- * are paired up in order (open, close, open, close, ...); if a quote
- * character appears an odd number of times on the line, it's ambiguous
- * (e.g. an apostrophe in prose) and is ignored entirely for that line rather
- * than risk hiding a real reference.
- */
-function isInsideQuotedSpan(line, index) {
-    for (const q of QUOTE_CHARS) {
-        const positions = [];
-        for (let i = 0; i < line.length; i++) {
-            if (line[i] === q && line[i - 1] !== '\\')
-                positions.push(i);
-        }
-        if (positions.length < 2 || positions.length % 2 !== 0)
-            continue;
-        for (let i = 0; i < positions.length; i += 2) {
-            if (index > positions[i] && index < positions[i + 1])
-                return true;
-        }
-    }
-    return false;
-}
-/** Filter regex matches on a single line, dropping ones that are inside a
- *  quoted/backticked literal or on a line carrying an explicit `lat:ignore`
- *  opt-out — these document the @lat: syntax rather than using it. */
-function extractRefsFromLine(line) {
-    if (LAT_IGNORE_RE.test(line))
-        return [];
-    const targets = [];
-    LAT_REF_RE.lastIndex = 0;
-    let match;
-    while ((match = LAT_REF_RE.exec(line)) !== null) {
-        if (!isInsideQuotedSpan(line, match.index)) {
-            targets.push(match[1]);
-        }
-    }
-    return targets;
-}
-/**
- * Run an external command and return stdout, or null if the command is not found
- * or fails.
- */
-function tryExec(cmd, args, cwd) {
-    return new Promise((resolve) => {
-        execFile(cmd, args, { cwd, maxBuffer: 50 * 1024 * 1024 }, (err, out) => {
-            if (err) {
-                // Exit code 1 with no stderr typically means "no matches" for grep/rg
-                const exitCode = err.code;
-                if (exitCode === 'ENOENT') {
-                    resolve(null); // command not found
-                    return;
-                }
-                // rg/grep exit 1 = no matches (not an error)
-                if ('status' in err &&
-                    err.status === 1 &&
-                    out === '') {
-                    resolve('');
-                    return;
-                }
-                resolve(null);
-                return;
-            }
-            resolve(out);
-        });
-    });
-}
-/**
- * Detect sub-projects (directories containing their own lat.md/) using
- * rg --files. Finds files inside nested lat.md/ dirs and extracts the parent
- * directory paths. Returns paths relative to projectRoot.
- */
-async function findSubProjects(projectRoot) {
-    // List files inside any lat.md/ dir, then extract unique parent paths.
-    // The root lat.md/ is excluded by EXCLUDE_DIRS in the caller, so we only
-    // need to find nested ones here — search for files under */lat.md/.
-    const out = await tryExec('rg', ['--files', '--glob', '**/lat.md/**', '.'], projectRoot);
-    if (!out)
-        return [];
-    const subProjects = new Set();
-    for (const rawLine of out.split('\n')) {
-        if (!rawLine)
-            continue;
-        // rg emits native separators on Windows; normalize before matching '/lat.md/'.
-        const line = toPosix(rawLine);
-        const clean = line.startsWith('./') ? line.slice(2) : line;
-        // "tests/cases/foo/lat.md/specs.md" → "tests/cases/foo"
-        // Skip root lat.md/ (no parent prefix — starts with "lat.md/")
-        const idx = clean.indexOf('/lat.md/');
-        if (idx !== -1)
-            subProjects.add(clean.slice(0, idx));
-    }
-    return [...subProjects];
-}
-/** Build rg glob exclusion args. */
-function rgExcludeArgs(subProjects) {
-    const args = [];
-    for (const dir of EXCLUDE_DIRS)
-        args.push('--glob', `!${dir}/`);
-    for (const glob of EXCLUDE_GLOBS)
-        args.push('--glob', `!${glob}`);
-    for (const sp of subProjects)
-        args.push('--glob', `!${sp}/`);
-    return args;
-}
-/**
- * Try scanning with ripgrep. Returns parsed refs and scanned file list, or null
- * if rg is not available. rg respects .gitignore by default; we add glob
- * exclusions for lat.md/, .claude/, *.md files, and sub-projects.
- */
-async function tryRipgrep(projectRoot) {
-    // Detect sub-projects first so we can exclude them from all rg calls
-    const subProjects = await findSubProjects(projectRoot);
-    const excludes = rgExcludeArgs(subProjects);
-    // Search for @lat refs
-    const searchArgs = [
-        '--no-heading',
-        '--line-number',
-        '--with-filename',
-        ...excludes,
-        '@lat:.*\\[\\[',
-        '.',
-    ];
-    const out = await tryExec('rg', searchArgs, projectRoot);
-    if (out === null)
-        return null;
-    const { refs } = parseGrepOutput(out);
-    // List all scanned files (for stats) — rg --files is fast
-    const filesOut = await tryExec('rg', ['--files', ...excludes, '.'], projectRoot);
-    const files = (filesOut || '')
-        .split('\n')
-        .filter(Boolean)
-        .map((f) => {
-        const clean = toPosix(f).replace(/^\.\//, '');
-        return join(projectRoot, clean);
-    });
-    return { refs, files };
-}
-/**
- * Parse rg output lines (file:line:content) into CodeRef entries.
- */
-function parseGrepOutput(output) {
-    const refs = [];
-    if (!output.trim())
-        return { refs };
-    for (const line of output.split('\n')) {
-        if (!line)
-            continue;
-        // Format: ./path/to/file:linenum:content
-        const firstColon = line.indexOf(':');
-        if (firstColon === -1)
-            continue;
-        const secondColon = line.indexOf(':', firstColon + 1);
-        if (secondColon === -1)
-            continue;
-        // rg emits native separators (`\` on Windows); normalize to POSIX so the
-        // stored path matches wiki-link and TS-fallback conventions. This also
-        // turns a Windows `.\` prefix into `./` for the strip below.
-        let filePath = toPosix(line.slice(0, firstColon));
-        const lineNum = parseInt(line.slice(firstColon + 1, secondColon), 10);
-        const content = line.slice(secondColon + 1);
-        if (isNaN(lineNum))
-            continue;
-        // Strip leading ./ from path
-        if (filePath.startsWith('./'))
-            filePath = filePath.slice(2);
-        // Extract targets using the same regex and literal-span filtering as the
-        // TS fallback, so both scan paths agree regardless of whether ripgrep is
-        // installed.
-        for (const target of extractRefsFromLine(content)) {
-            refs.push({ target, file: filePath, line: lineNum });
-        }
-    }
-    return { refs };
-}
-/**
- * TypeScript fallback: read every file and scan for @lat refs.
- */
-async function scanWithTs(files, projectRoot) {
-    const refs = [];
-    for (const file of files) {
-        let content;
-        try {
-            content = await readFile(file, 'utf-8');
-        }
-        catch (err) {
-            process.stderr.write(`Error: failed to read ${file}: ${err.message}\n`);
-            continue;
-        }
-        const lines = content.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            for (const target of extractRefsFromLine(lines[i])) {
-                refs.push({
-                    target,
-                    file: toPosix(relative(projectRoot, file)),
-                    line: i + 1,
-                });
-            }
-        }
-    }
-    return refs;
-}
-/** Check whether ripgrep (`rg`) is available on PATH. */
-export async function hasRipgrep() {
-    const result = await tryExec('rg', ['--version'], '.');
-    return result !== null;
-}
-export async function scanCodeRefs(projectRoot) {
-    // Fast path: use rg for both searching and file listing
-    // _LAT_DISABLE_RG is a test-only escape hatch to force the TS fallback
-    if (process.env._LAT_DISABLE_RG !== '1') {
-        const rgResult = await tryRipgrep(projectRoot);
-        if (rgResult !== null) {
-            return { refs: rgResult.refs, files: rgResult.files, usedRg: true };
-        }
-    }
-    // Fallback: walk files ourselves and scan with TS
-    const files = await walkFiles(projectRoot);
-    const refs = await scanWithTs(files, projectRoot);
-    return { refs, files, usedRg: false };
-}

package/dist/src/config.d.ts

@@ -1,29 +0,0 @@
-export declare function getConfigDir(): string;
-export declare function getConfigPath(): string;
-export type LatConfig = {
-    llm_key?: string;
-    /**
-     * Per-repo embedding backend preference, keyed by absolute lat.md dir. Durable
-     * (survives deletion of the regenerable `.cache`), so a repo explicitly
-     * switched to local stays local even after a cache wipe or fresh clone.
-     */
-    repos?: Record<string, {
-        embedding?: 'local';
-    }>;
-};
-export declare function readConfig(): LatConfig;
-export declare function writeConfig(config: LatConfig): void;
-/** Durable per-repo backend choice, or undefined if none recorded. */
-export declare function getRepoEmbedding(latDir: string): 'local' | undefined;
-/** Record (or clear, with `null`) the durable per-repo backend choice. */
-export declare function setRepoEmbedding(latDir: string, embedding: 'local' | null): void;
-/**
- * Returns the LLM key from (in priority order):
- * 1. LAT_LLM_KEY environment variable
- * 2. LAT_LLM_KEY_FILE — path to a file containing the key
- * 3. LAT_LLM_KEY_HELPER — shell command that prints the key
- * 4. llm_key field in ~/.config/lat/config.json
- *
- * Returns undefined if none is set.
- */
-export declare function getLlmKey(): string | undefined;

package/dist/src/config.js

@@ -1,83 +0,0 @@
-import { execSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import xdg from '@folder/xdg';
-// ── XDG config directory ────────────────────────────────────────────
-export function getConfigDir() {
-    return join(xdg().config, 'lat');
-}
-export function getConfigPath() {
-    return join(getConfigDir(), 'config.json');
-}
-export function readConfig() {
-    const configPath = getConfigPath();
-    if (!existsSync(configPath))
-        return {};
-    try {
-        return JSON.parse(readFileSync(configPath, 'utf-8'));
-    }
-    catch (err) {
-        process.stderr.write(`Error: failed to parse config ${configPath}: ${err.message}\n`);
-        process.exit(1);
-    }
-}
-export function writeConfig(config) {
-    const dir = getConfigDir();
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(getConfigPath(), JSON.stringify(config, null, 2) + '\n');
-}
-// ── Per-repo embedding backend preference ───────────────────────────
-/** Durable per-repo backend choice, or undefined if none recorded. */
-export function getRepoEmbedding(latDir) {
-    return readConfig().repos?.[resolve(latDir)]?.embedding;
-}
-/** Record (or clear, with `null`) the durable per-repo backend choice. */
-export function setRepoEmbedding(latDir, embedding) {
-    const key = resolve(latDir);
-    const config = readConfig();
-    const repos = config.repos ?? {};
-    if (embedding === null)
-        delete repos[key];
-    else
-        repos[key] = { embedding };
-    config.repos = repos;
-    writeConfig(config);
-}
-// ── Centralized LLM key resolution ─────────────────────────────────
-/**
- * Returns the LLM key from (in priority order):
- * 1. LAT_LLM_KEY environment variable
- * 2. LAT_LLM_KEY_FILE — path to a file containing the key
- * 3. LAT_LLM_KEY_HELPER — shell command that prints the key
- * 4. llm_key field in ~/.config/lat/config.json
- *
- * Returns undefined if none is set.
- */
-export function getLlmKey() {
-    const envKey = process.env.LAT_LLM_KEY;
-    if (envKey)
-        return envKey;
-    const file = process.env.LAT_LLM_KEY_FILE;
-    if (file) {
-        const content = readFileSync(file, 'utf-8').trim();
-        if (!content) {
-            throw new Error(`LAT_LLM_KEY_FILE (${file}) is empty.`);
-        }
-        return content;
-    }
-    const helper = process.env.LAT_LLM_KEY_HELPER;
-    if (helper) {
-        const result = execSync(helper, {
-            encoding: 'utf-8',
-            timeout: 10_000,
-        }).trim();
-        if (!result) {
-            throw new Error('LAT_LLM_KEY_HELPER command returned an empty string.');
-        }
-        return result;
-    }
-    const config = readConfig();
-    if (config.llm_key)
-        return config.llm_key;
-    return undefined;
-}

package/dist/src/context.d.ts

@@ -1,23 +0,0 @@
-export type Styler = {
-    bold: (s: string) => string;
-    dim: (s: string) => string;
-    red: (s: string) => string;
-    cyan: (s: string) => string;
-    white: (s: string) => string;
-    green: (s: string) => string;
-    yellow: (s: string) => string;
-    boldWhite: (s: string) => string;
-};
-export declare const plainStyler: Styler;
-export type CmdContext = {
-    latDir: string;
-    projectRoot: string;
-    styler: Styler;
-    mode: 'cli' | 'mcp';
-    /** The check target was supplied explicitly instead of discovered as lat.md. */
-    headless?: boolean;
-};
-export type CmdResult = {
-    output: string;
-    isError?: boolean;
-};

package/dist/src/context.js

@@ -1,11 +0,0 @@
-const identity = (s) => s;
-export const plainStyler = {
-    bold: identity,
-    dim: identity,
-    red: identity,
-    cyan: identity,
-    white: identity,
-    green: identity,
-    yellow: identity,
-    boldWhite: identity,
-};

package/dist/src/extensions/wiki-link/from-markdown.d.ts

@@ -1,5 +0,0 @@
-/**
- * mdast-util extension to turn wiki-link micromark tokens into mdast nodes.
- */
-import type { Extension } from 'mdast-util-from-markdown';
-export declare function wikiLinkFromMarkdown(): Extension;

package/dist/src/extensions/wiki-link/from-markdown.js

@@ -1,34 +0,0 @@
-/**
- * mdast-util extension to turn wiki-link micromark tokens into mdast nodes.
- */
-function enterWikiLink(token) {
-    const node = {
-        type: 'wikiLink',
-        value: '',
-        data: { alias: null },
-    };
-    this.enter(node, token);
-}
-function exitWikiLinkTarget(token) {
-    const target = this.sliceSerialize(token);
-    const node = this.stack[this.stack.length - 1];
-    node.value = target;
-}
-function exitWikiLinkAlias(token) {
-    const alias = this.sliceSerialize(token);
-    const node = this.stack[this.stack.length - 1];
-    node.data.alias = alias;
-}
-function exitWikiLink(token) {
-    this.exit(token);
-}
-export function wikiLinkFromMarkdown() {
-    return {
-        enter: { wikiLink: enterWikiLink },
-        exit: {
-            wikiLinkTarget: exitWikiLinkTarget,
-            wikiLinkAlias: exitWikiLinkAlias,
-            wikiLink: exitWikiLink,
-        },
-    };
-}

package/dist/src/extensions/wiki-link/index.d.ts

@@ -1,4 +0,0 @@
-export { wikiLinkSyntax } from './syntax.js';
-export { wikiLinkFromMarkdown } from './from-markdown.js';
-export { wikiLinkToMarkdown } from './to-markdown.js';
-export type { WikiLink } from './types.js';

package/dist/src/extensions/wiki-link/index.js

@@ -1,3 +0,0 @@
-export { wikiLinkSyntax } from './syntax.js';
-export { wikiLinkFromMarkdown } from './from-markdown.js';
-export { wikiLinkToMarkdown } from './to-markdown.js';

package/dist/src/extensions/wiki-link/syntax.d.ts

@@ -1,14 +0,0 @@
-/**
- * Micromark syntax extension for wiki links: [[target]] and [[target|alias]].
- *
- * Produces the following token types:
- *   - wikiLink          (the entire construct)
- *   - wikiLinkMarker    ([[ and ]])
- *   - wikiLinkData      (everything between markers)
- *   - wikiLinkTarget    (the target portion)
- *   - wikiLinkAliasMarker (the | divider)
- *   - wikiLinkAlias     (the alias portion)
- */
-import type { Extension } from 'micromark-util-types';
-import './types.js';
-export declare function wikiLinkSyntax(): Extension;

package/dist/src/extensions/wiki-link/syntax.js

@@ -1,121 +0,0 @@
-/**
- * Micromark syntax extension for wiki links: [[target]] and [[target|alias]].
- *
- * Produces the following token types:
- *   - wikiLink          (the entire construct)
- *   - wikiLinkMarker    ([[ and ]])
- *   - wikiLinkData      (everything between markers)
- *   - wikiLinkTarget    (the target portion)
- *   - wikiLinkAliasMarker (the | divider)
- *   - wikiLinkAlias     (the alias portion)
- */
-import './types.js';
-const ALIAS_DIVIDER = '|';
-const OPEN = '[[';
-const CLOSE = ']]';
-function tokenize(effects, ok, nok) {
-    let openCursor = 0;
-    let closeCursor = 0;
-    let aliasCursor = 0;
-    let hasData = false;
-    let hasAlias = false;
-    return start;
-    function start(code) {
-        if (code !== OPEN.charCodeAt(openCursor))
-            return nok(code);
-        effects.enter('wikiLink');
-        effects.enter('wikiLinkMarker');
-        return consumeOpen(code);
-    }
-    function consumeOpen(code) {
-        if (openCursor === OPEN.length) {
-            effects.exit('wikiLinkMarker');
-            return consumeDataStart(code);
-        }
-        if (code !== OPEN.charCodeAt(openCursor))
-            return nok(code);
-        effects.consume(code);
-        openCursor++;
-        return consumeOpen;
-    }
-    function consumeDataStart(code) {
-        if (code === null || code < -2)
-            return nok(code);
-        effects.enter('wikiLinkData');
-        effects.enter('wikiLinkTarget');
-        return consumeTarget(code);
-    }
-    function consumeTarget(code) {
-        if (code === ALIAS_DIVIDER.charCodeAt(aliasCursor)) {
-            if (!hasData)
-                return nok(code);
-            effects.exit('wikiLinkTarget');
-            effects.enter('wikiLinkAliasMarker');
-            return consumeAliasMarker(code);
-        }
-        if (code === CLOSE.charCodeAt(closeCursor)) {
-            if (!hasData)
-                return nok(code);
-            effects.exit('wikiLinkTarget');
-            effects.exit('wikiLinkData');
-            effects.enter('wikiLinkMarker');
-            return consumeClose(code);
-        }
-        // No line endings or EOF inside wiki links
-        if (code === null || code < -2)
-            return nok(code);
-        if (code !== -2 && code !== -1 && code !== 32) {
-            hasData = true;
-        }
-        effects.consume(code);
-        return consumeTarget;
-    }
-    function consumeAliasMarker(code) {
-        if (aliasCursor === ALIAS_DIVIDER.length) {
-            effects.exit('wikiLinkAliasMarker');
-            effects.enter('wikiLinkAlias');
-            return consumeAlias(code);
-        }
-        if (code !== ALIAS_DIVIDER.charCodeAt(aliasCursor))
-            return nok(code);
-        effects.consume(code);
-        aliasCursor++;
-        return consumeAliasMarker;
-    }
-    function consumeAlias(code) {
-        if (code === CLOSE.charCodeAt(closeCursor)) {
-            if (!hasAlias)
-                return nok(code);
-            effects.exit('wikiLinkAlias');
-            effects.exit('wikiLinkData');
-            effects.enter('wikiLinkMarker');
-            return consumeClose(code);
-        }
-        if (code === null || code < -2)
-            return nok(code);
-        if (code !== -2 && code !== -1 && code !== 32) {
-            hasAlias = true;
-        }
-        effects.consume(code);
-        return consumeAlias;
-    }
-    function consumeClose(code) {
-        if (closeCursor === CLOSE.length) {
-            effects.exit('wikiLinkMarker');
-            effects.exit('wikiLink');
-            return ok(code);
-        }
-        if (code !== CLOSE.charCodeAt(closeCursor))
-            return nok(code);
-        effects.consume(code);
-        closeCursor++;
-        return consumeClose;
-    }
-}
-export function wikiLinkSyntax() {
-    return {
-        text: {
-            91: { tokenize }, // '[' character code
-        },
-    };
-}

package/dist/src/extensions/wiki-link/to-markdown.d.ts

@@ -1,5 +0,0 @@
-/**
- * mdast-util extension to serialize wiki-link nodes back to markdown.
- */
-import type { Options } from 'mdast-util-to-markdown';
-export declare function wikiLinkToMarkdown(): Options;

package/dist/src/extensions/wiki-link/to-markdown.js

@@ -1,28 +0,0 @@
-/**
- * mdast-util extension to serialize wiki-link nodes back to markdown.
- */
-function handler(node, _parent, state, _info) {
-    const exit = state.enter('wikiLink');
-    const target = state.safe(node.value, { before: '[', after: ']' });
-    let value;
-    if (node.data.alias) {
-        const alias = state.safe(node.data.alias, { before: '[', after: ']' });
-        value = `[[${target}|${alias}]]`;
-    }
-    else {
-        value = `[[${target}]]`;
-    }
-    exit();
-    return value;
-}
-export function wikiLinkToMarkdown() {
-    return {
-        unsafe: [
-            { character: '[', inConstruct: ['phrasing', 'label', 'reference'] },
-            { character: ']', inConstruct: ['label', 'reference'] },
-        ],
-        handlers: {
-            wikiLink: handler,
-        },
-    };
-}

package/dist/src/extensions/wiki-link/types.d.ts

@@ -1,34 +0,0 @@
-import type { Data, Literal } from 'mdast';
-/**
- * mdast node for a wiki-style link like [[target]] or [[target|alias]].
- */
-export interface WikiLink extends Literal {
-    type: 'wikiLink';
-    value: string;
-    data: Data & {
-        alias: string | null;
-    };
-}
-declare module 'mdast' {
-    interface RootContentMap {
-        wikiLink: WikiLink;
-    }
-    interface PhrasingContentMap {
-        wikiLink: WikiLink;
-    }
-}
-declare module 'micromark-util-types' {
-    interface TokenTypeMap {
-        wikiLink: 'wikiLink';
-        wikiLinkMarker: 'wikiLinkMarker';
-        wikiLinkData: 'wikiLinkData';
-        wikiLinkTarget: 'wikiLinkTarget';
-        wikiLinkAliasMarker: 'wikiLinkAliasMarker';
-        wikiLinkAlias: 'wikiLinkAlias';
-    }
-}
-declare module 'mdast-util-to-markdown' {
-    interface ConstructNameMap {
-        wikiLink: 'wikiLink';
-    }
-}