@wdprlib/parser 5.3.0 → 5.4.0

package/src/parser/rules/opaque-probe.ts

@@ -0,0 +1,58 @@
+import type { BlockRule, InlineRule, ParseContext } from "./types";
+import { findCodeOpen } from "./block/code/open";
+import { findCodeBodyBounds } from "./block/code/boundary";
+import { findMathOpen, findMathBodyBounds } from "./block/math/boundary";
+
+/** Probe opaque syntax without registering its code, footnotes or diagnostics. */
+export function createOpaqueProbe(ctx: ParseContext): ParseContext {
+  return {
+    ...ctx,
+    diagnostics: [],
+    footnotes: [],
+    tocEntries: [],
+    codeBlocks: [],
+    htmlBlocks: [],
+    bibcites: [],
+    scope: {
+      ...ctx.scope,
+      inlineEnd: undefined,
+      tableFormatting: undefined,
+      blockCloseCondition: () => true,
+    },
+  };
+}
+
+export function opaqueRuleEnd(
+  probe: ParseContext,
+  pos: number,
+  rules: readonly (BlockRule | InlineRule)[],
+  requireClosed: boolean = false,
+): number {
+  const token = probe.tokens[pos];
+  if (!token) return pos;
+  probe.pos = pos;
+  for (const rule of rules) {
+    if (!rule.startTokens.includes(token.type)) continue;
+    if (rule.name === "code") {
+      const open = findCodeOpen(probe.tokens, pos);
+      if (!open) continue;
+      if (open.closingSwallowed) {
+        if (!requireClosed) return open.bodyStart;
+        continue;
+      }
+      const bounds = findCodeBodyBounds(probe.tokens, open.bodyStart);
+      if (!requireClosed || bounds.foundClose) return bounds.end;
+      continue;
+    }
+    if (rule.name === "math") {
+      const open = findMathOpen(probe.tokens, pos);
+      if (!open) continue;
+      const bounds = findMathBodyBounds(probe.tokens, open.bodyStart);
+      if (bounds.hasContent && (!requireClosed || bounds.foundClose)) return bounds.end;
+      continue;
+    }
+    const result = rule.parse(probe);
+    if (result.success) return pos + result.consumed;
+  }
+  return pos;
+}

package/src/parser/rules/block/math/content.ts

@@ -1,54 +0,0 @@
-import type { ParseContext } from "../../types";
-import { parseBlockName } from "../utils";
-
-export interface MathContentResult {
-  latexSource: string;
-  consumed: number;
-  foundClose: boolean;
-}
-
-export function collectMathContent(ctx: ParseContext, startPos: number): MathContentResult {
-  let latexSource = "";
-  let pos = startPos;
-  let consumed = 0;
-  let foundClose = false;
-
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (!token) break;
-
-    if (token.type === "BLOCK_END_OPEN") {
-      const closeNameResult = parseBlockName(ctx, pos + 1);
-      if (closeNameResult?.name === "math") {
-        foundClose = true;
-        break;
-      }
-    }
-
-    latexSource += token.type === "BACKSLASH_BREAK" ? "\\\n" : token.value;
-    pos++;
-    consumed++;
-  }
-
-  return { latexSource, consumed, foundClose };
-}
-
-export function consumeMathClose(ctx: ParseContext, startPos: number): number {
-  let pos = startPos + 1;
-  let consumed = 1;
-
-  const closeNameResult = parseBlockName(ctx, pos);
-  if (closeNameResult) {
-    pos += closeNameResult.consumed;
-    consumed += closeNameResult.consumed;
-  }
-  if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
-    pos++;
-    consumed++;
-  }
-  if (ctx.tokens[pos]?.type === "NEWLINE") {
-    consumed++;
-  }
-
-  return consumed;
-}

package/src/parser/rules/block/math/name.ts

@@ -1,35 +0,0 @@
-import type { ParseContext } from "../../types";
-
-export interface MathNameResult {
-  name: string | null;
-  consumed: number;
-}
-
-export function parseMathName(ctx: ParseContext, startPos: number): MathNameResult {
-  let pos = startPos;
-  let consumed = 0;
-  let name = "";
-
-  const first = ctx.tokens[pos];
-  if (first?.type !== "IDENTIFIER" && first?.type !== "TEXT") {
-    return { name: null, consumed: 0 };
-  }
-
-  while (pos < ctx.tokens.length) {
-    const token = ctx.tokens[pos];
-    if (
-      !token ||
-      token.type === "BLOCK_CLOSE" ||
-      token.type === "WHITESPACE" ||
-      token.type === "NEWLINE"
-    ) {
-      break;
-    }
-
-    name += token.value;
-    pos++;
-    consumed++;
-  }
-
-  return { name: name === "" ? null : name, consumed };
-}

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

@@ -1,22 +0,0 @@
-import type { Element } from "@wdprlib/ast";
-import type { ParseContext } from "../../types";
-import { parseInlineUntil } from "../utils";
-
-export interface FootnoteChildResult {
-  elements: Element[];
-  consumed: number;
-}
-
-export function parseFootnoteChild(ctx: ParseContext, pos: number): FootnoteChildResult {
-  const token = ctx.tokens[pos];
-  if (!token) {
-    return { elements: [], consumed: 0 };
-  }
-
-  const inlineResult = parseInlineUntil({ ...ctx, pos }, "BLOCK_END_OPEN");
-  if (inlineResult.elements.length > 0) {
-    return { elements: inlineResult.elements, consumed: inlineResult.consumed };
-  }
-
-  return { elements: [{ element: "text", data: token.value }], consumed: 1 };
-}

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

@@ -1,27 +0,0 @@
-import type { ParseContext } from "../../types";
-
-export interface FootnoteNewlineResult {
-  consumed: number;
-  paragraphBreak: boolean;
-}
-
-export function consumeFootnoteNewline(ctx: ParseContext, pos: number): FootnoteNewlineResult {
-  let nextPos = pos + 1;
-  let consumed = 1;
-
-  while (ctx.tokens[nextPos]?.type === "WHITESPACE") {
-    nextPos++;
-    consumed++;
-  }
-
-  if (ctx.tokens[nextPos]?.type !== "NEWLINE") {
-    return { consumed, paragraphBreak: false };
-  }
-
-  while (ctx.tokens[nextPos]?.type === "NEWLINE") {
-    nextPos++;
-    consumed++;
-  }
-
-  return { consumed, paragraphBreak: true };
-}