@osdlc/markdown-link 0.0.0-stage → 0.5.0

package/dist/body-links.js

@@ -0,0 +1,219 @@
+/**
+ * The body link scanner: every link in a body, with its span. A port of the
+ * `markdown-link` crate's `body_links_spanned` and `body_links`.
+ */
+import { stripCode } from "./code.js";
+import { isVaultLinkUrl, isWhitespace, mdLinkTarget, parseInner, trim } from "./parse.js";
+/**
+ * Every wikilink, embed and relative markdown link in a note body, in the
+ * order they appear. `bodyLinksSpanned` without the spans, so the two cannot
+ * disagree. A markdown link is reported as `'wikilink'`.
+ */
+export function bodyLinks(body) {
+    return bodyLinksSpanned(body).map((link) => ({
+        target: link.target,
+        kind: link.kind === 'embed' ? 'embed' : 'wikilink',
+    }));
+}
+/**
+ * Every wikilink, embed and relative markdown link in a body, in encounter
+ * order, with spans.
+ *
+ * Code is blanked before matching, `[[` never nests, and a markdown link
+ * counts only when `isVaultLinkUrl` accepts its URL and it carries no scheme.
+ *
+ * The scan walks code points. `stripCode` keeps the code point count of its
+ * input, not its UTF-16 length, so a code point index into the stripped text
+ * is one into the body, and a table converts it to a UTF-16 offset.
+ */
+export function bodyLinksSpanned(body) {
+    const chars = Array.from(stripCode(body));
+    // Code point index -> UTF-16 offset in the body, plus an end sentinel.
+    const at = [];
+    let offset = 0;
+    for (const c of body) {
+        at.push(offset);
+        offset += c.length;
+    }
+    at.push(body.length);
+    if (chars.length + 1 !== at.length) {
+        // `stripCode` must keep the code point count. If it ever does not,
+        // reporting no links beats reporting spans that index the wrong text.
+        return [];
+    }
+    const out = [];
+    const scan = new UrlScan();
+    let i = 0;
+    while (i < chars.length) {
+        if (chars[i] === '[' && chars[i + 1] === '[') {
+            const embed = i > 0 && chars[i - 1] === '!';
+            let j = i + 2;
+            let inner = '';
+            let pipe = -1;
+            let closed = false;
+            while (j + 1 < chars.length) {
+                if (chars[j] === ']' && chars[j + 1] === ']') {
+                    closed = true;
+                    break;
+                }
+                // `[[` never nests, and `[` or `]` inside is a malformed link: stop
+                // rather than swallow the rest of the note.
+                if (chars[j] === '[' || chars[j] === ']')
+                    break;
+                if (pipe === -1 && chars[j] === '|')
+                    pipe = j;
+                inner += chars[j];
+                j++;
+            }
+            if (closed && inner !== '') {
+                const link = parseInner(inner, embed);
+                if (link !== null) {
+                    // Split at the pipe `parseInner` used, found in the stripped chars
+                    // so a `|` in code is not one, then read the alias from the body so
+                    // code inside it is kept.
+                    const alias = pipe === -1 ? null : trim(body.slice(at[pipe + 1], at[j])) || null;
+                    out.push({
+                        kind: embed ? 'embed' : 'wikilink',
+                        raw: inner,
+                        target: link.target,
+                        alias,
+                        start: at[embed ? i - 1 : i],
+                        end: at[j + 2],
+                    });
+                }
+                i = j + 2;
+                continue;
+            }
+        }
+        if (chars[i] === '[') {
+            const found = markdownLink(chars, i, at, scan);
+            if (found !== null) {
+                out.push(found.link);
+                i = found.next;
+                continue;
+            }
+        }
+        i++;
+    }
+    return out;
+}
+/**
+ * `[text](relative/note.md)` starting at `start`, and the code point index
+ * just past it, or `null` when this is not one.
+ *
+ * The shape is the regex `\[[^\]]*\]\(<?([^)>\s]+?)>?\)`, walked by hand so
+ * positions index the body. A URL containing whitespace is not a link. The
+ * URL is read in place and built only for a link, so a body of failed
+ * attempts stays linear.
+ */
+function markdownLink(chars, start, at, scan) {
+    let j = start + 1;
+    while (j < chars.length && chars[j] !== ']' && chars[j] !== '[')
+        j++;
+    if (chars[j] !== ']' || chars[j + 1] !== '(')
+        return null;
+    const angled = chars[j + 2] === '<';
+    const urlStart = angled ? j + 3 : j + 2;
+    const urlEnd = scan.urlEnd(chars, urlStart);
+    let end = urlEnd;
+    if (angled) {
+        if (chars[end] !== '>')
+            return null;
+        end++;
+    }
+    if (chars[end] !== ')')
+        return null;
+    end++;
+    // Not a link this dialect harvests. The caller advances one code point, so
+    // a match may start at an inner `[`: `[a[b](x.md)` is a link.
+    if (!scan.isVaultLink(chars, urlStart, urlEnd) || hasScheme(chars, urlStart, urlEnd)) {
+        return null;
+    }
+    const url = chars.slice(urlStart, urlEnd).join('');
+    return {
+        link: {
+            kind: 'markdown',
+            raw: url,
+            target: mdLinkTarget(url),
+            alias: null,
+            start: at[start],
+            end: at[end],
+        },
+        next: end,
+    };
+}
+/**
+ * What earlier markdown link attempts learned about the URLs they read. Each
+ * attempt starts later than the one before, so remembering the last answer of
+ * each kind keeps a body of failed attempts linear.
+ */
+class UrlScan {
+    /** The first `)`, `>` or whitespace at or after `from` is at `stop`. */
+    from = -1;
+    stop = -1;
+    end = -1;
+    markFrom = -1;
+    /**
+     * The last `.` or `/` in `[markFrom, end)`, or below `markFrom` when there
+     * is none.
+     */
+    mark = -1;
+    /** `isVaultLinkUrl` of `chars[tailStart, end)`, by `tailStart`. */
+    answers = new Map();
+    /** Where a URL starting at `from` ends: the first `)`, `>` or whitespace. */
+    urlEnd(chars, from) {
+        if (from >= this.from && from <= this.stop)
+            return this.stop;
+        let k = from;
+        while (k < chars.length && chars[k] !== ')' && chars[k] !== '>' && !isWhitespace(chars[k])) {
+            k++;
+        }
+        this.from = from;
+        this.stop = k;
+        return k;
+    }
+    /**
+     * `isVaultLinkUrl` of `chars[from, end)`. That answer depends only on
+     * whether the URL ends in `.md` after at least one character and on the
+     * extension of its last segment. So the URL from the character before its
+     * last `.` gives the same answer, and that tail is shared by every attempt
+     * ending at `end`.
+     */
+    isVaultLink(chars, from, end) {
+        if (end !== this.end || from < this.markFrom) {
+            let mark = end - 1;
+            while (mark >= from && chars[mark] !== '.' && chars[mark] !== '/')
+                mark--;
+            this.end = end;
+            this.markFrom = from;
+            this.mark = mark;
+            this.answers.clear();
+        }
+        if (this.mark < from || chars[this.mark] === '/')
+            return false;
+        const tailStart = Math.max(from, this.mark - 1);
+        let answer = this.answers.get(tailStart);
+        if (answer === undefined) {
+            answer = isVaultLinkUrl(chars.slice(tailStart, end).join(''));
+            this.answers.set(tailStart, answer);
+        }
+        return answer;
+    }
+}
+/**
+ * Whether `chars[from, end)` starts with a URI scheme (`http:`, `https:`,
+ * `mailto:`), which marks the URL external. Read in place, like the rest of
+ * the URL: `/^[A-Za-z][A-Za-z0-9+.-]*:/` on a built string would cost the
+ * whole URL on every failed attempt.
+ */
+function hasScheme(chars, from, end) {
+    if (from >= end || !/^[A-Za-z]$/.test(chars[from]))
+        return false;
+    for (let i = from + 1; i < end; i++) {
+        if (chars[i] === ':')
+            return true;
+        if (!/^[A-Za-z0-9+.-]$/.test(chars[i]))
+            return false;
+    }
+    return false;
+}

