@asciidoctor/core 3.0.3 → 4.0.0-alpha.1

package/types/reader.d.ts

@@ -0,0 +1,184 @@
+export class Cursor {
+    constructor(file: any, dir?: any, path?: any, lineno?: number);
+    file: any;
+    dir: any;
+    path: any;
+    lineno: number;
+    advance(num: any): void;
+    get lineInfo(): string;
+    toString(): string;
+    getLineNumber(): number;
+    getFile(): any;
+    getDirectory(): any;
+    getPath(): any;
+    /**
+     * Get the line info string for this cursor (e.g. "path/to/file.adoc: line 42").
+     * @returns {string}
+     */
+    getLineInfo(): string;
+}
+export class Reader {
+    constructor(data?: any, cursor?: any, opts?: {});
+    file: any;
+    _dir: any;
+    path: any;
+    lineno: any;
+    _document: any;
+    sourceLines: string[];
+    _lines: string[];
+    _mark: any;
+    _lookAhead: number;
+    processLines: boolean;
+    _unescapeNextLine: boolean;
+    unterminated: any;
+    _saved: any;
+    /** @returns {boolean | Promise<boolean>} */
+    hasMoreLines(): boolean | Promise<boolean>;
+    /** @returns {boolean | Promise<boolean>} */
+    empty(): boolean | Promise<boolean>;
+    /** @returns {boolean | Promise<boolean>} */
+    eof(): boolean | Promise<boolean>;
+    nextLineEmpty(): Promise<boolean>;
+    isNextLineEmpty(): Promise<boolean>;
+    /**
+     * Peek at the next line without consuming it.
+     * @param {boolean} [direct=false] - When true, bypass processLine and return the raw stack top.
+     * @returns {Promise<string|undefined>} The next line, or undefined if there are no more lines.
+     */
+    peekLine(direct?: boolean): Promise<string | undefined>;
+    /**
+     * Peek at the next num lines without consuming them.
+     * @param {number|null} [num=null]
+     * @param {boolean} [direct=false]
+     * @returns {Promise<string[]>}
+     */
+    peekLines(num?: number | null, direct?: boolean): Promise<string[]>;
+    readLine(): Promise<string>;
+    readLines(): Promise<string[]>;
+    readlines(): Promise<string[]>;
+    read(): Promise<string>;
+    advance(): Promise<boolean>;
+    unshiftLine(lineToRestore: any): void;
+    restoreLine(lineToRestore: any): void;
+    unshiftLines(linesToRestore: any): void;
+    restoreLines(linesToRestore: any): void;
+    replaceNextLine(replacement: any): boolean;
+    replaceLine(replacement: any): boolean;
+    skipBlankLines(): Promise<number>;
+    skipCommentLines(): Promise<void>;
+    skipLineComments(): Promise<string[]>;
+    terminate(): void;
+    /**
+     * Read lines until a termination condition is met.
+     * @param {Object} [options={}]
+     * @param {string} [options.terminator] - Line at which to stop.
+     * @param {boolean} [options.breakOnBlankLines] - Stop on blank lines.
+     * @param {boolean} [options.breakOnListContinuation] - Stop on a list continuation (+).
+     * @param {boolean} [options.skipFirstLine] - Skip the first line before scanning.
+     * @param {boolean} [options.preserveLastLine] - Push the terminating line back.
+     * @param {boolean} [options.readLastLine] - Include the terminating line in result.
+     * @param {boolean} [options.skipLineComments] - Skip line comments.
+     * @param {boolean} [options.skipProcessing] - Disable line preprocessing for this call.
+     * @param {string} [options.context] - Name used in unterminated-block warnings.
+     * @param {Cursor} [options.cursor] - Starting cursor for unterminated-block warnings.
+     * @param {Function|null} [filter=null] - Optional function(line) returning true to break.
+     * @returns {Promise<string[]>}
+     */
+    readLinesUntil(options?: {
+        terminator?: string;
+        breakOnBlankLines?: boolean;
+        breakOnListContinuation?: boolean;
+        skipFirstLine?: boolean;
+        preserveLastLine?: boolean;
+        readLastLine?: boolean;
+        skipLineComments?: boolean;
+        skipProcessing?: boolean;
+        context?: string;
+        cursor?: Cursor;
+    }, filter?: Function | null): Promise<string[]>;
+    get cursor(): Cursor;
+    cursorAtLine(lineno: any): Cursor;
+    cursorAtMark(): Cursor;
+    cursorBeforeMark(): Cursor;
+    cursorAtPrevLine(): Cursor;
+    mark(): void;
+    lineInfo(): string;
+    /**
+     * Returns the remaining lines in forward order (first remaining line at index 0).
+     * The returned object is a mutable proxy so that element assignments like
+     * `reader.lines[i] = newValue` are reflected back into the internal reversed stack.
+     * @returns {string[]}
+     */
+    get lines(): string[];
+    string(): string;
+    source(): string;
+    save(): void;
+    restoreSave(): void;
+    discardSave(): void;
+    toString(): string;
+    getCursor(): Cursor;
+    getLines(): string[];
+    getString(): string;
+    getLogger(): any;
+    createLogMessage(text: any, context?: {}): any;
+    get logger(): any;
+    /** @param {string} msg @param {{ sourceLocation?: any, includeLocation?: any }} [opts] */
+    _logWarn(msg: string, { sourceLocation, includeLocation }?: {
+        sourceLocation?: any;
+        includeLocation?: any;
+    }): void;
+    _logError(msg: any, opts?: {}): void;
+    /** @param {string} msg @param {{ sourceLocation?: any }} [opts] */
+    _logInfo(msg: string, { sourceLocation }?: {
+        sourceLocation?: any;
+    }): void;
+}
+export class PreprocessorReader extends Reader {
+    constructor(document: any, data?: any, cursor?: any, opts?: {});
+    _sourcemap: any;
+    _maxdepth: {
+        abs: number;
+        curr: number;
+        rel: number;
+    };
+    includeStack: any[];
+    _includes: any;
+    _skipping: boolean;
+    _conditionalStack: any[];
+    _includeProcessorExtensions: any;
+    /**
+     * Drain conditional stack at EOS; treat blank lines as lines (not as EOF).
+     * `peekLine()` returns undefined only at true EOF; '' for blank lines.
+     * @returns {Promise<boolean>}
+     */
+    hasMoreLines(): Promise<boolean>;
+    empty(): Promise<boolean>;
+    eof(): Promise<boolean>;
+    peekLine(direct?: boolean): any;
+    /**
+     * Push new source onto the reader, switching the include context.
+     * @param {string|string[]} data
+     * @param {string|null} [file=null]
+     * @param {string|null} [path=null]
+     * @param {number} [lineno=1]
+     * @param {Object} [attributes={}]
+     * @returns {this}
+     */
+    pushInclude(data: string | string[], file?: string | null, path?: string | null, lineno?: number, attributes?: any): this;
+    get includeDepth(): number;
+    exceedsMaxDepth(): number;
+    exceededMaxDepth(): number;
+    hasIncludeProcessors(): boolean;
+    createIncludeCursor(file: any, path: any, lineno: any): Cursor;
+    /**
+     * Evaluate preprocessor directives as lines are visited.
+     * @param {string} line
+     * @returns {Promise<string|undefined>}
+     */
+    processLine(line: string): Promise<string | undefined>;
+    /**
+     * Get the current include depth (number of nested includes).
+     * @returns {number}
+     */
+    getIncludeDepth(): number;
+}

