@wdprlib/parser 5.3.0 → 6.0.0

package/src/parser/rules/inline/anchor/index.ts

@@ -1,3 +1,4 @@
+import { precedingSingleNewline } from "../parsing/automatic-line-break";
 /**
  *
  * Parses the Wikidot anchor inline block syntax: `[[a]]...[[/a]]`.
@@ -10,7 +11,8 @@
  * - `[[a_ href="url"]]text[[/a]]` -- paragraph strip mode (trailing underscore)
  *
  * Paragraph strip mode (`[[a_]]`) suppresses newlines within the anchor
- * body and strips at most one trailing newline after the closing tag
+ * body and strips at most one automatic newline before the opening tag
+ * and one trailing newline after the closing tag
  * (preserving double newlines as paragraph breaks). This prevents
  * unwanted `<br>` elements when consecutive anchor blocks are placed on
  * separate lines.
@@ -98,6 +100,7 @@ export const anchorRule: InlineRule = {
         },
       ],
       consumed,
+      stripLeadingLineBreak: openResult.paragraphStrip ? precedingSingleNewline(ctx) : undefined,
     };
   },
 };

package/src/parser/rules/inline/anchor/newline.ts

@@ -1,3 +1,4 @@
+import { createAutomaticLineBreak } from "../parsing/automatic-line-break";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
 
@@ -15,7 +16,7 @@ export function consumeAnchorNewline(
   let nextPos = pos + 1;
 
   if (!paragraphStrip) {
-    children.push({ element: "line-break" });
+    children.push(createAutomaticLineBreak(ctx.tokens[pos]!));
     while (ctx.tokens[nextPos]?.type === "WHITESPACE" && ctx.tokens[nextPos]?.lineStart) {
       nextPos++;
       consumed++;

package/src/parser/rules/inline/autolink.ts

@@ -0,0 +1,153 @@
+/**
+ *
+ * Parses bare URLs in plain text into links (auto-linking).
+ *
+ * Wikidot converts bare URLs like `http://example.com/page` into
+ * `<a href="URL">URL</a>` without any bracket syntax. A `*` prefix
+ * (`*http://...`) opens the link in a new tab.
+ *
+ * Mirrors Text_Wiki's Url rule (Parse/Default/Url.php):
+ * - Recognized schemes: `http://`, `https://`, `ftp://`, `gopher://`,
+ *   `news://`, `mms://`, and `mailto:`
+ * - A URL is only recognized at line start or after a non-alphabetic
+ *   character (`(^|[^A-Za-z])` in the original regex)
+ * - The final character of a URL must be alphanumeric or one of
+ *   `%/?=&~_`, so trailing punctuation (`.`, `,`, `)` etc.) stays as text
+ *
+ * Produces a `"link"` AST element with `type: "direct"`.
+ *
+ * @module
+ */
+import type { AnchorTarget, Element } from "@wdprlib/ast";
+import type { TokenType } from "../../../lexer";
+import { URL_PATTERN, URL_SCHEME_NAMES } from "../../../lexer/url-schemes";
+import type { InlineRule, ParseContext, RuleResult } from "../types";
+import { rawRegionEnd } from "./raw/end";
+
+/**
+ * Structural block/link delimiters that terminate a bare URL. Wikitext
+ * constructs like `[[span]]…[[/span]]` and `[[[page]]]` are resolved before
+ * URLs in Text_Wiki (their bodies are delimiter-wrapped), so a bare URL must
+ * not swallow the enclosing scope's close marker (e.g. the `[[/span]]` in
+ * `[[span]]http://x/[[/span]]`).
+ */
+const URL_BOUNDARY_TOKENS: ReadonlySet<TokenType> = new Set<TokenType>([
+  "WHITESPACE",
+  "NEWLINE",
+  "EOF",
+  "BLOCK_OPEN",
+  "BLOCK_END_OPEN",
+  "BLOCK_CLOSE",
+  "LINK_OPEN",
+  "LINK_CLOSE",
+  "COMMENT_OPEN",
+  "BACKSLASH_BREAK",
+]);
+
+/**
+ * Inline rule for auto-linking bare URLs.
+ *
+ * Triggered by an `IDENTIFIER` token whose value is a URL scheme name,
+ * or by a `*` prefix (`STAR` mid-line, `LIST_BULLET` at line start —
+ * the list rule requires a space after the marker, so `*http://...`
+ * falls through to inline parsing).
+ */
+export const autolinkRule: InlineRule = {
+  name: "autolink",
+  startTokens: ["IDENTIFIER", "STAR", "LIST_BULLET"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    let pos = ctx.pos;
+    let target: AnchorTarget | null = null;
+
+    const first = ctx.tokens[pos];
+    if (!first) {
+      return { success: false };
+    }
+
+    if (first.type === "STAR" || first.type === "LIST_BULLET") {
+      if (first.value !== "*") {
+        return { success: false };
+      }
+      target = "new-tab";
+      pos++;
+    }
+
+    const scheme = ctx.tokens[pos];
+    if (scheme?.type !== "IDENTIFIER" || !URL_SCHEME_NAMES.has(scheme.value)) {
+      return { success: false };
+    }
+    if (ctx.tokens[pos + 1]?.type !== "COLON") {
+      return { success: false };
+    }
+
+    // Text_Wikiの前置条件 `(^|[^A-Za-z])`: 行頭または非英字の直後でのみURLと認識する
+    const prev = ctx.tokens[ctx.pos - 1];
+    if (prev && !first.lineStart) {
+      const lastChar = prev.value[prev.value.length - 1] ?? "";
+      if (/[A-Za-z]/.test(lastChar)) {
+        return { success: false };
+      }
+    }
+
+    // URL候補: 空白・改行・構造デリミタの手前までのトークン列を文字列として連結する。
+    // ブロック/リンクの開閉トークン（[[ ]] [[/ [[[ ]]]）で止めることで、
+    // 囲みスコープの閉じマーカー（[[/span]]等）をURLに取り込まないようにする
+    const values: string[] = [];
+    let end = pos;
+    const inlineEnd = ctx.scope.inlineEnd ?? ctx.tokens.length;
+    while (end < inlineEnd) {
+      const token = ctx.tokens[end];
+      if (!token || URL_BOUNDARY_TOKENS.has(token.type)) {
+        break;
+      }
+      if (token.type === "RAW_OPEN" || token.type === "RAW_BLOCK_OPEN") {
+        if (rawRegionEnd(ctx.tokens, end, inlineEnd) > end) break;
+      }
+      values.push(token.value);
+      end++;
+      // Compact TEXT tokens can contain whitespace; do not scan subsequent URLs again.
+      if (/[ \t\n\\"']/.test(token.value)) break;
+    }
+
+    const candidate = values.join("");
+    const match = URL_PATTERN.exec(candidate);
+    if (!match) {
+      return { success: false };
+    }
+
+    // マッチ全体を含むところまでトークンを消費する。大きなソースの一括テキスト化では
+    // `page. b` のようにURL末尾と後続テキストが同一トークンに融合するため、マッチ終端が
+    // トークン中間に落ちた場合は残り部分をテキスト要素として返す
+    const url = match[0];
+    let length = 0;
+    let count = 0;
+    while (length < url.length) {
+      length += values[count]?.length ?? 0;
+      count++;
+    }
+    const rest = candidate.slice(url.length, length);
+
+    const elements: Element[] = [
+      {
+        element: "link",
+        data: {
+          type: "direct",
+          link: url,
+          extra: null,
+          label: { text: url },
+          target,
+        },
+      },
+    ];
+    if (rest !== "") {
+      elements.push({ element: "text", data: rest });
+    }
+
+    return {
+      success: true,
+      elements,
+      consumed: pos - ctx.pos + count,
+    };
+  },
+};

package/src/parser/rules/inline/button/attributes.ts

@@ -0,0 +1,17 @@
+/** Button's quoted attributes use Text_Wiki's getAttrs splitting rules. */
+export function parseButtonAttributes(source: string): Record<string, string> {
+  const sections = source.trim().split('="');
+  const attrs: Record<string, string> = {};
+  let key = sections[0]!.trim();
+  for (const section of sections.slice(1)) {
+    const quote = section.lastIndexOf('"');
+    if (quote < 0) continue;
+    if (key === "text" || key === "class" || key === "style") {
+      attrs[key] = section
+        .slice(0, quote)
+        .replace(/\\([\s\S]|$)/g, (_match, char: string) => (char === "0" ? "\0" : char));
+    }
+    key = section.slice(quote + 1).trim();
+  }
+  return attrs;
+}

package/src/parser/rules/inline/button/index.ts

@@ -0,0 +1,17 @@
+import type { InlineRule } from "../../types";
+import { parseButtonSyntax } from "./syntax";
+
+export const buttonRule: InlineRule = {
+  name: "button",
+  startTokens: ["BLOCK_OPEN"],
+  parse(ctx) {
+    const result = parseButtonSyntax(ctx, ctx.pos, ctx.scope.inlineEnd ?? ctx.tokens.length);
+    return result
+      ? {
+          success: true,
+          consumed: result.end - ctx.pos,
+          elements: [{ element: "button", data: result.data }],
+        }
+      : { success: false };
+  },
+};

package/src/parser/rules/inline/button/syntax.ts

@@ -0,0 +1,56 @@
+import type { PageButtonData } from "@wdprlib/ast";
+import { findRawTagClose } from "../parsing/raw-tag";
+import type { ParseContext } from "../../types";
+import { parseButtonAttributes } from "./attributes";
+
+interface ButtonSyntax {
+  data: PageButtonData;
+  end: number;
+}
+
+/** Read a complete standalone button, including permitted separator newlines. */
+export function parseButtonSyntax(
+  ctx: ParseContext,
+  start: number,
+  end: number,
+): ButtonSyntax | null {
+  const tokens = ctx.tokens;
+  if (tokens[start]?.type !== "BLOCK_OPEN" || tokens[start + 1]?.value.toLowerCase() !== "button")
+    return null;
+  let pos = start + 2;
+  const skipSpace = () => {
+    const before = pos;
+    while (pos < end && /^\s+$/.test(tokens[pos]?.value ?? "")) pos++;
+    return pos > before;
+  };
+  if (!skipSpace()) return null;
+  let action = "";
+  while (
+    pos < end &&
+    tokens[pos]?.type !== "BLOCK_CLOSE" &&
+    !/^\s+$/.test(tokens[pos]?.value ?? "")
+  ) {
+    const part = tokens[pos]?.value ?? "";
+    if (!/^[a-z0-9_-]+$/i.test(part)) return null;
+    action += part;
+    pos++;
+  }
+  if (!action) return null;
+  action = action.replaceAll("_", "-");
+  skipSpace();
+  const close = findRawTagClose(tokens, pos, end);
+  if (close === null) return null;
+  const attrs = parseButtonAttributes(
+    tokens
+      .slice(pos, close)
+      .map((token) => token.value)
+      .join(""),
+  );
+  const value = (key: string) => (attrs[key] && attrs[key] !== "0" ? attrs[key]! : null);
+  const attributes: Record<string, string> = {};
+  for (const name of ["class", "style"]) {
+    const attr = value(name);
+    if (attr !== null) attributes[name] = attr;
+  }
+  return { data: { action, text: value("text"), attributes }, end: close + 1 };
+}

package/src/parser/rules/inline/date/index.ts

@@ -0,0 +1,17 @@
+import type { InlineRule } from "../../types";
+import { parseDateSyntax } from "./syntax";
+
+export const dateRule: InlineRule = {
+  name: "date",
+  startTokens: ["BLOCK_OPEN"],
+  parse(ctx) {
+    const parsed = parseDateSyntax(ctx, ctx.pos, ctx.scope.inlineEnd ?? ctx.tokens.length);
+    return parsed
+      ? {
+          success: true,
+          consumed: parsed.end - ctx.pos,
+          elements: [{ element: "date", data: parsed.data }],
+        }
+      : { success: false };
+  },
+};

package/src/parser/rules/inline/date/syntax.ts

@@ -0,0 +1,46 @@
+import type { DateData } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseAttributesRaw } from "../../block/parsing/attributes";
+
+interface DateSyntax {
+  data: DateData;
+  end: number;
+}
+
+/** Read a complete date without registering any parser side effects. */
+export function parseDateSyntax(ctx: ParseContext, start: number, end: number): DateSyntax | null {
+  const tokens = ctx.tokens;
+  if (tokens[start]?.type !== "BLOCK_OPEN" || tokens[start + 1]?.value !== "date") return null;
+  let pos = start + 2;
+  const skipSpace = () => {
+    const before = pos;
+    while (pos < end && /^(?:\s+)$/.test(tokens[pos]?.value ?? "")) pos++;
+    return pos > before;
+  };
+  if (!skipSpace()) return null;
+  const value = tokens[pos]?.value ?? "";
+  if (pos >= end || !/^\d+$/.test(value)) return null;
+  const timestamp = Number(value);
+  if (!Number.isSafeInteger(timestamp) || timestamp > 8_640_000_000_000) return null;
+  pos++;
+  const separator = skipSpace();
+  if (tokens[pos]?.type !== "BLOCK_CLOSE" && !separator) return null;
+  let close = pos;
+  for (; close < end; close++) {
+    const token = tokens[close];
+    if (!token || token.type === "EOF" || token.type === "BLOCK_OPEN" || /[\r\n]/.test(token.value))
+      return null;
+    if (token.type === "BLOCK_CLOSE") break;
+  }
+  if (close >= end) return null;
+  const attributes = parseAttributesRaw(ctx, pos).attrs;
+  const format = attributes.format || null;
+  return {
+    data: {
+      value: { timestamp, timezone: "UTC" },
+      format,
+      hover: format?.split("|").slice(1).includes("agohover") ?? false,
+    },
+    end: close + 1,
+  };
+}

package/src/parser/rules/inline/email/candidates.ts

@@ -0,0 +1,134 @@
+import type { Token, TokenType } from "../../../../lexer";
+import { isLocalChar, scanEmail } from "./scan";
+
+export interface EmailCandidate {
+  start: number;
+  end: number;
+  endToken: number;
+  address: string;
+}
+
+interface EmailCache {
+  source: string;
+  offsets: number[];
+  candidates: Map<number, EmailCandidate | null>;
+  commentEnds: Map<number, number>;
+  unclosedComment: number;
+}
+
+const caches = new WeakMap<readonly Token[], EmailCache>();
+export const EMAIL_START_TOKENS: TokenType[] = [
+  "TEXT",
+  "IDENTIFIER",
+  "UNDERSCORE",
+  "UNDERLINE_MARKER",
+  "STRIKE_MARKER",
+];
+
+function getCache(tokens: readonly Token[]): EmailCache {
+  let cache = caches.get(tokens);
+  if (cache) return cache;
+  const offsets = [0];
+  const values: string[] = [];
+  for (const token of tokens) {
+    values.push(token.value);
+    offsets.push(offsets.at(-1)! + token.value.length);
+  }
+  cache = {
+    source: values.join(""),
+    offsets,
+    candidates: new Map(),
+    commentEnds: new Map(),
+    unclosedComment: Infinity,
+  };
+  caches.set(tokens, cache);
+  return cache;
+}
+
+function commentEnd(cache: EmailCache, pos: number): number {
+  const opener = cache.source[pos] === "\n" ? pos + 1 : pos;
+  if (!cache.source.startsWith("[!--", opener)) return pos;
+  const cached = cache.commentEnds.get(pos);
+  if (cached !== undefined) return cached;
+  const close = opener >= cache.unclosedComment ? -1 : cache.source.indexOf("--]", opener + 4);
+  if (close === -1) cache.unclosedComment = Math.min(cache.unclosedComment, opener);
+  const end = close === -1 ? pos : close + 3;
+  cache.commentEnds.set(pos, end);
+  return end;
+}
+
+export function getEmailCandidate(tokens: readonly Token[], index: number): EmailCandidate | null {
+  const token = tokens[index];
+  if (!token || !EMAIL_START_TOKENS.includes(token.type)) return null;
+  const cache = getCache(tokens);
+  if (cache.candidates.has(index)) return cache.candidates.get(index)!;
+  const value = tokens[index]?.value ?? "";
+  // Compact TEXT may include a prefix before the last possible local-part run.
+  let suffix = value.length;
+  while (suffix > 0 && (isLocalChar(value.charCodeAt(suffix - 1)) || value[suffix - 1] === "."))
+    suffix--;
+  const doubled = value.lastIndexOf("..");
+  if (doubled >= suffix) suffix = doubled + 2;
+  while (value[suffix] === ".") suffix++;
+  if (suffix >= value.length || !isLocalChar(value.charCodeAt(suffix))) {
+    cache.candidates.set(index, null);
+    return null;
+  }
+  const start = cache.offsets[index]! + suffix;
+  const scanned = scanEmail(cache.source, start, (pos) => commentEnd(cache, pos));
+  if (scanned.end === undefined) {
+    cache.candidates.set(index, null);
+    let comment = 0;
+    // A failed local run cannot produce an address from one of its suffix tokens.
+    // Do not poison positions inside skipped comments: another parse scope may see them as raw text.
+    for (let i = index + 1; i < tokens.length && cache.offsets[i + 1]! <= scanned.localEnd; i++) {
+      const offset = cache.offsets[i]!;
+      while (scanned.comments[comment] && scanned.comments[comment]!.end <= offset) comment++;
+      const region = scanned.comments[comment];
+      if (!region || offset < region.start) cache.candidates.set(i, null);
+    }
+    return null;
+  }
+  let endToken = index;
+  while (cache.offsets[endToken + 1]! < scanned.end) endToken++;
+  const candidate = { start, end: scanned.end, endToken, address: scanned.address! };
+  cache.candidates.set(index, candidate);
+  return candidate;
+}
+
+interface EmailGroup {
+  candidates: EmailCandidate[];
+  source: string;
+  start: number;
+  end: number;
+  endToken: number;
+}
+
+export function getEmailGroup(
+  tokens: readonly Token[],
+  index: number,
+  limit: number,
+): EmailGroup | null {
+  const first = getEmailCandidate(tokens, index);
+  if (!first || first.endToken >= limit) return null;
+  const candidates = [first];
+  let last = first;
+  while (last.endToken > index) {
+    const next = getEmailCandidate(tokens, last.endToken);
+    if (!next || next.start < last.end || next.endToken >= limit) break;
+    candidates.push(next);
+    last = next;
+  }
+  const cache = getCache(tokens);
+  return {
+    candidates,
+    source: cache.source,
+    start: cache.offsets[index]!,
+    end: cache.offsets[last.endToken + 1]!,
+    endToken: last.endToken + 1,
+  };
+}
+
+export function emailRegionEnd(tokens: readonly Token[], index: number, limit: number): number {
+  return getEmailGroup(tokens, index, limit)?.endToken ?? index;
+}

package/src/parser/rules/inline/email/index.ts

@@ -0,0 +1,36 @@
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule } from "../../types";
+import { EMAIL_START_TOKENS, getEmailGroup } from "./candidates";
+
+export const emailRule: InlineRule = {
+  name: "email",
+  startTokens: EMAIL_START_TOKENS,
+  parse(ctx) {
+    const group = getEmailGroup(ctx.tokens, ctx.pos, ctx.scope.inlineEnd ?? ctx.tokens.length);
+    if (!group) return { success: false };
+    const elements: Element[] = [];
+    let copied = group.start;
+    for (const candidate of group.candidates) {
+      if (copied < candidate.start)
+        elements.push({ element: "text", data: group.source.slice(copied, candidate.start) });
+      elements.push(
+        ctx.scope.suppressEmailLinks
+          ? { element: "text", data: candidate.address }
+          : {
+              element: "link",
+              data: {
+                type: "direct",
+                link: `mailto:${candidate.address}`,
+                label: { text: candidate.address },
+                target: null,
+                extra: null,
+              },
+            },
+      );
+      copied = candidate.end;
+    }
+    if (copied < group.end)
+      elements.push({ element: "text", data: group.source.slice(copied, group.end) });
+    return { success: true, elements, consumed: group.endToken - ctx.pos };
+  },
+};