package/dist/code.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Code fences and inline code spans: finding them, and blanking them so a
+ * lexer never harvests out of them. A port of the `markdown-link` crate's
+ * `wikilink::code` module; that module's doc states both rule sets in full.
+ *
+ * In short, `'commonmark'` (the default) follows CommonMark, and
+ * `'skill-export'` keeps the looser rules of `skill-export`'s renderer. Both read one line at a time, so neither knows about container
+ * blocks, and indented code blocks are not code.
+ *
+ * Every marker is ASCII, so a scan over UTF-16 code units never splits a
+ * character.
+ */
+/** Which rules the lexer follows. */
+export type CodeRules = 'commonmark' | 'skill-export';
+/**
+ * Blank out fenced and inline code so links and tags inside it are not
+ * harvested. `stripCodeWith` under `'commonmark'`.
+ */
+export declare function stripCode(text: string): string;
+/**
+ * Blank out fenced and inline code under `rules`.
+ *
+ * Every character of code, fence marker lines included, becomes a space, and
+ * every `\n` stays. The output has the same number of **code points** as the
+ * input, as the Rust crate keeps the same number of `char`s. It is not the
+ * same UTF-16 length: a character outside the Basic Multilingual Plane in code
+ * becomes one space, not two.
+ */
+export declare function stripCodeWith(text: string, rules: CodeRules): string;