package/types/rx.d.ts

@@ -0,0 +1,513 @@
+export const CC_ALL: "[\\s\\S]";
+export const CC_ANY: ".";
+export const CC_EOL: "$";
+export const CC_ALPHA: "\\p{Alphabetic}";
+export const CG_ALPHA: "\\p{Alphabetic}";
+export const CC_ALNUM: "\\p{Alphabetic}\\p{N}";
+export const CG_ALNUM: "[\\p{Alphabetic}\\p{N}]";
+export const CC_WORD: "\\p{Alphabetic}\\p{N}\\p{Pc}";
+export const CG_WORD: "[\\p{Alphabetic}\\p{N}\\p{Pc}]";
+export const CG_BLANK: "[\\p{Zs}\\t]";
+export const QuoteAttributeListRxt: "\\[([^\\[\\]]+)\\]";
+/**
+ * Matches the author info line immediately following the document title.
+ * @example
+ * Doc Writer <doc@example.com>
+ * Mary_Sue Brontë
+ */
+export const AuthorInfoLineRx: RegExp;
+/**
+ * Matches the delimiter that separates multiple authors.
+ * @example
+ * Doc Writer; Junior Writer
+ */
+export const AuthorDelimiterRx: RegExp;
+/**
+ * Matches the revision info line immediately following the author info line.
+ * @example
+ * v1.0
+ * 2013-01-01
+ * v1.0, 2013-01-01: Ring in the new year release
+ */
+export const RevisionInfoLineRx: RegExp;
+/**
+ * Matches the title and volnum in the manpage doctype.
+ * @example
+ * = asciidoctor(1)
+ * = asciidoctor ( 1 )
+ */
+export const ManpageTitleVolnumRx: RegExp;
+/**
+ * Matches the name and purpose in the manpage doctype.
+ * @example
+ * asciidoctor - converts AsciiDoc source files to HTML, DocBook and other formats
+ */
+export const ManpageNamePurposeRx: RegExp;
+/**
+ * Matches a conditional preprocessor directive (ifdef, ifndef, ifeval, endif).
+ * @example
+ * ifdef::basebackend-html[]
+ * ifeval::["{asciidoctor-version}" >= "0.1.0"]
+ * endif::[]
+ */
+export const ConditionalDirectiveRx: RegExp;
+/**
+ * Matches a restricted (safe) eval expression.
+ * @example
+ * "{asciidoctor-version}" >= "0.1.0"
+ */
+export const EvalExpressionRx: RegExp;
+/**
+ * Matches an include preprocessor directive.
+ * @example
+ * include::chapter1.ad[]
+ * include::example.txt[lines=1;2;5..10]
+ */
+export const IncludeDirectiveRx: RegExp;
+/**
+ * Matches a trailing tag directive in an include file.
+ *
+ * NOTE: 'm' flag required so that $ matches end-of-line (not only end-of-string) in JS.
+ * NOTE: accounts for \r in Windows line endings.
+ * @example
+ * // tag::try-catch[]
+ * // end::try-catch[]
+ */
+export const TagDirectiveRx: RegExp;
+/**
+ * Matches a document attribute entry.
+ * @example
+ * :foo: bar
+ * :First Name: Dan
+ * :sectnums!:
+ */
+export const AttributeEntryRx: RegExp;
+/** Matches invalid characters in an attribute name. */
+export const InvalidAttributeNameCharsRx: RegExp;
+/**
+ * Matches a pass inline macro surrounding an attribute entry value.
+ *
+ * NOTE: ^ / $ are string anchors here (no 'm' flag). [\s\S]* allows multi-line values.
+ * @example
+ * pass:[text]
+ * pass:a[{a} {b} {c}]
+ */
+export const AttributeEntryPassMacroRx: RegExp;
+/**
+ * Matches an inline attribute reference.
+ * @example
+ * {foobar}
+ * {counter:sequence-name:1}
+ * {set:foo:bar}
+ */
+export const AttributeReferenceRx: RegExp;
+/**
+ * Matches an anchor (id + optional reference text) on a line above a block.
+ * @example
+ * [[idname]]
+ * [[idname,Reference Text]]
+ */
+export const BlockAnchorRx: RegExp;
+/**
+ * Matches an attribute list above a block element.
+ * @example
+ * [quote, Adam Smith, Wealth of Nations]
+ * [{lead}]
+ */
+export const BlockAttributeListRx: RegExp;
+/** Combined pattern matching either a block anchor or a block attribute list. */
+export const BlockAttributeLineRx: RegExp;
+/**
+ * Matches a title above a block.
+ * @example
+ * .Title goes here
+ */
+export const BlockTitleRx: RegExp;
+/**
+ * Matches an admonition label at the start of a paragraph.
+ * @example
+ * NOTE: Just a little note.
+ * TIP: Don't forget!
+ */
+export const AdmonitionParagraphRx: RegExp;
+/**
+ * Matches a literal paragraph (line preceded by at least one space or tab).
+ * @example
+ * <SPACE>Foo
+ * <TAB>Foo
+ */
+export const LiteralParagraphRx: RegExp;
+/**
+ * Matches an Atx (single-line) section title.
+ * @example
+ * == Foo
+ * == Foo ==
+ */
+export const AtxSectionTitleRx: RegExp;
+/** Extended Atx section title supporting the Markdown variant (#). */
+export const ExtAtxSectionTitleRx: RegExp;
+/**
+ * Matches the first line of a Setext (two-line) section title.
+ * Must not start with '.' and must contain at least one alphanumeric character.
+ */
+export const SetextSectionTitleRx: RegExp;
+/**
+ * Matches an anchor inside a section title.
+ * @example
+ * Section Title [[idname]]
+ * Section Title [[idname,Reference Text]]
+ */
+export const InlineSectionAnchorRx: RegExp;
+/**
+ * Matches invalid ID characters in a section title.
+ * NOTE: Uppercase excluded; expression is run only on a lowercase string.
+ */
+export const InvalidSectionIdCharsRx: RegExp;
+/** Matches an explicit section level style like sect1. */
+export const SectionLevelStyleRx: RegExp;
+/**
+ * Detects the start of any list item.
+ *
+ * NOTE: Check only up to the blank character since non-whitespace follows.
+ * IMPORTANT: Must agree with the per-list-type regexps or the parser will hang.
+ */
+export const AnyListRx: RegExp;
+/**
+ * Matches an unordered list item.
+ * @example
+ * * Foo
+ * - Foo
+ */
+export const UnorderedListRx: RegExp;
+/**
+ * Matches an ordered list item.
+ * @example
+ * . Foo    1. Foo    a. Foo    I. Foo
+ */
+export const OrderedListRx: RegExp;
+export namespace OrderedListMarkerRxMap {
+    let arabic: RegExp;
+    let loweralpha: RegExp;
+    let lowerroman: RegExp;
+    let upperalpha: RegExp;
+    let upperroman: RegExp;
+}
+/**
+ * Matches a description list entry.
+ * @example
+ * foo::
+ * foo:: The metasyntactic variable …
+ */
+export const DescriptionListRx: RegExp;
+/** Matches a sibling description list item (excluding the delimiter given by key). */
+export const DescriptionListSiblingRx: {
+    '::': RegExp;
+    ':::': RegExp;
+    '::::': RegExp;
+    ';;': RegExp;
+};
+/**
+ * Matches a callout list item.
+ * @example
+ * <1> Explanation
+ * <.> Explanation with automatic number
+ */
+export const CalloutListRx: RegExp;
+/**
+ * Matches a callout reference inside literal text (applied line-by-line).
+ *
+ * Group layout:
+ *   1 – optional line-comment prefix (//  #  --  ;;)
+ *   2 – backslash escape
+ *   3 – optional XML comment delimiter (--)
+ *   4 – callout number or dot
+ */
+export const CalloutExtractRx: RegExp;
+/**
+ * Template string for CalloutExtractRxMap entries.
+ * Runtime value: (\\)?<()(\d+|\.)>(?=(?: ?\\?<(?:\d+|\.)>)*$)
+ * Note: 'm' flag added so $ matches end-of-line (Ruby regex default behaviour).
+ */
+export const CalloutExtractRxt: "(\\\\)?<()([\\d]+|\\.)>(?=(?: ?\\\\?<(?:\\d+|\\.)>)*$)";
+/**
+ * Lazy map: line-comment string → callout-extract regex.
+ * Mirrors Ruby: Hash.new { |h,k| h[k] = /(prefix)?#{CalloutExtractRxt}/ }
+ */
+export const CalloutExtractRxMap: any;
+/** Matches a callout reference when scanning source (special chars NOT yet replaced). */
+export const CalloutScanRx: RegExp;
+/**
+ * Matches a callout reference in HTML output (special chars already replaced).
+ *
+ * Group layout mirrors CalloutExtractRx.
+ * Note: 'm' flag so $ matches end-of-line, matching Ruby regex semantics.
+ */
+export const CalloutSourceRx: RegExp;
+/**
+ * Template string for CalloutSourceRxMap entries.
+ * Runtime value: (\\)?&lt;()(\d+|\.)&gt;(?=(?: ?\\?&lt;(?:\d+|\.)&gt;)*$)
+ */
+export const CalloutSourceRxt: "(\\\\)?&lt;()([\\d]+|\\.)&gt;(?=(?: ?\\\\?&lt;(?:\\d+|\\.)&gt;)*$)";
+/** Lazy map: line-comment string → callout-source regex. */
+export const CalloutSourceRxMap: any;
+export namespace ListRxMap {
+    export { UnorderedListRx as ulist };
+    export { OrderedListRx as olist };
+    export { DescriptionListRx as dlist };
+    export { CalloutListRx as colist };
+}
+/**
+ * Parses the column test (colspec) for a table.
+ * @example
+ * 1*h,2*,^3e
+ */
+export const ColumnSpecRx: RegExp;
+/**
+ * Parses the start of a cell test.
+ * @example
+ * 2.3+<.>m
+ */
+export const CellSpecStartRx: RegExp;
+/** Parses the end of a cell test. */
+export const CellSpecEndRx: RegExp;
+/**
+ * Matches the custom block macro pattern.
+ * @example
+ * gist::123456[]
+ */
+export const CustomBlockMacroRx: RegExp;
+/**
+ * Matches an image, video or audio block macro.
+ * @example
+ * image::filename.png[Caption]
+ * video::http://youtube.com/12345[Cats vs Dogs]
+ */
+export const BlockMediaMacroRx: RegExp;
+/**
+ * Matches the TOC block macro.
+ * @example
+ * toc::[]
+ * toc::[levels=2]
+ */
+export const BlockTocMacroRx: RegExp;
+/**
+ * Matches an anchor (id + optional reference text) in the flow of text.
+ *
+ * Group layout:
+ *   1 – backslash escape
+ *   2 – id  (double-bracket form)
+ *   3 – reftext  (double-bracket form)
+ *   4 – id  (anchor: macro form)
+ *   5 – reftext  (anchor: macro form)
+ * @example
+ * [[idname]]
+ * [[idname,Reference Text]]
+ * anchor:idname[]
+ * anchor:idname[Reference Text]
+ */
+export const InlineAnchorRx: RegExp;
+/** Scans for a non-escaped anchor in the flow of text. */
+export const InlineAnchorScanRx: RegExp;
+/** Scans for a leading, non-escaped anchor. */
+export const LeadingInlineAnchorRx: RegExp;
+/**
+ * Matches a bibliography anchor at the start of a list item.
+ * @example
+ * [[[Fowler_1997]]] Fowler M. ...
+ */
+export const InlineBiblioAnchorRx: RegExp;
+/**
+ * Matches an inline e-mail address.
+ * @example
+ * doc.writer@example.com
+ */
+export const InlineEmailRx: RegExp;
+/**
+ * Matches an inline footnote macro (may span multiple lines).
+ *
+ * NOTE: [\s\S]*? allows multiline content (Ruby /m + CC_ALL).
+ * NOTE: (?!</a>) avoids matching inside an anchor tag.
+ * @example
+ * footnote:[text]
+ * footnote:id[text]
+ * footnoteref:[id,text]  (legacy)
+ */
+export const InlineFootnoteMacroRx: RegExp;
+/**
+ * Matches an image or icon inline macro (may span multiple lines).
+ * @example
+ * image:filename.png[Alt Text]
+ * icon:github[large]
+ */
+export const InlineImageMacroRx: RegExp;
+/**
+ * Matches an indexterm inline macro (may span multiple lines).
+ * @example
+ * indexterm:[Tigers,Big cats]
+ * (((Tigers,Big cats)))
+ * ((Tigers))
+ */
+export const InlineIndextermMacroRx: RegExp;
+/**
+ * Matches either the kbd or btn inline macro (may span multiple lines).
+ * @example
+ * kbd:[F3]     kbd:[Ctrl+Shift+T]     btn:[Save]
+ */
+export const InlineKbdBtnMacroRx: RegExp;
+/**
+ * Matches an implicit link and the link inline macro.
+ *
+ * NOTE: This is the Opal/JS variant of the pattern.
+ *   Group 2 captures ':' inside a lookahead from the &lt;<protocol> branch.
+ *   (?!\2) then guards the &gt;-terminated branch: when group 2 IS ':',
+ *   the guard prevents matching '://' at the start of the path; when group 2
+ *   is UNSET (other prefix branches), (?!\2) expands to (?!"") which ALWAYS
+ *   FAILS – correctly preventing the &gt; branch for non-&lt; prefixes.
+ *
+ * *** NO 'u' FLAG: the (?!\2) guard relies on unset back-references matching
+ *     the empty string, which only holds in non-Unicode mode. ***
+ *
+ * Group layout:
+ *   1 – prefix (^, link:, blank, \\?&lt; or punctuation)
+ *   2 – ':' captured by lookahead  (only when prefix is \\?&lt;)
+ *   3 – URL scheme + ://
+ *   4 – target before [   (formal macro)
+ *   5 – attrlist           (formal macro, may be empty)
+ *   6 – target before &gt; (angle-bracket autolink, requires &lt; prefix)
+ *   7 – target             (bare autolink)
+ *   8 – last non-terminating char of bare target
+ * @example
+ * https://github.com
+ * https://github.com[GitHub]
+ * <https://github.com>
+ * link:https://github.com[]
+ */
+export const InlineLinkRx: RegExp;
+/**
+ * Matches a link or e-mail inline macro (may span multiple lines).
+ * @example
+ * link:path[label]
+ * mailto:doc.writer@example.com[]
+ */
+export const InlineLinkMacroRx: RegExp;
+/** Matches the name of a macro. */
+export const MacroNameRx: RegExp;
+/**
+ * Matches a stem (and alternatives) inline macro (may span multiple lines).
+ * @example
+ * stem:[x != 0]
+ * latexmath:[\sqrt{4} = 2]
+ */
+export const InlineStemMacroRx: RegExp;
+/**
+ * Matches a menu inline macro (may span multiple lines).
+ * @example
+ * menu:File[Save As...]
+ * menu:View[Page Style > No Style]
+ */
+export const InlineMenuMacroRx: RegExp;
+/**
+ * Matches an implicit menu inline macro.
+ * @example
+ * "File > New..."
+ */
+export const InlineMenuRx: RegExp;
+export namespace InlinePassRx {
+    let _false: (string | RegExp)[];
+    export { _false as false };
+    let _true: (string | RegExp)[];
+    export { _true as true };
+}
+/**
+ * Matches several variants of the passthrough inline macro (may span multiple lines).
+ *
+ * Group layout:
+ *   1 – optional backslash before attribute list
+ *   2 – attribute list content  (QuoteAttributeListRxt)
+ *   3 – backslash(es) before delimiter  (0–2)
+ *   4 – delimiter: +++, ++, or $$
+ *   5 – content between delimiters  (\4 closes)
+ *   6 – backslash before pass: macro
+ *   7 – subs list after pass:
+ *   8 – content inside pass:[…]
+ * @example
+ * +++text+++
+ * $$text$$
+ * pass:quotes[text]
+ * pass:[]
+ */
+export const InlinePassMacroRx: RegExp;
+/**
+ * Matches an xref (cross-reference) inline macro (may span multiple lines).
+ *
+ * NOTE: { included to support targets beginning with an attribute reference.
+ * NOTE: Special characters are already entity-encoded in the matched text.
+ *
+ * Group layout:
+ *   1 – target of <<…>> form
+ *   2 – target of xref:…[] form
+ *   3 – link text inside xref:…[…]
+ * @example
+ * <<id,reftext>>
+ * xref:id[reftext]
+ */
+export const InlineXrefMacroRx: RegExp;
+/**
+ * Matches a trailing + preceded by at least one space, forcing a hard line break.
+ *
+ * NOTE: 'm' flag required so that ^ / $ are line anchors (not string anchors) in JS.
+ * @example
+ * Humpty Dumpty sat on a wall, +
+ * Humpty Dumpty had a great fall.
+ */
+export const HardLineBreakRx: RegExp;
+/**
+ * Matches a Markdown horizontal rule.
+ * @example
+ * --- or - - -
+ * *** or * * *
+ * ___ or _ _ _
+ */
+export const MarkdownThematicBreakRx: RegExp;
+/**
+ * Matches an AsciiDoc or Markdown horizontal rule, or an AsciiDoc page break.
+ * @example
+ * '''  <<<  ---  ***  ___
+ */
+export const ExtLayoutBreakRx: RegExp;
+/** Matches consecutive blank lines. */
+export const BlankLineRx: RegExp;
+/**
+ * Matches whitespace escaped by a backslash.
+ * @example
+ * three\ blind\ mice
+ */
+export const EscapedSpaceRx: RegExp;
+/** Detects text that may contain replaceable characters. */
+export const ReplaceableTextRx: RegExp;
+/**
+ * Matches a whitespace delimiter (space, tab, newline).
+ * Replicates the parsing rules of Ruby %w strings.
+ *
+ * TODO: Replace with /(?<!\\)[ \t\n]+/ when lookbehind is universally available.
+ */
+export const SpaceDelimiterRx: RegExp;
+/** Matches a + or - modifier in a subs list. */
+export const SubModifierSniffRx: RegExp;
+/**
+ * Matches one or more consecutive digits at the end of a line.
+ * @example
+ * docbook5   html5
+ */
+export const TrailingDigitsRx: RegExp;
+/**
+ * Detects strings that resemble URIs.
+ *
+ * NOTE: ^ is used as a string-start anchor (no 'm' flag), equivalent to Ruby \A.
+ * NOTE: Does NOT match Windows paths like c:/sample.adoc or c:\sample.adoc.
+ * @example
+ * http://domain    https://domain    file:///path    data:info
+ */
+export const UriSniffRx: RegExp;
+/** Detects XML tags. */
+export const XmlSanitizeRx: RegExp;