package/src/parser/rules/inline/email/scan.ts

@@ -0,0 +1,76 @@
+export interface EmailScan {
+  end?: number;
+  address?: string;
+  localEnd: number;
+  comments: Array<{ start: number; end: number }>;
+}
+
+export function isDomainChar(code: number): boolean {
+  return (
+    (code >= 48 && code <= 57) ||
+    (code >= 65 && code <= 90) ||
+    (code >= 97 && code <= 122) ||
+    code === 45
+  );
+}
+
+export function isLocalChar(code: number): boolean {
+  return isDomainChar(code) || code === 95;
+}
+
+/** Read Email.php's grammar from one possible start, ignoring complete comments. */
+export function scanEmail(
+  source: string,
+  start: number,
+  commentEnd: (pos: number) => number,
+): EmailScan {
+  const comments: EmailScan["comments"] = [];
+  let pos = start;
+  const skipComments = () => {
+    let end = commentEnd(pos);
+    while (end > pos) {
+      comments.push({ start: pos, end });
+      pos = end;
+      end = commentEnd(pos);
+    }
+  };
+  let localPart = false;
+  while (pos < source.length) {
+    skipComments();
+    if (isLocalChar(source.charCodeAt(pos))) {
+      localPart = true;
+      pos++;
+    } else if (source[pos] === "." && localPart) {
+      localPart = false;
+      pos++;
+    } else break;
+  }
+  const localEnd = pos;
+  if (!localPart || source[pos] !== "@") return { localEnd, comments };
+  pos++;
+  let domainPart = false;
+  let dots = 0;
+  let end = -1;
+  while (pos < source.length) {
+    skipComments();
+    if (isDomainChar(source.charCodeAt(pos))) {
+      domainPart = true;
+      pos++;
+      if (dots > 0) end = pos;
+    } else if (source[pos] === "." && domainPart) {
+      domainPart = false;
+      dots++;
+      pos++;
+    } else break;
+  }
+  if (end === -1) return { localEnd, comments };
+  const parts: string[] = [];
+  let copied = start;
+  for (const comment of comments) {
+    if (comment.start >= end) break;
+    parts.push(source.slice(copied, comment.start));
+    copied = comment.end;
+  }
+  parts.push(source.slice(copied, end));
+  return { end, address: parts.join(""), localEnd, comments };
+}