package/dist/code.js

@@ -0,0 +1,353 @@
+/**
+ * Code fences and inline code spans: finding them, and blanking them so a
+ * lexer never harvests out of them. A port of the `markdown-link` crate's
+ * `wikilink::code` module; that module's doc states both rule sets in full.
+ *
+ * In short, `'commonmark'` (the default) follows CommonMark, and
+ * `'skill-export'` keeps the looser rules of `skill-export`'s renderer. Both read one line at a time, so neither knows about container
+ * blocks, and indented code blocks are not code.
+ *
+ * Every marker is ASCII, so a scan over UTF-16 code units never splits a
+ * character.
+ */
+const NEWLINE = 10;
+const CR = 13;
+const TAB = 9;
+const SPACE = 32;
+const BACKTICK = 96;
+const TILDE = 126;
+/**
+ * `^ {0,3}(`{3,}|~{3,})` on the line `s[start, end)`: the marker's shape only.
+ */
+function fenceRun(s, start, end) {
+    const at = start + leadingSpaces(s, start, end, 3);
+    if (at >= end)
+        return null;
+    const char = s.charCodeAt(at);
+    if (char !== BACKTICK && char !== TILDE)
+        return null;
+    let runEnd = at;
+    while (runEnd < end && s.charCodeAt(runEnd) === char)
+        runEnd++;
+    const length = runEnd - at;
+    return length >= 3 ? { char, length, end: runEnd } : null;
+}
+function opensFence(s, start, end, rules) {
+    const run = fenceRun(s, start, end);
+    if (run === null)
+        return null;
+    const backtickInInfo = run.char === BACKTICK && s.slice(run.end, end).includes('`');
+    if (rules === 'commonmark' && backtickInInfo)
+        return null;
+    return { char: run.char, length: run.length };
+}
+function closesFence(s, start, end, open, rules) {
+    const run = fenceRun(s, start, end);
+    if (run === null)
+        return false;
+    return (run.char === open.char &&
+        run.length >= open.length &&
+        (rules === 'skill-export' || isBlank(s, run.end, end)));
+}
+/** The fence state of a line-by-line scan: which fence, if any, is open. */
+class Fences {
+    open = null;
+    rules;
+    constructor(rules) {
+        this.rules = rules;
+    }
+    /** Classify the line `s[start, end)` and step past it. */
+    line(s, start, end) {
+        if (this.open === null) {
+            this.open = opensFence(s, start, end, this.rules);
+            return this.open === null ? 'outside' : 'marker';
+        }
+        if (closesFence(s, start, end, this.open, this.rules)) {
+            this.open = null;
+            return 'marker';
+        }
+        if (this.rules === 'skill-export' && fenceRun(s, start, end) !== null)
+            return 'marker';
+        return 'inside';
+    }
+}
+/**
+ * The backtick runs in `start..end`, the rest of a block from where a search
+ * found no close.
+ */
+class BlockRuns {
+    /**
+     * `[length, start]` for each run length that occurs, sorted by length:
+     * where the last run that would close a span of that length starts.
+     */
+    lastClose;
+    start;
+    end;
+    rules;
+    constructor(s, start, end, rules) {
+        this.start = start;
+        this.end = end;
+        this.rules = rules;
+        const last = new Map();
+        let at = start;
+        while (at < end) {
+            if (s.charCodeAt(at) !== BACKTICK) {
+                at++;
+                continue;
+            }
+            const run = runLength(s, at, end);
+            last.set(run, at);
+            at += run;
+        }
+        this.lastClose = [...last].sort((a, b) => a[0] - b[0]);
+        if (rules === 'skill-export') {
+            // A longer run closes a shorter span too.
+            for (let i = this.lastClose.length - 2; i >= 0; i--) {
+                const entry = this.lastClose[i];
+                entry[1] = Math.max(entry[1], this.lastClose[i + 1][1]);
+            }
+        }
+    }
+    /** Whether a run at or after `from` closes a span opened by `length` backticks. */
+    hasClose(length, from) {
+        let lo = 0;
+        let hi = this.lastClose.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (this.lastClose[mid][0] < length)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        const entry = this.lastClose[lo];
+        if (entry === undefined)
+            return false;
+        return entry[1] >= from && (entry[0] === length || this.rules === 'skill-export');
+    }
+}
+/**
+ * Finds where inline code spans close, for a scan that reads its input once,
+ * left to right. Call `line` at each line start the scan reaches outside a
+ * fence, and `close` at each backtick run it reaches. A whole pass is linear
+ * in the size of its input.
+ */
+class Spans {
+    /** Whether the current line is one a span cannot leave. */
+    oneLine = false;
+    noClose = null;
+    rules;
+    s;
+    constructor(rules, s) {
+        this.rules = rules;
+        this.s = s;
+    }
+    /**
+     * Note the line `s[start, end)` the scan has reached. Under `'commonmark'`,
+     * a span opened on an ATX heading or a line starting with `|` stays on that
+     * line.
+     */
+    line(start, end) {
+        this.oneLine = this.rules === 'commonmark' && isOneLineBlock(this.s, start, end);
+    }
+    /**
+     * The backtick run that starts at `start`: its length, and where the span it
+     * opens closes (the start of the closing run), or `null` if it does not.
+     */
+    close(start) {
+        const length = runLength(this.s, start, this.s.length);
+        const from = start + length;
+        const runs = this.noClose;
+        if (runs !== null && runs.start <= from && from < runs.end && !runs.hasClose(length, from)) {
+            return [length, null];
+        }
+        const found = this.search(length, from);
+        if ('close' in found)
+            return [length, found.close];
+        this.noClose = new BlockRuns(this.s, from, found.blockEnd, this.rules);
+        return [length, null];
+    }
+    /** The close, or the end of the block when there is none. */
+    search(length, from) {
+        const s = this.s;
+        let at = from;
+        for (;;) {
+            while (at < s.length && s.charCodeAt(at) !== NEWLINE) {
+                if (s.charCodeAt(at) !== BACKTICK) {
+                    at++;
+                    continue;
+                }
+                const run = runLength(s, at, s.length);
+                if (closes(run, length, this.rules))
+                    return { close: at };
+                at += run;
+            }
+            const next = at + 1;
+            if (this.oneLine || next >= s.length)
+                return { blockEnd: Math.min(next, s.length) };
+            if (endsSpanBlock(s, next, lineEnd(s, next), this.rules))
+                return { blockEnd: next };
+            at = next;
+        }
+    }
+}
+function closes(run, length, rules) {
+    return rules === 'commonmark' ? run === length : run >= length;
+}
+function runLength(s, at, end) {
+    let i = at;
+    while (i < end && s.charCodeAt(i) === BACKTICK)
+        i++;
+    return i - at;
+}
+/** Whether the line `s[start, end)` starts a block that a span cannot reach into. */
+function endsSpanBlock(s, start, end, rules) {
+    const stop = end > start && s.charCodeAt(end - 1) === CR ? end - 1 : end;
+    if (isBlank(s, start, stop))
+        return true;
+    if (rules === 'skill-export')
+        return fenceRun(s, start, stop) !== null;
+    return opensFence(s, start, stop, rules) !== null || startsBlock(s, start, stop);
+}
+/** An ATX heading or a line starting with `|`: a block that is one line long. */
+function isOneLineBlock(s, start, end) {
+    const at = start + leadingSpaces(s, start, end, 3);
+    return atxHeading(s, at, end) || (at < end && s[at] === '|');
+}
+/** `#{1,6}` then a space, a tab or the end of the line, from `at`. */
+function atxHeading(s, at, end) {
+    let i = at;
+    while (i < end && s[i] === '#')
+        i++;
+    const hashes = i - at;
+    if (hashes < 1 || hashes > 6)
+        return false;
+    if (i >= end)
+        return true;
+    const after = s.charCodeAt(i);
+    return after === SPACE || after === TAB || after === CR;
+}
+/**
+ * An ATX heading, a line starting with `|`, a setext underline, a thematic
+ * break, a block quote or a list item.
+ */
+function startsBlock(s, start, end) {
+    const indented = start + leadingSpaces(s, start, end, 3);
+    let rest = start;
+    while (rest < end && (s.charCodeAt(rest) === SPACE || s.charCodeAt(rest) === TAB))
+        rest++;
+    const endsMarker = (at) => at >= end || s.charCodeAt(at) === SPACE || s.charCodeAt(at) === TAB;
+    let equals = indented;
+    while (equals < end && s[equals] === '=')
+        equals++;
+    const setext = equals > indented && isBlank(s, equals, end);
+    const quote = rest < end && s[rest] === '>';
+    const bullet = rest < end && '-*+'.includes(s[rest]) && endsMarker(rest + 1);
+    let digitsEnd = rest;
+    while (digitsEnd < end && isAsciiDigit(s.charCodeAt(digitsEnd)))
+        digitsEnd++;
+    const digits = digitsEnd - rest;
+    const ordered = digits >= 1 &&
+        digits <= 9 &&
+        digitsEnd < end &&
+        (s[digitsEnd] === '.' || s[digitsEnd] === ')') &&
+        endsMarker(digitsEnd + 1);
+    return (isOneLineBlock(s, start, end) ||
+        setext ||
+        quote ||
+        bullet ||
+        ordered ||
+        thematicBreak(s, indented, end));
+}
+/** Three or more of one of `-`, `*` or `_`, with only spaces or tabs between. */
+function thematicBreak(s, start, end) {
+    if (start >= end)
+        return false;
+    const mark = s[start];
+    if (mark !== '-' && mark !== '*' && mark !== '_')
+        return false;
+    let count = 0;
+    for (let i = start; i < end; i++) {
+        const c = s[i];
+        if (c === mark)
+            count++;
+        else if (c !== ' ' && c !== '\t')
+            return false;
+    }
+    return count >= 3;
+}
+function isAsciiDigit(code) {
+    return code >= 48 && code <= 57;
+}
+function leadingSpaces(s, start, end, max) {
+    let n = 0;
+    while (n < max && start + n < end && s.charCodeAt(start + n) === SPACE)
+        n++;
+    return n;
+}
+function isBlank(s, start, end) {
+    for (let i = start; i < end; i++) {
+        const c = s.charCodeAt(i);
+        if (c !== SPACE && c !== TAB && c !== CR)
+            return false;
+    }
+    return true;
+}
+/** The index of the `\n` ending the line that holds `from`, or the end of input. */
+function lineEnd(s, from) {
+    const at = s.indexOf('\n', from);
+    return at === -1 ? s.length : at;
+}
+/**
+ * Blank out fenced and inline code so links and tags inside it are not
+ * harvested. `stripCodeWith` under `'commonmark'`.
+ */
+export function stripCode(text) {
+    return stripCodeWith(text, 'commonmark');
+}
+/**
+ * Blank out fenced and inline code under `rules`.
+ *
+ * Every character of code, fence marker lines included, becomes a space, and
+ * every `\n` stays. The output has the same number of **code points** as the
+ * input, as the Rust crate keeps the same number of `char`s. It is not the
+ * same UTF-16 length: a character outside the Basic Multilingual Plane in code
+ * becomes one space, not two.
+ */
+export function stripCodeWith(text, rules) {
+    const out = [];
+    const fences = new Fences(rules);
+    const spans = new Spans(rules, text);
+    let writtenUpTo = 0;
+    const blank = (start, end) => {
+        out.push(text.slice(writtenUpTo, start));
+        for (const c of text.slice(start, end))
+            out.push(c === '\n' ? '\n' : ' ');
+        writtenUpTo = end;
+    };
+    let offset = 0;
+    while (offset < text.length) {
+        if (offset === 0 || text.charCodeAt(offset - 1) === NEWLINE) {
+            const end = lineEnd(text, offset);
+            if (fences.line(text, offset, end) !== 'outside') {
+                blank(offset, end);
+                offset = end + 1;
+                continue;
+            }
+            spans.line(offset, end);
+        }
+        if (text.charCodeAt(offset) === BACKTICK) {
+            const [run, close] = spans.close(offset);
+            if (close === null) {
+                offset += run;
+            }
+            else {
+                blank(offset, close + run);
+                offset = close + run;
+            }
+            continue;
+        }
+        offset++;
+    }
+    out.push(text.slice(writtenUpTo));
+    return out.join('');
+}

