@osdlc/markdown-link 0.5.0 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @osdlc/markdown-link
 
+## 0.8.0
+
+### Minor Changes
+
+- 96a1bd2: New: `scanBodyWith(body, options)` returns `{ links, abandoned }`. `links` is what `bodyLinksSpannedWith` returns. `abandoned` lists each `[[` the scan found outside code and did not read as a link, as an `AbandonedLink` with `reason`, `embed`, `start` and `end`, so a caller can flag link syntax left in the text. The reasons (`AbandonReason`) are `'bracket'` (a `[` or `]` before the closing `]]`), `'code'` (the target is only code), `'empty-target'` (`[[]]`, `[[ |alias]]`, or `[[#Heading]]` without `selfLinks`) and `'unclosed'`. A run of `[` with no link after it, such as `[[[TODO`, is one entry: from the first `[[`, with the reason and end of the last. Matches the Rust crate's `scan_body_with`. This release is 0.8.0: `package.json` was set to 0.7.0 by hand so the package joins the Rust crate on 0.8 and skips 0.7.
+- 3623b05: **Breaking:** a `#^id` fragment is now a block, not a heading. `parseInner('Note#^abc', false)` gives `heading: null` and `block: 'abc'`, where it gave `heading: '^abc'`. `WikiLink` and `BodyLink` gain `block` and `size` (an embed's `|300` or `|300x200`, as `{ width, height }`; the alias still holds it as written), and `BodyLink` gains `heading`. New: `bodyLinksSpannedWith(body, options)` with `ScanOptions` (`codeRules`, `skipHtmlComments`, `selfLinks`, all off or CommonMark by default, so `bodyLinksSpanned` is unchanged), `parseInnerSelf` (reads `#Heading` as a link to the note it is in, with an empty target), `isSizeSpec` and `parseSize`. Released together with `scanBodyWith` as 0.8.0, which matches the Rust crate's 0.8.0; there is no 0.7.0 of this package.
+
+### Patch Changes
+
+- 96a1bd2: Fixed: `percentDecode` takes an escape only when both characters after `%` are hex digits, so `%+5` stays as written instead of decoding. It had copied a quirk of Rust's `u8::from_str_radix`, which accepts a sign; the Rust crate's `percent_decode` is fixed the same way.
+
+## 0.6.0
+
+### Minor Changes
+
+- 743c7bf: Export `percentDecode`, the decoding `mdLinkTarget` already uses, as the Rust crate exports `percent_decode`. Each valid `%XX` decodes on its own, a `%` that is not valid hex stays as written, and a result that is not UTF-8 leaves the whole string as written.
+
 ## 0.5.0
 
 ### Minor Changes

package/README.md

@@ -60,7 +60,8 @@ npm install @osdlc/markdown-link
 import { bodyLinksSpanned } from '@osdlc/markdown-link'
 
 bodyLinksSpanned('See [[Note#h|alias]] and `[[not a link]]`')
-// [{ kind: 'wikilink', raw: 'Note#h|alias', target: 'Note', alias: 'alias', start: 4, end: 20 }]
+// [{ kind: 'wikilink', raw: 'Note#h|alias', target: 'Note', heading: 'h', block: null,
+//    alias: 'alias', size: null, start: 4, end: 20 }]
 ```
 
 ## Exports
@@ -69,12 +70,26 @@ bodyLinksSpanned('See [[Note#h|alias]] and `[[not a link]]`')
   `\n` and the code point count, so links in code are not harvested.
   `stripCodeWith(text, rules)` takes `'commonmark'` (the default) or
   `'skill-export'`.
-- One link: `parseInner` splits a wikilink body into target, heading and
-  alias; `targetRange` is where the target sits in it.
+- One link: `parseInner` splits a wikilink body into target, heading, block
+  (`#^id`), alias and, for an embed, size; `targetRange` is where the target
+  sits in it. `parseInnerSelf` also reads a body with no target and a `#`
+  fragment, `#Heading`, as a link to the note it is in, with an empty target.
+  `isSizeSpec` and `parseSize` read `300` or `300x200`.
 - Markdown link URLs: `isVaultLinkUrl` says whether a URL is a note or an
   attachment; `mdLinkTarget` percent-decodes it and drops `.md`.
+  `percentDecode` is that decoding alone: `percentDecode('My%20Note')` is
+  `'My Note'`, and a `%` that is not valid hex or UTF-8 stays as written.
 - A body: `bodyLinksSpanned` finds every wikilink, embed and relative markdown
   link, with its span; `bodyLinks` is the same scan without spans.
+  `bodyLinksSpannedWith(body, options)` takes `ScanOptions`: `codeRules`,
+  `skipHtmlComments` (links in `<!-- -->` are not links) and `selfLinks`
+  (`[[#Heading]]` is a link with an empty target). The defaults are
+  `bodyLinksSpanned`'s. `scanBodyWith(body, options)` returns those links
+  and `abandoned`, each `[[` the scan gave up on as an `AbandonedLink`
+  (`reason`, `embed`, `start`, `end`), so a caller can flag link syntax left
+  in the text. The reasons (`AbandonReason`) are `'bracket'` (a `[` or `]`
+  before `]]`), `'code'` (the target is only code), `'empty-target'` and
+  `'unclosed'`. Its result is a `BodyScan`.
 - Display text: `displayText` replaces each wikilink and embed with what a
   reader sees, its alias or else its target. An embed's `|300` or `|300x200`
   is a size, not text, so `![[img.png|300]]` shows `img.png`.
@@ -88,7 +103,9 @@ The Rust crate reports byte offsets.
 ## Twin
 
 The Rust crate `markdown-link` has the parsing functions above under their
-snake_case names. It also resolves links (`LinkIndex`), reads links in
+snake_case names. It also resolves links (`LinkIndex`, with `candidates` and
+`resolve_strict`), writes relative links (`relative_link`,
+`encode_uri_component`, `encode_uri_fragment`, `escape_label`), reads links in
 frontmatter and has smaller helpers, which this package does not have yet.
 Both suites read one case file,
 `packages/rust/markdown-link/tests/fixtures/conformance.json` in the

package/dist/body-links.d.ts

@@ -2,6 +2,20 @@
  * 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 { type CodeRules } from './code.ts';
+import { type Size } from './parse.ts';
+/** What a body scan counts as a link. Every field is optional; the defaults are what `bodyLinksSpanned` uses. */
+export interface ScanOptions {
+    /** Which rules decide what is code. Default `'commonmark'`. */
+    codeRules?: CodeRules;
+    /** Skip links inside HTML comments, `<!--` to `-->` or the end. Default `false`. */
+    skipHtmlComments?: boolean;
+    /**
+     * Read `[[#Heading]]` or `[[#^block]]` as a link to the note it is written
+     * in, with an empty `target`. Default `false`: such a link is dropped.
+     */
+    selfLinks?: boolean;
+}
 /** What syntax produced a `BodyLink`. */
 export type BodyLinkKind = 'wikilink' | 'embed' | 'markdown';
 /** One outgoing reference found in a body, with its span, before resolution. */
@@ -15,9 +29,16 @@ export interface BodyLink {
     /**
      * What resolution runs against. A wikilink's `raw` minus `#heading` /
      * `^block` / `|alias` and the `\` escaping the pipe; a markdown link's URL
-     * percent-decoded and minus a trailing `.md`.
+     * percent-decoded and minus a trailing `.md`. Empty for a link to the note
+     * it is written in (see `ScanOptions.selfLinks`).
      */
     target: string;
+    /** A wikilink's `#heading`, as `WikiLink.heading`. `null` for a markdown link. */
+    heading: string | null;
+    /** A wikilink's `#^block`, as `WikiLink.block`. `null` for a markdown link. */
+    block: string | null;
+    /** An embed's size, as `WikiLink.size`. */
+    size: Size | null;
     /**
      * A wikilink's or embed's `|alias`: the text after the first `|` outside
      * code, read from the body so code inside it is kept. `null` when there is
@@ -32,6 +53,40 @@ export interface BodyLink {
     start: number;
     end: number;
 }
+/**
+ * Why the scanner gave up on a `[[`. `'bracket'`: a `[` or `]` came before
+ * the closing `]]`. `'code'`: closed, but the target is empty once the code
+ * inside it is blanked. `'empty-target'`: closed with an empty target (`[[]]`,
+ * `[[ |alias]]`, or `[[#Heading]]` when `selfLinks` is off). `'unclosed'`: no
+ * `]]` before the end of the body.
+ */
+export type AbandonReason = 'bracket' | 'code' | 'empty-target' | 'unclosed';
+/**
+ * A `[[` the scanner found outside code and did not read as a link: what a
+ * renderer would otherwise leave in its output as literal brackets. A `[[`
+ * inside code, or inside an HTML comment when `skipHtmlComments` is on, is not
+ * reported, and nor is one that a link found after it starts inside:
+ * `[[[Note]]` is a literal `[` and a link. A run of `[` with no link after it,
+ * such as `[[[TODO`, is one entry: from the first `[[`, with the reason and
+ * end of the last.
+ */
+export interface AbandonedLink {
+    reason: AbandonReason;
+    /** Whether a `!` came before the `[[`. */
+    embed: boolean;
+    /**
+     * UTF-16 offsets of what the scanner read, from the `[[` (or the `!` before
+     * it): past the `]]` for `'code'` and `'empty-target'`, up to the `[` or `]`
+     * it stopped at for `'bracket'`, and the end of the body for `'unclosed'`.
+     */
+    start: number;
+    end: number;
+}
+/** What `scanBodyWith` found: the links, and the `[[` it gave up on. */
+export interface BodyScan {
+    links: BodyLink[];
+    abandoned: AbandonedLink[];
+}
 /** What kind of reference produced a `RawLink`. */
 export type LinkKind = 'wikilink' | 'embed';
 /** A body reference without its span. */
@@ -62,3 +117,14 @@ export declare function bodyLinks(body: string): RawLink[];
  * is one into the body, and a table converts it to a UTF-16 offset.
  */
 export declare function bodyLinksSpanned(body: string): BodyLink[];
+/**
+ * `bodyLinksSpanned` under `options`: which code rules apply, whether HTML
+ * comments hide links, and whether `[[#Heading]]` is a link. A comment is
+ * found after code is blanked, so a `<!--` inside code does not open one.
+ */
+export declare function bodyLinksSpannedWith(body: string, options: ScanOptions): BodyLink[];
+/**
+ * `bodyLinksSpannedWith`, and each `[[` it gave up on: one holding a `[` or
+ * `]`, one whose target is empty or only code, and one never closed.
+ */
+export declare function scanBodyWith(body: string, options: ScanOptions): BodyScan;

package/dist/body-links.js

@@ -2,8 +2,8 @@
  * 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";
+import { stripCodeWith } from "./code.js";
+import { isVaultLinkUrl, isWhitespace, mdLinkTarget, parseInner, parseInnerSelf, 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
@@ -27,7 +27,27 @@ export function bodyLinks(body) {
  * 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));
+    return bodyLinksSpannedWith(body, {});
+}
+/**
+ * `bodyLinksSpanned` under `options`: which code rules apply, whether HTML
+ * comments hide links, and whether `[[#Heading]]` is a link. A comment is
+ * found after code is blanked, so a `<!--` inside code does not open one.
+ */
+export function bodyLinksSpannedWith(body, options) {
+    return scanBodyWith(body, options).links;
+}
+/**
+ * `bodyLinksSpannedWith`, and each `[[` it gave up on: one holding a `[` or
+ * `]`, one whose target is empty or only code, and one never closed.
+ */
+export function scanBodyWith(body, options) {
+    const codeBlanked = stripCodeWith(body, options.codeRules ?? 'commonmark');
+    const skipComments = options.skipHtmlComments === true;
+    const chars = Array.from(skipComments ? blankComments(codeBlanked) : codeBlanked);
+    // With comments blanked too, the code points with only code blanked, made
+    // the first time an abandoned link needs them.
+    let codeChars = null;
     // Code point index -> UTF-16 offset in the body, plus an end sentinel.
     const at = [];
     let offset = 0;
@@ -39,18 +59,21 @@ export function bodyLinksSpanned(body) {
     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 [];
+        return { links: [], abandoned: [] };
     }
     const out = [];
+    const abandoned = [];
     const scan = new UrlScan();
     let i = 0;
     while (i < chars.length) {
         if (chars[i] === '[' && chars[i + 1] === '[') {
             const embed = i > 0 && chars[i - 1] === '!';
+            const start = at[embed ? i - 1 : i];
             let j = i + 2;
             let inner = '';
             let pipe = -1;
             let closed = false;
+            let bracket = false;
             while (j + 1 < chars.length) {
                 if (chars[j] === ']' && chars[j + 1] === ']') {
                     closed = true;
@@ -58,26 +81,56 @@ export function bodyLinksSpanned(body) {
                 }
                 // `[[` never nests, and `[` or `]` inside is a malformed link: stop
                 // rather than swallow the rest of the note.
-                if (chars[j] === '[' || chars[j] === ']')
+                if (chars[j] === '[' || chars[j] === ']') {
+                    bracket = true;
                     break;
+                }
                 if (pipe === -1 && chars[j] === '|')
                     pipe = j;
                 inner += chars[j];
                 j++;
             }
-            if (closed && inner !== '') {
-                const link = parseInner(inner, embed);
+            if (!closed) {
+                abandoned.push({
+                    reason: bracket ? 'bracket' : 'unclosed',
+                    embed,
+                    start,
+                    end: bracket ? at[j] : body.length,
+                });
+            }
+            if (closed) {
+                let link = null;
+                if (inner !== '') {
+                    link =
+                        options.selfLinks === true ? parseInnerSelf(inner, embed) : parseInner(inner, embed);
+                }
+                if (link === null) {
+                    // Code inside was blanked to spaces, so the body there differs from
+                    // the code-blanked text. A blanked comment is not code.
+                    const code = skipComments ? (codeChars ??= Array.from(codeBlanked)) : chars;
+                    const heldCode = body.slice(at[i + 2], at[j]) !== code.slice(i + 2, j).join('');
+                    abandoned.push({
+                        reason: heldCode ? 'code' : 'empty-target',
+                        embed,
+                        start,
+                        end: at[j + 2],
+                    });
+                }
                 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;
+                    dropOverlapped(abandoned, at[i]);
                     out.push({
                         kind: embed ? 'embed' : 'wikilink',
                         raw: inner,
                         target: link.target,
+                        heading: link.heading,
+                        block: link.block,
                         alias,
-                        start: at[embed ? i - 1 : i],
+                        size: link.size,
+                        start,
                         end: at[j + 2],
                     });
                 }
@@ -88,6 +141,7 @@ export function bodyLinksSpanned(body) {
         if (chars[i] === '[') {
             const found = markdownLink(chars, i, at, scan);
             if (found !== null) {
+                dropOverlapped(abandoned, at[i]);
                 out.push(found.link);
                 i = found.next;
                 continue;
@@ -95,8 +149,63 @@ export function bodyLinksSpanned(body) {
         }
         i++;
     }
+    return { links: out, abandoned: mergeRuns(abandoned) };
+}
+/**
+ * Folds each abandoned `[[` that starts inside the one before it into that
+ * one, so a run of `[` such as `[[[TODO` is one entry: from the first `[[`,
+ * with the reason and end of the last. As in `dropOverlapped`, an embed's `!`
+ * does not count: in `[[x![[y` the embed is its own entry.
+ */
+function mergeRuns(abandoned) {
+    const out = [];
+    for (const next of abandoned) {
+        const run = out[out.length - 1];
+        if (run !== undefined && next.start + (next.embed ? 1 : 0) < run.end) {
+            run.reason = next.reason;
+            run.end = next.end;
+        }
+        else {
+            out.push(next);
+        }
+    }
     return out;
 }
+/**
+ * Drops each abandoned `[[` whose second `[` opens a link: `bracket` is the
+ * offset of the link's first `[`, after any `!`. After a `[` or `]` the
+ * scanner moves on one code point, so `[[[Note]]` is a literal `[` and a link,
+ * not a `[[` given up on. An embed's `!` right after an abandoned `[[`, as in
+ * `[[x![[B]]`, does not count.
+ */
+function dropOverlapped(abandoned, bracket) {
+    for (;;) {
+        const last = abandoned[abandoned.length - 1];
+        if (last === undefined || last.start + (last.embed ? 1 : 0) + 2 <= bracket)
+            return;
+        abandoned.pop();
+    }
+}
+/**
+ * `text` with every HTML comment, `<!--` to `-->` or the end, blanked to
+ * spaces, newlines kept. The code point count does not change.
+ */
+function blankComments(text) {
+    let out = '';
+    let rest = text;
+    for (;;) {
+        const open = rest.indexOf('<!--');
+        if (open === -1)
+            break;
+        out += rest.slice(0, open);
+        const close = rest.indexOf('-->', open + 4);
+        const end = close === -1 ? rest.length : close + 3;
+        for (const c of rest.slice(open, end))
+            out += c === '\n' ? '\n' : ' ';
+        rest = rest.slice(end);
+    }
+    return out + rest;
+}
 /**
  * `[text](relative/note.md)` starting at `start`, and the code point index
  * just past it, or `null` when this is not one.
@@ -135,7 +244,10 @@ function markdownLink(chars, start, at, scan) {
             kind: 'markdown',
             raw: url,
             target: mdLinkTarget(url),
+            heading: null,
+            block: null,
             alias: null,
+            size: null,
             start: at[start],
             end: at[end],
         },

package/dist/display.js

@@ -2,7 +2,7 @@
  * What a reader sees for a link, and typed references. A port of the
  * `markdown-link` crate's `display_text` and `parse_typed_ref`.
  */
-import { isWhitespace, parseInner, splitAlias, trim } from "./parse.js";
+import { isSizeSpec, isWhitespace, parseInner, splitAlias, trim } from "./parse.js";
 /**
  * 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
@@ -50,15 +50,11 @@ function shown(link) {
     if (alias !== null && link.embed) {
         const pipe = alias.lastIndexOf('|');
         const last = pipe === -1 ? alias : alias.slice(pipe + 1);
-        if (isSize(trim(last)))
+        if (isSizeSpec(trim(last)))
             alias = pipe === -1 ? '' : trim(alias.slice(0, pipe));
     }
     return alias || link.target;
 }
-/** `300` or `300x200`: an embed's width, or width and height. */
-function isSize(s) {
-    return /^[0-9]+(?:x[0-9]+)?$/.test(s);
-}
 /**
  * Parse a whole value as a typed reference, or `null`.
  *

package/dist/index.d.ts

@@ -8,6 +8,6 @@
  * The Rust crate reports byte offsets.
  */
 export { type CodeRules, stripCode, stripCodeWith } from './code.ts';
-export { ATTACHMENT_EXTENSIONS, type TextRange, type WikiLink, isVaultLinkUrl, mdLinkTarget, parseInner, targetRange, } from './parse.ts';
+export { ATTACHMENT_EXTENSIONS, type Size, type TextRange, type WikiLink, isSizeSpec, isVaultLinkUrl, mdLinkTarget, parseInner, parseInnerSelf, parseSize, percentDecode, targetRange, } from './parse.ts';
 export { type TypedRef, displayText, parseTypedRef } from './display.ts';
-export { type BodyLink, type BodyLinkKind, type LinkKind, type RawLink, bodyLinks, bodyLinksSpanned, } from './body-links.ts';
+export { type AbandonReason, type AbandonedLink, type BodyLink, type BodyLinkKind, type BodyScan, type LinkKind, type RawLink, type ScanOptions, bodyLinks, bodyLinksSpanned, bodyLinksSpannedWith, scanBodyWith, } from './body-links.ts';

package/dist/index.js

@@ -8,6 +8,6 @@
  * The Rust crate reports byte offsets.
  */
 export { stripCode, stripCodeWith } from "./code.js";
-export { ATTACHMENT_EXTENSIONS, isVaultLinkUrl, mdLinkTarget, parseInner, targetRange, } from "./parse.js";
+export { ATTACHMENT_EXTENSIONS, isSizeSpec, isVaultLinkUrl, mdLinkTarget, parseInner, parseInnerSelf, parseSize, percentDecode, targetRange, } from "./parse.js";
 export { displayText, parseTypedRef } from "./display.js";
-export { bodyLinks, bodyLinksSpanned, } from "./body-links.js";
+export { bodyLinks, bodyLinksSpanned, bodyLinksSpannedWith, scanBodyWith, } from "./body-links.js";

package/dist/parse.d.ts

@@ -5,11 +5,33 @@
  */
 /** A parsed `[[target#heading|alias]]`. */
 export interface WikiLink {
+    /** The target, trimmed, minus any `#heading`, `#^block` and `|alias`. */
     target: string;
+    /**
+     * The text after the first `#`, trimmed, unless it starts with `^`, which
+     * makes it a `block`. A heading path such as `Parent#Child` keeps its inner `#`.
+     */
     heading: string | null;
+    /** A block reference, `Note#^id`: the text after `#^`, trimmed. */
+    block: string | null;
+    /** The text after the first `|`, trimmed. An embed's size stays in it as written. */
     alias: string | null;
+    /** An embed's `|300` or `|300x200`, read from the last `|` part of its alias. */
+    size: Size | null;
     embed: boolean;
 }
+/** An embed's display size, `|300` (width) or `|300x200` (width and height). */
+export interface Size {
+    width: number;
+    height: number | null;
+}
+/** Whether `spec` is an image size, `300` or `300x200`. */
+export declare function isSizeSpec(spec: string): boolean;
+/**
+ * Read `300` or `300x200` as a `Size`. `null` for anything else, and for a
+ * number too large for the Rust crate's `u32`.
+ */
+export declare function parseSize(spec: string): Size | null;
 /** A half-open range of UTF-16 offsets, `[start, end)`. */
 export interface TextRange {
     start: number;
@@ -25,6 +47,12 @@ export interface TextRange {
  * a `#heading` or an `|alias`.
  */
 export declare function parseInner(inner: string, embed: boolean): WikiLink | null;
+/**
+ * `parseInner`, except that a body with no target and a `#` fragment, such as
+ * `#Heading` or `#^block`, is a link to the note it is written in: its target
+ * is empty. This is how Obsidian reads `[[#Heading]]`.
+ */
+export declare function parseInnerSelf(inner: string, embed: boolean): WikiLink | null;
 /**
  * The range of `parseInner`'s target within `inner`, for a caller that
  * rewrites the target in place and must leave the rest of the link as written.
@@ -66,3 +94,10 @@ export declare function isVaultLinkUrl(url: string): boolean;
  * off.
  */
 export declare function mdLinkTarget(url: string): string;
+/**
+ * Percent-decode a string over its UTF-8 bytes, as the Rust crate's
+ * `percent_decode` does. Each valid `%XX` decodes on its own, so a stray `%`
+ * (`100%`) stays as written. Bytes that do not decode to UTF-8 leave the whole
+ * string as written, rather than becoming U+FFFD.
+ */
+export declare function percentDecode(s: string): string;

package/dist/parse.js

@@ -3,6 +3,25 @@
  * crate's `parse_inner`, `target_range`, `is_vault_link_url` and
  * `md_link_target`.
  */
+/** Whether `spec` is an image size, `300` or `300x200`. */
+export function isSizeSpec(spec) {
+    return /^[0-9]+(?:x[0-9]+)?$/.test(spec);
+}
+/**
+ * Read `300` or `300x200` as a `Size`. `null` for anything else, and for a
+ * number too large for the Rust crate's `u32`.
+ */
+export function parseSize(spec) {
+    if (!isSizeSpec(spec))
+        return null;
+    const [w, h] = spec.split('x');
+    const width = Number(w);
+    const height = h === undefined ? null : Number(h);
+    const fits = (n) => n <= 0xffffffff;
+    if (!fits(width) || (height !== null && !fits(height)))
+        return null;
+    return { width, height };
+}
 /**
  * Parse a single wikilink body (the text between the brackets).
  *
@@ -16,14 +35,42 @@ export function parseInner(inner, embed) {
     const target = targetRange(inner);
     if (target === null)
         return null;
-    const [beforeAlias, alias] = splitAlias(inner);
+    return parseParts(inner, inner.slice(target.start, target.end), embed);
+}
+/**
+ * `parseInner`, except that a body with no target and a `#` fragment, such as
+ * `#Heading` or `#^block`, is a link to the note it is written in: its target
+ * is empty. This is how Obsidian reads `[[#Heading]]`.
+ */
+export function parseInnerSelf(inner, embed) {
+    const link = parseInner(inner, embed);
+    if (link !== null)
+        return link;
+    const [beforeAlias] = splitAlias(inner);
+    if (!trimStart(beforeAlias).startsWith('#'))
+        return null;
+    return parseParts(inner, '', embed);
+}
+/** The fragment, alias and size of `inner`, around an already-found target. */
+function parseParts(inner, target, embed) {
+    const [beforeAlias, rawAlias] = splitAlias(inner);
     const hash = beforeAlias.indexOf('#');
-    return {
-        target: inner.slice(target.start, target.end),
-        heading: hash === -1 ? null : trim(beforeAlias.slice(hash + 1)),
-        alias: alias === null ? null : trim(alias),
-        embed,
-    };
+    let heading = null;
+    let block = null;
+    if (hash !== -1) {
+        const fragment = trim(beforeAlias.slice(hash + 1));
+        if (fragment.startsWith('^'))
+            block = trim(fragment.slice(1));
+        else
+            heading = fragment;
+    }
+    const alias = rawAlias === null ? null : trim(rawAlias);
+    let size = null;
+    if (embed && alias !== null) {
+        const pipe = alias.lastIndexOf('|');
+        size = parseSize(trim(pipe === -1 ? alias : alias.slice(pipe + 1)));
+    }
+    return { target, heading, block, alias, size, embed };
 }
 /**
  * The range of `parseInner`'s target within `inner`, for a caller that
@@ -165,10 +212,12 @@ function stripMdExt(s) {
 }
 const utf8Decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
 /**
- * Percent-decode a URL over its UTF-8 bytes. Bytes that do not decode to UTF-8
- * leave the URL as written, rather than becoming U+FFFD.
+ * Percent-decode a string over its UTF-8 bytes, as the Rust crate's
+ * `percent_decode` does. Each valid `%XX` decodes on its own, so a stray `%`
+ * (`100%`) stays as written. Bytes that do not decode to UTF-8 leave the whole
+ * string as written, rather than becoming U+FFFD.
  */
-function percentDecode(s) {
+export function percentDecode(s) {
     if (!s.includes('%'))
         return s;
     const bytes = new TextEncoder().encode(s);
@@ -193,18 +242,11 @@ function percentDecode(s) {
         return s;
     }
 }
-/**
- * Two bytes read as Rust's `u8::from_str_radix(_, 16)` reads them: two hex
- * digits, or a `+` sign and one hex digit.
- */
+/** Two bytes read as two hex digits, or `null`. A sign is not a digit. */
 function hexByte(a, b) {
-    const low = hexDigit(b);
-    if (low === null)
-        return null;
-    if (a === 0x2b)
-        return low;
     const high = hexDigit(a);
-    return high === null ? null : high * 16 + low;
+    const low = hexDigit(b);
+    return high === null || low === null ? null : high * 16 + low;
 }
 function hexDigit(byte) {
     if (byte >= 0x30 && byte <= 0x39)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osdlc/markdown-link",
-  "version": "0.5.0",
+  "version": "0.8.0",
   "description": "Wikilink parsing that follows documented link-resolution conventions: every [[link]], ![[embed]] and relative markdown link in a note body, with spans, and the code lexer that keeps links in code out. The TypeScript twin of the parsing half of the Rust markdown-link crate, held to it by a shared case file. No dependencies.",
   "license": "MIT OR Apache-2.0",
   "author": "sksizer",