package/src/parser/rules/inline/expr/branch.ts

@@ -1,3 +1,4 @@
+import { stripAutomaticLineBreak } from "../parsing/automatic-line-break";
 import type { Element } from "@wdprlib/ast";
 import type { ParseContext } from "../../types";
 import { getCandidateInlineRules } from "../utils";
@@ -52,7 +53,8 @@ export function parseInlineBranch(ctx: ParseContext, startPos: number): BranchPa
       }
       const result = rule.parse(inlineCtx);
       if (result.success) {
-        elements.push(...result.elements);
+        stripAutomaticLineBreak(elements, result.stripLeadingLineBreak);
+        for (const element of result.elements) elements.push(element);
         consumed += result.consumed;
         pos += result.consumed;
         matched = true;

package/src/parser/rules/inline/footnote/boundary.ts

@@ -0,0 +1,56 @@
+import { createOpaqueProbe, opaqueRuleEnd } from "../../opaque-probe";
+import type { ParseContext } from "../../types";
+import { codeBlockRule } from "../../block/code";
+import { htmlBlockRule } from "../../block/html";
+import { mathBlockRule } from "../../block/math";
+import { mathInlineRule } from "../math-inline";
+import { linkTripleRule } from "../link-triple";
+import { linkSingleRule } from "../link-single";
+import { linkStarRule } from "../link-star";
+import { linkAnchorRule } from "../link-anchor";
+import { protectedInlineRegionEnd } from "../raw/end";
+import { tryConsumeFootnoteClose } from "./close";
+import { parseFootnoteOpen } from "./open";
+
+const opaqueRules = [
+  codeBlockRule,
+  htmlBlockRule,
+  mathBlockRule,
+  mathInlineRule,
+  linkTripleRule,
+  linkSingleRule,
+  linkStarRule,
+  linkAnchorRule,
+];
+
+/** Locate the enclosing close without parsing code, HTML or math as footnote syntax. */
+export function findFootnoteEnd(ctx: ParseContext, start: number): number {
+  const probe = createOpaqueProbe(ctx);
+  let depth = 0;
+  for (let pos = start; pos < ctx.tokens.length; pos++) {
+    if (ctx.tokens[pos]?.type === "EOF") return pos;
+    const protectedEnd = protectedInlineRegionEnd(ctx.tokens, pos, ctx.tokens.length);
+    if (protectedEnd > pos) {
+      pos = protectedEnd - 1;
+      continue;
+    }
+
+    probe.pos = pos;
+    const close = tryConsumeFootnoteClose(probe, pos);
+    if (close) {
+      if (depth === 0) return pos;
+      depth--;
+      pos += close.consumed - 1;
+      continue;
+    }
+    const open = parseFootnoteOpen(probe);
+    if (open) {
+      depth++;
+      pos += open.consumed - 1;
+      continue;
+    }
+    const opaqueEnd = opaqueRuleEnd(probe, pos, opaqueRules);
+    if (opaqueEnd > pos) pos = opaqueEnd - 1;
+  }
+  return ctx.tokens.length;
+}