package/dist/display.d.ts

@@ -0,0 +1,36 @@
+/**
+ * What a reader sees for a link, and typed references. A port of the
+ * `markdown-link` crate's `display_text` and `parse_typed_ref`.
+ */
+/**
+ * Replace each wikilink and embed with what a reader sees for it, for
+ * snippets and search: its alias, or else its target. An embed's trailing
+ * `|300` or `|300x200` is a size, not an alias, so
+ * `![[img.png|300]]` shows `img.png`. An empty alias shows the target. Code
+ * is not skipped.
+ *
+ * Every delimiter is ASCII, so the scan can step UTF-16 units: a surrogate
+ * never matches one.
+ */
+export declare function displayText(text: string): string;
+/**
+ * A typed reference, `[[type/slug]]` or `[[type/slug|Alias]]`: a frontmatter
+ * value naming one note of a known type, such as `location: "[[location/home]]"`.
+ */
+export interface TypedRef {
+    /** The text before the first `/`, such as `location`. */
+    kind: string;
+    /** The rest of the target, such as `home` or `2026/spring`. */
+    slug: string;
+    /** The text after the first `|`, as written. */
+    alias: string | null;
+}
+/**
+ * Parse a whole value as a typed reference, or `null`.
+ *
+ * Shape only: the target is not resolved. The value is exactly `[[...]]`
+ * with no `[`, `]` or line break inside. The target ends at the first `|`,
+ * minus a `\` that escapes it, as in `parseInner`. Its type and each
+ * `/`-separated slug segment are non-empty and hold no whitespace.
+ */
+export declare function parseTypedRef(value: string): TypedRef | null;