@jianwen-lang/parser 0.1.1 → 0.1.3

package/README.md

@@ -1,4 +1,4 @@
-# @jianwen-lang/parser `0.1.0`
+# @jianwen-lang/parser `0.1.2`
 
 Jianwen（简文）是一种类似 Markdown 的轻量级标记语言，针对网页博客、公众号等内容发布场景的排版能力进行优化。本包提供 Jianwen 的 **TypeScript 核心解析器**（输出结构化 AST）以及 **HTML 渲染器**，用于在编辑器、渲染服务、静态站点生成等场景复用同一套解析语义。
 
@@ -55,6 +55,19 @@ const { html, ast, errors } = renderJianwenToHtmlDocument(source, {
 });
 ```
 
+如果你在做编辑器并需要“渲染区块 ↔ 源码行范围”映射（例如拖拽区块后回写源码），可以使用：
+
+```ts
+import { renderJianwenToHtmlDocumentWithBlockMap } from '@jianwen-lang/parser';
+
+const result = renderJianwenToHtmlDocumentWithBlockMap(source, {
+  document: { format: true },
+});
+
+console.log(result.groups);
+// [{ id, kind, startLine, endLine, readOnly, origin? }, ...]
+```
+
 ## Include：文件/标签展开（可选）
 
 解析阶段支持将 `[@](path)`（文件 include）或 `[@=tag]`（标签 include）按需展开。开启方式：
@@ -83,8 +96,38 @@ const { ast, errors } = parseJianwenWithErrors(source, {
   - `ParseOptions`：`expandInclude` / `includeMaxDepth` / `loadFile`
 - 渲染
   - `renderDocumentToHtml(doc, options?) => string`
+  - `renderDocumentToHtmlWithBlockMap(doc, options?) => { html; groups }`
   - `renderJianwenToHtmlDocument(source, options?) => { html; ast; errors }`
+  - `renderJianwenToHtmlDocumentWithBlockMap(source, options?) => { html; ast; errors; groups }`
   - `buildHtmlDocument(bodyHtml, options?) => string`
+  - `composeThemeCss(options?) => string`（`preset: 'default' | 'none'`，支持 `theme` token 对象与 `extraCss` 追加覆盖）
+  - `renderThemeTokenCss(theme) => string`
+  - `JIANWEN_THEME_TOKEN_KEYS` / `JianwenThemeConfig` / `JianwenThemeTokenValues`
+
+## 主题对象（Token）注入
+
+`JianwenThemeConfig` 支持局部覆盖：`light` / `dark` 可只写需要改动的 token，未提供项自动回退到默认主题。
+
+```ts
+import {
+  composeThemeCss,
+} from '@jianwen-lang/parser';
+
+const css = composeThemeCss({
+  preset: 'default',
+  theme: {
+    light: { '--jw-strong-color': '#0b766e' },
+    dark: { '--jw-strong-color': '#79e9dc' },
+    includeAutoDark: true,
+  },
+});
+```
+
+CLI 也支持通过 `--theme-file` 注入 JSON 文件（同样支持局部覆盖）：
+
+```bash
+jw-render input.jw --out out.html --theme-file ./theme.json
+```
 
 ## 规范与扩展
 

package/dist/cli/render.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runRenderCli = runRenderCli;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const theme_1 = require("../html/theme/theme");
 const convert_1 = require("../html/convert");
 const TAB_WIDTH = 4;
 function isCombiningCodePoint(code) {
@@ -89,6 +90,7 @@ function parseCliArgs(argv) {
     let format = false;
     let includeCss = true;
     let cssHref;
+    let themeFilePath;
     let includeRuntime = false;
     let runtimeSrc;
     let includeComments = false;
@@ -128,6 +130,14 @@ function parseCliArgs(argv) {
             includeCss = true;
             continue;
         }
+        if (arg === '--theme-file') {
+            const value = args.shift();
+            if (!value)
+                throw new Error('Missing value for --theme-file');
+            themeFilePath = value;
+            includeCss = true;
+            continue;
+        }
         if (arg === '--runtime') {
             includeRuntime = true;
             continue;
@@ -157,6 +167,7 @@ Options:
   --format                 Beautify output HTML
   --no-css                 Do not inline CSS
   --css-href <href>        Link CSS instead of inlining
+  --theme-file <path>      Load Jianwen theme token JSON for CSS generation
   --runtime                Append runtime <script> tag (default src: ${convert_1.DEFAULT_RUNTIME_SRC})
   --runtime-src <src>      Override runtime <script src=...>
   --comments               Include comment nodes
@@ -173,12 +184,72 @@ Options:
         format,
         includeCss,
         cssHref,
+        themeFilePath,
         includeRuntime,
         runtimeSrc,
         includeComments,
         includeMeta,
     };
 }
+function validateThemeTokenMap(filePath, section, candidate) {
+    if (candidate === undefined) {
+        return undefined;
+    }
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+        throw new Error(`Theme file ${filePath} has invalid "${section}" section (expected object).`);
+    }
+    const expectedKeys = new Set(theme_1.JIANWEN_THEME_TOKEN_KEYS);
+    const tokenMap = candidate;
+    const actualKeys = Object.keys(tokenMap);
+    const unknownKeys = actualKeys.filter((key) => !expectedKeys.has(key));
+    if (unknownKeys.length > 0) {
+        throw new Error(`Theme file ${filePath} has unknown ${section} token(s): ${unknownKeys.join(', ')}`);
+    }
+    for (const key of actualKeys) {
+        if (typeof tokenMap[key] !== 'string') {
+            throw new Error(`Theme file ${filePath} token ${section}.${key} must be a string.`);
+        }
+    }
+    return tokenMap;
+}
+function loadThemeFromFile(themeFilePath) {
+    const absoluteThemePath = path.resolve(process.cwd(), themeFilePath);
+    if (!fs.existsSync(absoluteThemePath)) {
+        throw new Error(`Theme file not found: ${absoluteThemePath}`);
+    }
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(absoluteThemePath, 'utf-8'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid theme JSON file ${absoluteThemePath}: ${message}`);
+    }
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error(`Theme file ${absoluteThemePath} must contain an object.`);
+    }
+    const parsed = raw;
+    const knownRootKeys = new Set(['light', 'dark', 'includeAutoDark']);
+    const unknownRootKeys = Object.keys(parsed).filter((key) => !knownRootKeys.has(key));
+    if (unknownRootKeys.length > 0) {
+        throw new Error(`Theme file ${absoluteThemePath} has unknown root field(s): ${unknownRootKeys.join(', ')}`);
+    }
+    const lightCandidate = parsed.light;
+    const darkCandidate = parsed.dark;
+    const lightOverrides = validateThemeTokenMap(absoluteThemePath, 'light', lightCandidate);
+    const darkOverrides = validateThemeTokenMap(absoluteThemePath, 'dark', darkCandidate);
+    if (parsed.includeAutoDark !== undefined && typeof parsed.includeAutoDark !== 'boolean') {
+        throw new Error(`Theme file ${absoluteThemePath} field includeAutoDark must be a boolean.`);
+    }
+    if (!lightOverrides && !darkOverrides) {
+        throw new Error(`Theme file ${absoluteThemePath} must provide at least one of "light" or "dark" token overrides.`);
+    }
+    return {
+        light: lightOverrides,
+        dark: darkOverrides,
+        includeAutoDark: parsed.includeAutoDark,
+    };
+}
 function runRenderCli(argv) {
     const options = parseCliArgs(argv);
     const absoluteInput = path.resolve(process.cwd(), options.inputFilePath);
@@ -188,6 +259,9 @@ function runRenderCli(argv) {
     }
     const baseDir = path.dirname(absoluteInput);
     const source = fs.readFileSync(absoluteInput, 'utf-8');
+    const themeConfig = options.includeCss && options.themeFilePath
+        ? loadThemeFromFile(options.themeFilePath)
+        : undefined;
     const sourceLines = source.split(/\r?\n/);
     const includeLineCache = new Map();
     const getIncludeLines = (target) => {
@@ -249,6 +323,7 @@ function runRenderCli(argv) {
     const documentOptions = {
         includeCss: options.includeCss,
         cssHref: options.cssHref,
+        theme: themeConfig,
         includeRuntime: options.includeRuntime,
         runtimeSrc: options.runtimeSrc,
         format: options.format,

package/dist/core/block/rules/attribute-line.d.ts

@@ -0,0 +1,13 @@
+import { BlockAttributes } from '../../ast';
+import { ParseError } from '../../errors';
+import { PendingBlockContext } from '../types';
+export interface ConsumeAttributeLineOptions {
+    text: string;
+    lineNumber: number;
+    errors: ParseError[];
+    pending: PendingBlockContext;
+    fallbackPosition?: BlockAttributes['position'];
+    tabCount?: number;
+}
+export declare function isAttributeOnlyLine(text: string): boolean;
+export declare function tryConsumeAttributeOnlyLine(options: ConsumeAttributeLineOptions): boolean;

package/dist/core/block/rules/attribute-line.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAttributeOnlyLine = isAttributeOnlyLine;
+exports.tryConsumeAttributeOnlyLine = tryConsumeAttributeOnlyLine;
+const diagnostics_1 = require("../../diagnostics");
+const include_1 = require("./include");
+const MULTI_ARROW_WARNING_CODE = 'layout-multi-arrow';
+const UNKNOWN_ATTRIBUTE_WARNING_CODE = 'unknown-attribute-token';
+function isAttributeOnlyLine(text) {
+    if (text.length === 0) {
+        return false;
+    }
+    const trimmed = text.trim();
+    if ((0, include_1.matchInclude)(trimmed)) {
+        return false;
+    }
+    let i = 0;
+    while (i < text.length) {
+        const ch = text[i];
+        if (ch === '[') {
+            const end = text.indexOf(']', i + 1);
+            if (end === -1) {
+                return false;
+            }
+            i = end + 1;
+            continue;
+        }
+        if (ch === ' ' || ch === '\t') {
+            i += 1;
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+function tryConsumeAttributeOnlyLine(options) {
+    const result = parseAttributeLine(options.text, options.lineNumber, options.errors, options.pending.attrs, options.fallbackPosition, options.tabCount);
+    if (!result.recognizedAny) {
+        return false;
+    }
+    if (result.attrs) {
+        options.pending.attrs = mergeBlockAttributes(options.pending.attrs, result.attrs);
+    }
+    if (result.foldNext) {
+        options.pending.foldNext = true;
+    }
+    if (result.tagName) {
+        options.pending.tagName = result.tagName;
+    }
+    if (result.isComment) {
+        options.pending.isComment = true;
+    }
+    if (result.isDisabled) {
+        options.pending.isDisabled = true;
+    }
+    if (result.isSheet) {
+        options.pending.isSheet = true;
+    }
+    if (result.isHtml) {
+        options.pending.isHtml = true;
+    }
+    return true;
+}
+function parseAttributeLine(text, lineNumber, errors, baseAttrs, fallbackPosition, tabCount) {
+    const result = {
+        attrs: undefined,
+        foldNext: false,
+        tagName: undefined,
+        isComment: false,
+        isDisabled: false,
+        isSheet: false,
+        isHtml: false,
+        recognizedAny: false,
+    };
+    let attrs = baseAttrs ? { ...baseAttrs } : undefined;
+    const unknownTokens = [];
+    let arrowCount = 0;
+    let i = 0;
+    while (i < text.length) {
+        const start = text.indexOf('[', i);
+        if (start === -1) {
+            break;
+        }
+        const end = text.indexOf(']', start + 1);
+        if (end === -1) {
+            break;
+        }
+        const inside = text.slice(start + 1, end).trim();
+        if (inside.length === 0) {
+            i = end + 1;
+            continue;
+        }
+        const parts = inside.split(',');
+        for (const rawPart of parts) {
+            const part = rawPart.trim();
+            if (part.length === 0) {
+                continue;
+            }
+            if (part === 'c') {
+                attrs = ensureBlockAttributes(attrs);
+                attrs.align = 'center';
+                result.recognizedAny = true;
+                continue;
+            }
+            if (part === 'r') {
+                attrs = ensureBlockAttributes(attrs);
+                attrs.align = 'right';
+                result.recognizedAny = true;
+                continue;
+            }
+            if (part === '->' || part === '<-' || part === '<->') {
+                arrowCount += 1;
+                result.recognizedAny = true;
+                if (part === '->' && arrowCount > 2) {
+                    (0, diagnostics_1.reportParseWarning)(errors, {
+                        message: 'More than two [->] attributes in a row; extra [->] will be treated as plain text.',
+                        line: lineNumber,
+                        code: MULTI_ARROW_WARNING_CODE,
+                    });
+                    continue;
+                }
+                attrs = ensureBlockAttributes(attrs);
+                if (part === '->' || part === '<->') {
+                    const basePosition = attrs.position ??
+                        fallbackPosition ??
+                        (tabCount !== undefined ? mapTabsToPosition(tabCount) : undefined);
+                    attrs.position = shiftPositionRight(basePosition);
+                    attrs.sameLine = true;
+                }
+                if (part === '<-' || part === '<->') {
+                    attrs.truncateRight = true;
+                }
+                continue;
+            }
+            if (part === 'fold') {
+                result.foldNext = true;
+                result.recognizedAny = true;
+                continue;
+            }
+            if (part === 'sheet') {
+                result.isSheet = true;
+                result.recognizedAny = true;
+                continue;
+            }
+            if (part === 'html') {
+                result.isHtml = true;
+                result.recognizedAny = true;
+                continue;
+            }
+            if (part === 'comment') {
+                result.isComment = true;
+                result.recognizedAny = true;
+                continue;
+            }
+            if (part === 'disable' || part === 'd') {
+                result.isDisabled = true;
+                result.recognizedAny = true;
+                continue;
+            }
+            if (part.startsWith('tag=')) {
+                result.tagName = part.slice('tag='.length);
+                result.recognizedAny = true;
+                continue;
+            }
+            if (part.startsWith('t=')) {
+                result.tagName = part.slice(2);
+                result.recognizedAny = true;
+                continue;
+            }
+            if (part.startsWith('f=')) {
+                result.tagName = part.slice(2);
+                result.recognizedAny = true;
+                continue;
+            }
+            unknownTokens.push(part);
+            continue;
+        }
+        i = end + 1;
+    }
+    if (!result.recognizedAny && unknownTokens.length > 0) {
+        for (const token of unknownTokens) {
+            (0, diagnostics_1.reportParseWarning)(errors, {
+                message: `Unknown block attribute token "${token}"`,
+                line: lineNumber,
+                code: UNKNOWN_ATTRIBUTE_WARNING_CODE,
+            });
+        }
+    }
+    result.attrs = attrs;
+    return result;
+}
+function ensureBlockAttributes(attrs) {
+    if (attrs) {
+        return attrs;
+    }
+    return {};
+}
+function mergeBlockAttributes(base, extra) {
+    if (!base) {
+        return { ...extra };
+    }
+    return { ...base, ...extra };
+}
+function mapTabsToPosition(tabCount) {
+    if (tabCount === 0) {
+        return 'L';
+    }
+    if (tabCount === 1) {
+        return 'C';
+    }
+    if (tabCount >= 2) {
+        return 'R';
+    }
+    return undefined;
+}
+function shiftPositionRight(position) {
+    if (position === 'L') {
+        return 'C';
+    }
+    if (position === 'C') {
+        return 'R';
+    }
+    if (position === 'R') {
+        return 'R';
+    }
+    return 'C';
+}

package/dist/core/block/rules/code-block.d.ts

@@ -0,0 +1,2 @@
+import { BlockRuleContext } from './types';
+export declare function tryParseCodeBlock(ctx: BlockRuleContext): number | null;

package/dist/core/block/rules/code-block.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseCodeBlock = tryParseCodeBlock;
+const diagnostics_1 = require("../../diagnostics");
+const location_1 = require("../../location");
+const lexer_1 = require("../../../lexer/lexer");
+const code_fence_1 = require("./code-fence");
+function tryParseCodeBlock(ctx) {
+    const codeFenceStart = (0, code_fence_1.matchCodeFenceStart)(ctx.trimmedContent);
+    const attrCodeFenceStart = codeFenceStart ? null : (0, code_fence_1.matchAttributedCodeFence)(ctx.trimmedContent);
+    const effectiveCodeFence = codeFenceStart || attrCodeFenceStart;
+    if (!effectiveCodeFence) {
+        return null;
+    }
+    const rawLines = [ctx.lineInfo.raw];
+    const codeLines = [];
+    const fenceIndent = ctx.lineInfo.tabCount;
+    let jCode = ctx.index + 1;
+    let closed = false;
+    while (jCode < ctx.lines.length) {
+        const nextRaw = ctx.lines[jCode];
+        if (nextRaw === undefined) {
+            jCode += 1;
+            continue;
+        }
+        const nextInfo = (0, lexer_1.getLineInfo)(nextRaw);
+        const nextTrimmed = nextInfo.content.trim();
+        if ((0, code_fence_1.isCodeFenceEnd)(nextTrimmed)) {
+            rawLines.push(nextInfo.raw);
+            closed = true;
+            jCode += 1;
+            break;
+        }
+        rawLines.push(nextInfo.raw);
+        let codeLine = nextRaw;
+        for (let t = 0; t < fenceIndent && codeLine.startsWith('\t'); t++) {
+            codeLine = codeLine.slice(1);
+        }
+        codeLines.push(codeLine);
+        jCode += 1;
+    }
+    if (!closed) {
+        (0, diagnostics_1.reportParseError)(ctx.errors, {
+            message: 'Code block is not closed with ```',
+            line: ctx.index + 1,
+        });
+    }
+    const blockAttrs = ctx.buildBlockAttrs(ctx.lineInfo.tabCount);
+    const isHtmlBlock = ctx.pending.isHtml || (attrCodeFenceStart?.isHtml ?? false);
+    let block;
+    if (ctx.pending.isDisabled) {
+        const disabled = {
+            type: 'disabledBlock',
+            raw: rawLines.join('\n'),
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(disabled, ctx.lineLocation);
+        block = disabled;
+    }
+    else {
+        const codeBlock = {
+            type: 'code',
+            language: effectiveCodeFence.language,
+            value: codeLines.join('\n'),
+            htmlLike: isHtmlBlock ? true : undefined,
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(codeBlock, ctx.lineLocation);
+        block = codeBlock;
+    }
+    ctx.commitBlock(block, blockAttrs, { allowTag: !ctx.pending.isDisabled });
+    return jCode;
+}

package/dist/core/block/rules/code-fence.d.ts

@@ -0,0 +1,15 @@
+interface CodeFenceStartMatchResult {
+    language?: string;
+}
+export interface AttributedCodeFenceResult {
+    language?: string;
+    isHtml: boolean;
+}
+export declare function matchCodeFenceStart(trimmed: string): CodeFenceStartMatchResult | undefined;
+export declare function isCodeFenceEnd(trimmed: string): boolean;
+/**
+ * Match code fence with optional leading attributes like [html]```
+ * Returns the language and whether it's an HTML block
+ */
+export declare function matchAttributedCodeFence(trimmed: string): AttributedCodeFenceResult | undefined;
+export {};

package/dist/core/block/rules/code-fence.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchCodeFenceStart = matchCodeFenceStart;
+exports.isCodeFenceEnd = isCodeFenceEnd;
+exports.matchAttributedCodeFence = matchAttributedCodeFence;
+function matchCodeFenceStart(trimmed) {
+    if (!trimmed.startsWith('```')) {
+        return undefined;
+    }
+    const m = trimmed.match(/^```([^\s`]*)\s*$/);
+    if (!m) {
+        return undefined;
+    }
+    const group = m[1];
+    if (group === undefined || group.length === 0) {
+        return { language: undefined };
+    }
+    return { language: group };
+}
+function isCodeFenceEnd(trimmed) {
+    return /^```\s*$/.test(trimmed);
+}
+/**
+ * Match code fence with optional leading attributes like [html]```
+ * Returns the language and whether it's an HTML block
+ */
+function matchAttributedCodeFence(trimmed) {
+    // Match pattern: optional [attr]... followed by ```language?
+    const match = trimmed.match(/^(\[.+\])*\s*```([^\s`]*)\s*$/);
+    if (!match) {
+        return undefined;
+    }
+    const attrPart = match[1] || '';
+    const language = match[2] || undefined;
+    const isHtml = /\[html\]/i.test(attrPart);
+    return { language, isHtml };
+}

package/dist/core/block/rules/content-title.d.ts

@@ -0,0 +1,12 @@
+import { BlockNode } from '../../ast';
+import { BlockRuleContext } from './types';
+interface ContentTitleRuleContext extends BlockRuleContext {
+    blocks: BlockNode[];
+    resetPending: () => void;
+}
+interface ContentTitleMatchResult {
+    text: string;
+}
+export declare function tryParseContentTitleBlock(ctx: ContentTitleRuleContext): number | null;
+export declare function matchContentTitle(content: string): ContentTitleMatchResult | undefined;
+export {};

package/dist/core/block/rules/content-title.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseContentTitleBlock = tryParseContentTitleBlock;
+exports.matchContentTitle = matchContentTitle;
+const location_1 = require("../../location");
+function tryParseContentTitleBlock(ctx) {
+    const contentTitleMatch = matchContentTitle(ctx.lineInfo.content);
+    if (!contentTitleMatch) {
+        return null;
+    }
+    const text = contentTitleMatch.text;
+    let consumedByImageTitle = false;
+    if (canAttachToPreviousImage(ctx.pending)) {
+        const lastBlock = ctx.blocks[ctx.blocks.length - 1];
+        if (lastBlock && lastBlock.type === 'image') {
+            lastBlock.title = text;
+            consumedByImageTitle = true;
+        }
+        else if (lastBlock && lastBlock.type === 'taggedBlock' && lastBlock.child.type === 'image') {
+            lastBlock.child.title = text;
+            consumedByImageTitle = true;
+        }
+    }
+    if (consumedByImageTitle) {
+        ctx.resetPending();
+        return ctx.index + 1;
+    }
+    const blockAttrs = ctx.buildBlockAttrs(ctx.lineInfo.tabCount);
+    let block;
+    if (ctx.pending.isDisabled) {
+        const disabled = {
+            type: 'disabledBlock',
+            raw: ctx.lineInfo.raw,
+            blockAttrs,
+        };
+        (0, location_1.setNodeLocation)(disabled, ctx.lineLocation);
+        block = disabled;
+    }
+    else {
+        const contentTitle = {
+            type: 'contentTitle',
+            children: [{ type: 'text', value: text }],
+        };
+        (0, location_1.setNodeLocation)(contentTitle, ctx.lineLocation);
+        block = contentTitle;
+    }
+    ctx.commitBlock(block, blockAttrs);
+    return ctx.index + 1;
+}
+function matchContentTitle(content) {
+    const m = content.match(/^>\s+(.+)$/);
+    if (!m) {
+        return undefined;
+    }
+    const group = m[1];
+    if (group === undefined) {
+        return undefined;
+    }
+    const text = group.trimEnd();
+    return { text };
+}
+function canAttachToPreviousImage(pending) {
+    return (!pending.attrs &&
+        !pending.foldNext &&
+        !pending.tagName &&
+        !pending.isComment &&
+        !pending.isDisabled &&
+        !pending.isSheet &&
+        !pending.isHtml);
+}

package/dist/core/block/rules/footnotes.d.ts

@@ -0,0 +1,9 @@
+import { BlockNode } from '../../ast';
+import { ParseError } from '../../errors';
+import { BlockRuleContext } from './types';
+interface FootnotesRuleContext extends BlockRuleContext {
+    parseBlocks: (source: string, errors: ParseError[]) => BlockNode[];
+}
+export declare function tryParseFootnotesBlock(ctx: FootnotesRuleContext): number | null;
+export declare function isFootnotesLine(trimmed: string): boolean;
+export {};