@the_dissidents/libemmm 0.0.8 → 0.0.10

package/dist/index.d.ts

@@ -1,316 +1,389 @@
-import * as minimal_jsx_runtime from 'minimal-jsx-runtime';
+import { t as __export } from "./chunk-Bp6m_JJh.js";
+import * as minimal_jsx_runtime_jsx_runtime0 from "minimal-jsx-runtime/jsx-runtime";
 
+//#region src/debug.d.ts
 declare enum DebugLevel {
-    Trace = 0,
-    Info = 1,
-    Warning = 2,
-    Error = 3,
-    None = 4
-}
-
+  Trace = 0,
+  Info = 1,
+  Warning = 2,
+  Error = 3,
+  None = 4,
+}
+//#endregion
+//#region src/source.d.ts
 type SourceDescriptor = {
-    readonly name: string;
+  readonly name: string;
 };
 interface Source extends SourceDescriptor {
-    readonly nLines: number;
-    /**
-     * Return the row- and column-index corresponding to a given location. The indices are zero-based.
-     */
-    getRowCol(loc: number): [row: number, col: number];
-    /**
-     * Returns the position of the start of row `n` (zero-based). If `n` is zero, returns zero. If the source contains less than `n` rows, returns `Infinity`.
-     */
-    getRowStart(n: number): number;
-    /**
-     * Returns the content of the row `n` (zero-based). If the source contains less than `n` rows, returns `undefined`.
-     */
-    getRow(n: number): string | undefined;
+  readonly nLines: number;
+  /**
+   * Return the row- and column-index corresponding to a given location. The indices are zero-based.
+   */
+  getRowCol(loc: number): [row: number, col: number];
+  /**
+   * Returns the position of the start of row `n` (zero-based). If `n` is zero, returns zero. If the source contains less than `n` rows, returns `Infinity`.
+   */
+  getRowStart(n: number): number;
+  /**
+   * Returns the content of the row `n` (zero-based). If the source contains less than `n` rows, returns `undefined`.
+   */
+  getRow(n: number): string | undefined;
 }
 declare class StringSource implements Source {
-    private readonly src;
-    readonly name: string;
-    readonly nLines: number;
-    private readonly lineMap;
-    constructor(d: SourceDescriptor, src: string);
-    getRowCol(pos: number): [row: number, col: number];
-    getRowStart(n: number): number;
-    getRow(n: number): string | undefined;
+  private readonly src;
+  readonly name: string;
+  readonly nLines: number;
+  private readonly lineMap;
+  constructor(d: SourceDescriptor, src: string);
+  getRowCol(pos: number): [row: number, col: number];
+  getRowStart(n: number): number;
+  getRow(n: number): string | undefined;
+}
+//#endregion
+//#region src/module.d.ts
+type ModuleDefinition = {
+  usedModules: Set<string>;
+  blocks: Set<BlockModifierDefinition<unknown>>;
+  inlines: Set<InlineModifierDefinition<unknown>>;
+  inlineShorthands: Set<InlineShorthand<unknown>>;
+  blockShorthands: Set<BlockShorthand<unknown>>;
+};
+declare namespace ModuleDefinition {
+  function from(cxt: ParseContext): ModuleDefinition;
+  function apply(defs: ModuleDefinition, cxt: ParseContext): void;
+  function diff(cnew: ModuleDefinition, cold: ModuleDefinition): ModuleDefinition;
+  function combine(cnew: ModuleDefinition, cold: ModuleDefinition): [ModuleDefinition, string];
+}
+//#endregion
+//#region src/scanner.d.ts
+type Inspector = {
+  position: number;
+  callback: (cxt: ParseContext, pos: number) => void;
+};
+declare class SimpleScanner implements Scanner {
+  #private;
+  private src;
+  readonly source: Source;
+  constructor(src: string, sourceDesc?: SourceDescriptor, inspectors?: Inspector[]);
+  position(): number;
+  isEOF(): boolean;
+  inspectors(): Inspector[];
+  peek(str: string): boolean;
+  acceptChar(): string;
+  accept(str: string): boolean;
+  acceptWhitespaceChar(): string | null;
 }
-
-declare class NameManager<T extends {
-    name: string;
+interface Scanner {
+  readonly source: Source;
+  position(): number;
+  isEOF(): boolean;
+  /** Sources can have inspectors in them, which are positions that trigger a callback when encounterede. This function returns the inspectors that lie between the current position and where this function was previously called (or the beginning for the first call). */
+  inspectors(): Inspector[];
+  /** return true if sees str immediately */
+  peek(str: string): boolean;
+  /** if sees str immediately, consumes it and returns true */
+  accept(str: string): boolean;
+  /** consumes a character and returns it; throws at EOF */
+  acceptChar(): string;
+  /** newlines are NOT whitespaces */
+  acceptWhitespaceChar(): string | null;
+}
+//#endregion
+//#region src/util.d.ts
+declare class NameManager<T$1 extends {
+  name: string;
 }> {
-    private array;
-    private data;
-    constructor(from?: ReadonlyNameManager<T> | readonly T[] | ReadonlySet<T>);
-    toArray(): T[];
-    toSet(): Set<T>;
-    get(name: string): T | undefined;
-    has(name: string): boolean;
-    remove(name: string): void;
-    add(...elems: T[]): void;
-    find(predicate: (x: T) => boolean): T | undefined;
-}
-type ReadonlyNameManager<T extends {
-    name: string;
-}> = Omit<NameManager<T>, 'add' | 'remove'>;
-
-interface ParseContextStoreDefinitions {
-}
+  private array;
+  private data;
+  constructor(from?: ReadonlyNameManager<T$1> | readonly T$1[] | ReadonlySet<T$1>);
+  toArray(): T$1[];
+  toSet(): Set<T$1>;
+  get(name: string): T$1 | undefined;
+  has(name: string): boolean;
+  remove(name: string): void;
+  add(...elems: T$1[]): void;
+  find(predicate: (x: T$1) => boolean): T$1 | undefined;
+}
+type ReadonlyNameManager<T$1 extends {
+  name: string;
+}> = Omit<NameManager<T$1>, 'add' | 'remove'>;
+//#endregion
+//#region src/parser-config.d.ts
+interface ParseContextStoreDefinitions {}
 type ParseContextStoreKey = keyof ParseContextStoreDefinitions;
 type ParseContextStoreEntry<S extends ParseContextStoreKey> = ParseContextStoreDefinitions[S];
 declare class ParseContext {
-    config: Configuration;
-    variables: Map<string, string>;
-    private data;
-    constructor(config: Configuration, variables?: Map<string, string>);
-    init<S extends ParseContextStoreKey>(key: S, obj: ParseContextStoreEntry<S>): void;
-    set<S extends ParseContextStoreKey>(key: S, obj: ParseContextStoreEntry<S>): void;
-    get<S extends ParseContextStoreKey>(key: S): ParseContextStoreEntry<S>;
+  readonly config: Configuration;
+  variables: Map<string, string>;
+  private data;
+  usedModules: Set<string>;
+  constructor(config: Configuration, variables?: Map<string, string>);
+  init<S extends ParseContextStoreKey>(key: S, obj: ParseContextStoreEntry<S>): void;
+  set<S extends ParseContextStoreKey>(key: S, obj: ParseContextStoreEntry<S>): void;
+  get<S extends ParseContextStoreKey>(key: S): ParseContextStoreEntry<S>;
+  parse(scanner: Scanner): Document$1;
 }
 declare class Document$1 {
-    readonly root: RootNode;
-    readonly context: ParseContext;
-    readonly messages: readonly Message[];
-    constructor(root: RootNode, context: ParseContext, messages: readonly Message[]);
-    toStripped(): Document$1;
-    /**
-     * Performs a depth-first walk of the node tree.
-     */
-    walk(callback: (node: BlockEntity | InlineEntity | ArgumentEntity) => 'skip' | 'break' | 'continue'): void;
-    /**
-     * Gets all nodes that covers the given position, from outermost to innermost (essentially a path).
-     */
-    resolvePosition(pos: number): (BlockEntity | InlineEntity | ArgumentEntity)[];
+  readonly root: RootNode;
+  readonly context: ParseContext;
+  readonly messages: readonly Message[];
+  constructor(root: RootNode, context: ParseContext, messages: readonly Message[]);
+  toStripped(): Document$1;
+  /**
+   * Performs a depth-first walk of the node tree.
+   */
+  walk(callback: (node: BlockEntity | InlineEntity | ArgumentEntity) => 'skip' | 'break' | 'continue'): void;
+  /**
+   * Gets all nodes that covers the given position, from outermost to innermost (essentially a path).
+   */
+  resolvePosition(pos: number): (BlockEntity | InlineEntity | ArgumentEntity)[];
 }
+type Shorthand<TMod> = {
+  name: string;
+  parts: readonly string[];
+  postfix: string | undefined;
+  mod: TMod;
+};
+type BlockShorthand<TState> = Shorthand<BlockModifierDefinition<TState>>;
+type InlineShorthand<TState> = Shorthand<InlineModifierDefinition<TState>>;
+type KernelConfiguration = {
+  collapseWhitespaces: boolean;
+  reparseDepthLimit: number;
+};
 interface ReadonlyConfiguration {
-    readonly initializers: readonly ((cxt: ParseContext) => void)[];
-    readonly blockModifiers: ReadonlyNameManager<BlockModifierDefinition<any>>;
-    readonly inlineModifiers: ReadonlyNameManager<InlineModifierDefinition<any>>;
-    readonly systemModifiers: ReadonlyNameManager<SystemModifierDefinition<any>>;
-    readonly argumentInterpolators: ReadonlyNameManager<ArgumentInterpolatorDefinition>;
-    readonly blockShorthands: ReadonlyNameManager<BlockShorthand<any>>;
-    readonly inlineShorthands: ReadonlyNameManager<InlineShorthand<any>>;
-    readonly reparseDepthLimit: number;
+  readonly initializers: readonly ((cxt: ParseContext) => void)[];
+  readonly modules: ReadonlyMap<string, ModuleDefinition>;
+  readonly blockModifiers: ReadonlyNameManager<BlockModifierDefinition<any>>;
+  readonly inlineModifiers: ReadonlyNameManager<InlineModifierDefinition<any>>;
+  readonly systemModifiers: ReadonlyNameManager<SystemModifierDefinition<any>>;
+  readonly argumentInterpolators: ReadonlyNameManager<ArgumentInterpolatorDefinition>;
+  readonly blockShorthands: ReadonlyNameManager<BlockShorthand<any>>;
+  readonly inlineShorthands: ReadonlyNameManager<InlineShorthand<any>>;
+  readonly kernel: Readonly<KernelConfiguration>;
 }
 declare class Configuration implements ReadonlyConfiguration {
-    initializers: ((cxt: ParseContext) => void)[];
-    blockModifiers: NameManager<BlockModifierDefinition<any>>;
-    inlineModifiers: NameManager<InlineModifierDefinition<any>>;
-    systemModifiers: NameManager<SystemModifierDefinition<any>>;
-    argumentInterpolators: NameManager<ArgumentInterpolatorDefinition>;
-    blockShorthands: NameManager<BlockShorthand<any>>;
-    inlineShorthands: NameManager<InlineShorthand<any>>;
-    reparseDepthLimit: number;
-    static from(from: ReadonlyConfiguration): Configuration;
+  initializers: ((cxt: ParseContext) => void)[];
+  modules: Map<string, ModuleDefinition>;
+  blockModifiers: NameManager<BlockModifierDefinition<any>>;
+  inlineModifiers: NameManager<InlineModifierDefinition<any>>;
+  systemModifiers: NameManager<SystemModifierDefinition<any>>;
+  argumentInterpolators: NameManager<ArgumentInterpolatorDefinition>;
+  blockShorthands: NameManager<BlockShorthand<any>>;
+  inlineShorthands: NameManager<InlineShorthand<any>>;
+  kernel: KernelConfiguration;
+  static from(from: ReadonlyConfiguration): Configuration;
+}
+//#endregion
+//#region src/modifier.d.ts
+declare enum ModifierSlotType {
+  Normal = 0,
+  /** Content is preformatted: no escaping, no inner tags */
+  Preformatted = 1,
+  /** No content slot */
+  None = 2,
 }
-
+type ModifierMetadata = {};
+declare class ModifierBase<TNode, TEntity> {
+  readonly name: string;
+  readonly slotType: ModifierSlotType;
+  constructor(name: string, slotType?: ModifierSlotType, args?: Partial<ModifierBase<TNode, TEntity>>);
+  metadata: ModifierMetadata;
+  /**
+   * Common values: heading, emphasis, keyword, highlight, commentary, comment, link, quote, pre
+   */
+  roleHint?: string;
+  /**
+   * If true, any modifier encountered inside it will *not* be expanded *during parse-content*,
+   * *unless* that modifier is `alwaysTryExpand`. In the vast majority of cases, you shouldn't
+   * be using this.
+   */
+  delayContentExpansion: boolean;
+  /**
+   * If true, such a modifier will always be expanded whenever it is encountered, *even if*
+   * it is contained in a modifier with `delayContentExpansion`. In the vast majority of cases,
+   * you shouldn't be using this.
+   */
+  alwaysTryExpand: boolean;
+  /** Called before the modifier's content is parsed.
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+  */
+  beforeParseContent?: (node: TNode, cxt: ParseContext, immediate: boolean) => Message[];
+  /** Called after the modifier's content is parsed.
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+  */
+  afterParseContent?: (node: TNode, cxt: ParseContext, immediate: boolean) => Message[];
+  /** Called before reparsing of the expansion.
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.*/
+  beforeProcessExpansion?: (node: TNode, cxt: ParseContext, immediate: boolean) => Message[];
+  /** Called before reparsing of the expansion.
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.*/
+  afterProcessExpansion?: (node: TNode, cxt: ParseContext, immediate: boolean) => Message[];
+  /**
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+   */
+  prepareExpand?: (node: TNode, cxt: ParseContext, immediate: boolean) => Message[];
+  /**
+   * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
+   */
+  expand?: (node: TNode, cxt: ParseContext, immediate: boolean) => TEntity[] | undefined;
+}
+declare class BlockModifierDefinition<TState> extends ModifierBase<BlockModifierNode<TState>, BlockEntity> {}
+declare class InlineModifierDefinition<TState> extends ModifierBase<InlineModifierNode<TState>, InlineEntity> {}
+declare class SystemModifierDefinition<TState> extends ModifierBase<SystemModifierNode<TState>, never> {}
+declare class ArgumentInterpolatorDefinition {
+  readonly name: string;
+  readonly postfix: string;
+  constructor(name: string, postfix: string, args?: Partial<ArgumentInterpolatorDefinition>);
+  alwaysTryExpand: boolean;
+  expand?: (content: string, cxt: ParseContext, immediate: boolean) => string | undefined;
+}
+//#endregion
+//#region src/interface.d.ts
 declare enum MessageSeverity {
-    Info = 0,
-    Warning = 1,
-    Error = 2
+  Info = 0,
+  Warning = 1,
+  Error = 2,
 }
 type Message = {
-    readonly severity: MessageSeverity;
-    readonly location: LocationRange;
-    readonly info: string;
-    readonly code: number;
+  readonly severity: MessageSeverity;
+  readonly location: LocationRange;
+  readonly info: string;
+  readonly code: number;
 };
 type LocationRange = {
-    original?: LocationRange;
-    source: Source;
-    start: number;
-    end: number;
-    actualEnd?: number;
+  original?: LocationRange;
+  source: Source;
+  start: number;
+  end: number;
+  actualEnd?: number;
 };
 declare enum NodeType {
-    Root = 0,
-    Paragraph = 1,
-    Preformatted = 2,
-    Text = 3,
-    Escaped = 4,
-    SystemModifier = 5,
-    InlineModifier = 6,
-    BlockModifier = 7,
-    Interpolation = 8
+  Root = 0,
+  Group = 1,
+  Paragraph = 2,
+  Preformatted = 3,
+  Text = 4,
+  Escaped = 5,
+  SystemModifier = 6,
+  InlineModifier = 7,
+  BlockModifier = 8,
+  Interpolation = 9,
 }
+type RootNode = {
+  type: NodeType.Root;
+  content: BlockEntity[];
+  source: Source;
+};
+type GroupNode = {
+  location: LocationRange;
+  type: NodeType.Group;
+  content: BlockEntity[];
+};
 type ParagraphNode = {
-    location: LocationRange;
-    type: NodeType.Paragraph;
-    content: InlineEntity[];
+  location: LocationRange;
+  type: NodeType.Paragraph;
+  content: InlineEntity[];
 };
 type PreNode = {
-    location: LocationRange;
-    type: NodeType.Preformatted;
-    content: {
-        start: number;
-        end: number;
-        text: string;
-    };
+  location: LocationRange;
+  type: NodeType.Preformatted;
+  content: {
+    start: number;
+    end: number;
+    text: string;
+  };
 };
 type TextNode = {
-    location: LocationRange;
-    type: NodeType.Text;
-    content: string;
+  location: LocationRange;
+  type: NodeType.Text;
+  content: string;
 };
 type EscapedNode = {
-    location: LocationRange;
-    type: NodeType.Escaped;
-    content: string;
+  location: LocationRange;
+  type: NodeType.Escaped;
+  content: string;
 };
-type SystemModifierNode<TState> = {
-    location: LocationRange;
-    type: NodeType.SystemModifier;
-    mod: SystemModifierDefinition<TState>;
-    state?: TState;
-    head: LocationRange;
-    arguments: ModifierArgument[];
-    content: BlockEntity[];
-    expansion?: never[];
+type ModifierArguments = {
+  positional: ModifierArgument[];
+  named: Map<string, ModifierArgument>;
+  location: LocationRange;
 };
-type BlockModifierNode<TState> = {
-    location: LocationRange;
-    type: NodeType.BlockModifier;
-    mod: BlockModifierDefinition<TState>;
-    state?: TState;
-    head: LocationRange;
-    arguments: ModifierArgument[];
-    content: BlockEntity[];
-    expansion?: BlockEntity[];
+type ModifierNodeBase<TState> = {
+  location: LocationRange;
+  state?: TState;
+  head: LocationRange;
+  arguments: ModifierArguments;
 };
-type InlineModifierNode<TState> = {
-    location: LocationRange;
-    type: NodeType.InlineModifier;
-    mod: InlineModifierDefinition<TState>;
-    state?: TState;
-    head: LocationRange;
-    arguments: ModifierArgument[];
-    content: InlineEntity[];
-    expansion?: InlineEntity[];
+type SystemModifierNode<TState> = ModifierNodeBase<TState> & {
+  type: NodeType.SystemModifier;
+  mod: SystemModifierDefinition<TState>;
+  content: BlockEntity[];
+  expansion?: never[];
 };
-type RootNode = {
-    type: NodeType.Root;
-    content: BlockEntity[];
-    source: Source;
+type BlockModifierNode<TState> = ModifierNodeBase<TState> & {
+  type: NodeType.BlockModifier;
+  mod: BlockModifierDefinition<TState>;
+  content: BlockEntity[];
+  expansion?: BlockEntity[];
+};
+type InlineModifierNode<TState> = ModifierNodeBase<TState> & {
+  type: NodeType.InlineModifier;
+  mod: InlineModifierDefinition<TState>;
+  content: InlineEntity[];
+  expansion?: InlineEntity[];
 };
-type ModifierNode<T = any> = BlockModifierNode<T> | InlineModifierNode<T> | SystemModifierNode<T>;
-type BlockEntity = ParagraphNode | PreNode | BlockModifierNode<any> | SystemModifierNode<any>;
+type ModifierNode<T$1 = any> = BlockModifierNode<T$1> | InlineModifierNode<T$1> | SystemModifierNode<T$1>;
+type BlockEntity = GroupNode | ParagraphNode | PreNode | BlockModifierNode<any> | SystemModifierNode<any>;
 type InlineEntity = TextNode | EscapedNode | InlineModifierNode<any> | SystemModifierNode<any>;
 type DocumentNode = BlockEntity | InlineEntity | RootNode;
 type InterpolationNode = {
-    location: LocationRange;
-    type: NodeType.Interpolation;
-    definition: ArgumentInterpolatorDefinition;
-    argument: ModifierArgument;
-    expansion?: string;
+  location: LocationRange;
+  type: NodeType.Interpolation;
+  definition: ArgumentInterpolatorDefinition;
+  argument: ModifierArgument;
+  expansion?: string;
 };
 type ModifierArgument = {
-    location: LocationRange;
-    content: ArgumentEntity[];
-    expansion?: string;
+  location: LocationRange;
+  content: ArgumentEntity[];
+  expansion?: string;
 };
 type ArgumentEntity = TextNode | EscapedNode | InterpolationNode;
-declare enum ModifierSlotType {
-    Normal = 0,
-    /** Content is preformatted: no escaping, no inner tags */
-    Preformatted = 1,
-    /** No content slot */
-    None = 2
-}
-declare class ModifierBase<TNode, TEntity> {
-    readonly name: string;
-    readonly slotType: ModifierSlotType;
-    constructor(name: string, slotType?: ModifierSlotType, args?: Partial<ModifierBase<TNode, TEntity>>);
-    /**
-     * Common values: heading, emphasis, keyword, highlight, commentary, comment, link, quote
-     */
-    roleHint?: string;
-    /**
-     * If true, any modifier encountered inside it will *not* be expanded *during parse-content*,
-     * *unless* that modifier is `alwaysTryExpand`. In the vast majority of cases, you shouldn't
-     * be using this.
-     */
-    delayContentExpansion: boolean;
-    /**
-     * If true, such a modifier will always be expanded whenever it is encountered, *even if*
-     * it is contained in a modifier with `delayContentExpansion`. In the vast majority of cases,
-     * you shouldn't be using this.
-     */
-    alwaysTryExpand: boolean;
-    /** Called before the modifier's content is parsed.
-     * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
-    */
-    beforeParseContent?: (node: TNode, cxt: ParseContext, immediate: boolean) => Message[];
-    /** Called after the modifier's content is parsed.
-     * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
-    */
-    afterParseContent?: (node: TNode, cxt: ParseContext, immediate: boolean) => Message[];
-    /** Called before reparsing of the expansion.
-     * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.*/
-    beforeProcessExpansion?: (node: TNode, cxt: ParseContext, immediate: boolean) => Message[];
-    /** Called before reparsing of the expansion.
-     * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.*/
-    afterProcessExpansion?: (node: TNode, cxt: ParseContext, immediate: boolean) => Message[];
-    /**
-     * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
-     */
-    prepareExpand?: (node: TNode, cxt: ParseContext, immediate: boolean) => Message[];
-    /**
-     * @param immediate False when the node is inside a `delayContentExpansion` modifier, but it is `alwaysTryExpand`; otherwise true.
-     */
-    expand?: (node: TNode, cxt: ParseContext, immediate: boolean) => TEntity[] | undefined;
-}
-declare class BlockModifierDefinition<TState> extends ModifierBase<BlockModifierNode<TState>, BlockEntity> {
-}
-declare class InlineModifierDefinition<TState> extends ModifierBase<InlineModifierNode<TState>, InlineEntity> {
-}
-declare class SystemModifierDefinition<TState> extends ModifierBase<SystemModifierNode<TState>, never> {
-}
-declare class ArgumentInterpolatorDefinition {
-    readonly name: string;
-    readonly postfix: string;
-    constructor(name: string, postfix: string, args?: Partial<ArgumentInterpolatorDefinition>);
-    alwaysTryExpand: boolean;
-    expand?: (content: string, cxt: ParseContext, immediate: boolean) => string | undefined;
-}
-type Shorthand<TMod> = {
-    name: string;
-    parts: readonly string[];
-    postfix: string | undefined;
-    mod: TMod;
-};
-type BlockShorthand<TState> = Shorthand<BlockModifierDefinition<TState>>;
-type InlineShorthand<TState> = Shorthand<InlineModifierDefinition<TState>>;
-
-declare class SimpleScanner implements Scanner {
-    private src;
-    readonly source: Source;
-    private pos;
-    constructor(src: string, sourceDesc?: SourceDescriptor);
-    position(): number;
-    isEOF(): boolean;
-    peek(str: string): boolean;
-    acceptChar(): string;
-    accept(str: string): boolean;
-    acceptWhitespaceChar(): string | null;
-}
-interface Scanner {
-    readonly source: Source;
-    position(): number;
-    isEOF(): boolean;
-    peek(str: string): boolean;
-    accept(str: string): boolean;
-    acceptChar(): string;
-    acceptWhitespaceChar(): string | null;
-}
-
-declare function parse(scanner: Scanner, cxt: ParseContext): Document$1;
-
+//#endregion
+//#region src/parser.d.ts
+declare class Parser {
+  #private;
+  private scanner;
+  private cxt;
+  private emit;
+  private delayDepth;
+  constructor(scanner: Scanner, cxt: ParseContext);
+  parse(): Document$1;
+  private WHITESPACES;
+  private WHITESPACES_OR_NEWLINES;
+  private SHOULD_BE_A_NEWLINE;
+  private WARN_IF_MORE_NEWLINES_THAN;
+  private DOCUMENT;
+  private BLOCK_ENTITY;
+  private MODIFIER;
+  private PRE_PARAGRAPH;
+  private MAYBE_GROUPED_PARAGRAPH;
+  private PARAGRAPH;
+  private SHORTHAND;
+  private MODIFIER_BODY;
+  private INLINE_ENTITY;
+  private PREFORMATTED_INLINE_ENTITY;
+  private ARGUMENT_CONTENT;
+  private POSSIBLY_NAMED_ARGUMENT;
+  private ARGUMENTS;
+}
+//#endregion
+//#region src/renderer.d.ts
 type RendererType<TState, TReturn, TDocument, TOptions = undefined> = {
-    state: TState;
-    return: TReturn;
-    document: TDocument;
-    options: TOptions;
+  state: TState;
+  return: TReturn;
+  document: TDocument;
+  options: TOptions;
 };
 type AnyRendererType = RendererType<any, any, any, any>;
 type getState<Type> = Type extends RendererType<infer T, any, any, any> ? T : never;
@@ -318,317 +391,337 @@ type getReturn<Type> = Type extends RendererType<any, infer T, any, any> ? T : n
 type getDocument<Type> = Type extends RendererType<any, any, infer T, any> ? T : never;
 type getOptions<Type> = Type extends RendererType<any, any, any, infer T> ? T : never;
 type NodeRenderer<Type extends AnyRendererType, TNode> = (node: TNode, cxt: RenderContext<Type>) => getReturn<Type>;
-type NodeRendererDefinition<Type extends AnyRendererType, TNode, TDef> = [
-    def: TDef,
-    renderer: NodeRenderer<Type, TNode>
-];
+type NodeRendererDefinition<Type extends AnyRendererType, TNode, TDef> = [def: TDef, renderer: NodeRenderer<Type, TNode>];
 declare class RenderContext<Type extends AnyRendererType> {
-    readonly config: RenderConfiguration<Type>;
-    readonly parsedDocument: Document$1;
-    state: getState<Type>;
-    renderEntity(node: BlockEntity | InlineEntity): getReturn<Type> | undefined;
-    constructor(config: RenderConfiguration<Type>, parsedDocument: Document$1, state: getState<Type>);
+  readonly config: RenderConfiguration<Type>;
+  readonly parsedDocument: Document$1;
+  state: getState<Type>;
+  renderEntity(node: BlockEntity | InlineEntity): getReturn<Type>[];
+  constructor(config: RenderConfiguration<Type>, parsedDocument: Document$1, state: getState<Type>);
 }
 interface ReadonlyRenderConfiguration<Type extends AnyRendererType> {
-    readonly options: getOptions<Type>;
-    readonly paragraphRenderer?: NodeRenderer<Type, ParagraphNode>;
-    readonly textRenderer?: NodeRenderer<Type, TextNode | PreNode | EscapedNode>;
-    readonly undefinedBlockRenderer?: NodeRenderer<Type, BlockModifierNode<any>>;
-    readonly undefinedInlineRenderer?: NodeRenderer<Type, InlineModifierNode<any>>;
-    readonly blockRenderers: ReadonlyMap<BlockModifierDefinition<any>, NodeRenderer<Type, BlockModifierNode<any>>>;
-    readonly inlineRenderers: ReadonlyMap<InlineModifierDefinition<any>, NodeRenderer<Type, InlineModifierNode<any>>>;
-    readonly postprocessor: (results: getReturn<Type>[], cxt: RenderContext<Type>) => getDocument<Type>;
-    render(doc: Document$1, state: getState<Type>): getDocument<Type>;
+  readonly options: getOptions<Type>;
+  readonly paragraphRenderer?: NodeRenderer<Type, ParagraphNode>;
+  readonly textRenderer?: NodeRenderer<Type, TextNode | PreNode | EscapedNode>;
+  readonly undefinedBlockRenderer?: NodeRenderer<Type, BlockModifierNode<any>>;
+  readonly undefinedInlineRenderer?: NodeRenderer<Type, InlineModifierNode<any>>;
+  readonly blockRenderers: ReadonlyMap<BlockModifierDefinition<any>, NodeRenderer<Type, BlockModifierNode<any>>>;
+  readonly inlineRenderers: ReadonlyMap<InlineModifierDefinition<any>, NodeRenderer<Type, InlineModifierNode<any>>>;
+  readonly postprocessor: (results: getReturn<Type>[], cxt: RenderContext<Type>) => getDocument<Type>;
+  render(doc: Document$1, state: getState<Type>): getDocument<Type>;
 }
 type BlockRendererDefiniton<Type extends AnyRendererType, ModState = any> = NodeRendererDefinition<Type, BlockModifierNode<ModState>, BlockModifierDefinition<ModState>>;
 type InlineRendererDefiniton<Type extends AnyRendererType, ModState = any> = NodeRendererDefinition<Type, InlineModifierNode<ModState>, InlineModifierDefinition<ModState>>;
 declare class RenderConfiguration<Type extends AnyRendererType> implements ReadonlyRenderConfiguration<Type> {
-    options: getOptions<Type>;
-    postprocessor: (results: getReturn<Type>[], cxt: RenderContext<Type>) => getDocument<Type>;
-    paragraphRenderer?: NodeRenderer<Type, ParagraphNode>;
-    textRenderer?: NodeRenderer<Type, TextNode | PreNode | EscapedNode>;
-    undefinedBlockRenderer?: NodeRenderer<Type, BlockModifierNode<any>>;
-    undefinedInlineRenderer?: NodeRenderer<Type, InlineModifierNode<any>>;
-    blockRenderers: Map<BlockModifierDefinition<any>, NodeRenderer<Type, BlockModifierNode<any>>>;
-    inlineRenderers: Map<InlineModifierDefinition<any>, NodeRenderer<Type, InlineModifierNode<any>>>;
-    constructor(options: getOptions<Type>, postprocessor: (results: getReturn<Type>[], cxt: RenderContext<Type>) => getDocument<Type>);
-    render(doc: Document$1, state: getState<Type>): getDocument<Type>;
-    addBlockRenderer(...rs: BlockRendererDefiniton<Type>[]): void;
-    addInlineRenderer(...rs: InlineRendererDefiniton<Type>[]): void;
-    static from<Type extends AnyRendererType>(from: ReadonlyRenderConfiguration<Type>): RenderConfiguration<Type>;
+  options: getOptions<Type>;
+  postprocessor: (results: getReturn<Type>[], cxt: RenderContext<Type>) => getDocument<Type>;
+  paragraphRenderer?: NodeRenderer<Type, ParagraphNode>;
+  textRenderer?: NodeRenderer<Type, TextNode | PreNode | EscapedNode>;
+  undefinedBlockRenderer?: NodeRenderer<Type, BlockModifierNode<any>>;
+  undefinedInlineRenderer?: NodeRenderer<Type, InlineModifierNode<any>>;
+  blockRenderers: Map<BlockModifierDefinition<any>, NodeRenderer<Type, BlockModifierNode<any>>>;
+  inlineRenderers: Map<InlineModifierDefinition<any>, NodeRenderer<Type, InlineModifierNode<any>>>;
+  constructor(options: getOptions<Type>, postprocessor: (results: getReturn<Type>[], cxt: RenderContext<Type>) => getDocument<Type>);
+  render(doc: Document$1, state: getState<Type>): getDocument<Type>;
+  addBlockRenderer(...rs: BlockRendererDefiniton<Type>[]): void;
+  addInlineRenderer(...rs: InlineRendererDefiniton<Type>[]): void;
+  static from<Type extends AnyRendererType>(from: ReadonlyRenderConfiguration<Type>): RenderConfiguration<Type>;
+}
+declare namespace messages_d_exports {
+  export { ArgumentCountMismatchMessage, CannotExpandArgumentMessage, CannotUseModuleInSelfMessage, ContentExpectedMessage, DuplicateNamedArgumentMessage, EitherNormalOrPreMessage, EntityNotAllowedMessage, ExpectedMessage, InternalErrorMessage, InvalidArgumentMessage, MultipleBlocksNotPermittedMessage, NameAlreadyDefinedMessage, NewBlockShouldBeOnNewlineMessage, NoNestedModuleMessage, OnlySimpleParagraphsPermittedMessage, OverwriteDefinitionsMessage, OverwriteSpecialVariableMessage, ReachedRecursionLimitMessage, ShouldBeOnNewlineMessage, SlotUsedOutsideDefinitionMessage, UnclosedInlineModifierMessage, UndefinedVariableMessage, UnknownModifierMessage, UnnecessaryNewlineMessage };
 }
-
 declare class AddThingMessage implements Message {
-    readonly code: number;
-    readonly severity: MessageSeverity;
-    readonly location: LocationRange;
-    readonly info: string;
-    constructor(code: number, severity: MessageSeverity, location: LocationRange, info: string);
+  readonly code: number;
+  readonly severity: MessageSeverity;
+  readonly location: LocationRange;
+  readonly info: string;
+  constructor(code: number, severity: MessageSeverity, location: LocationRange, info: string);
 }
 declare class RemoveThingMessage implements Message {
-    readonly code: number;
-    readonly severity: MessageSeverity;
-    readonly location: LocationRange;
-    readonly info: string;
-    constructor(code: number, severity: MessageSeverity, location: LocationRange, info: string);
+  readonly code: number;
+  readonly severity: MessageSeverity;
+  readonly location: LocationRange;
+  readonly info: string;
+  constructor(code: number, severity: MessageSeverity, location: LocationRange, info: string);
 }
 declare class ExpectedMessage implements Message {
-    readonly location: LocationRange;
-    private what;
-    constructor(location: LocationRange, what: string);
-    readonly code = 1;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  private what;
+  constructor(location: LocationRange, what: string);
+  readonly code = 1;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class UnknownModifierMessage implements Message {
-    readonly location: LocationRange;
-    private what;
-    constructor(location: LocationRange, what: string);
-    readonly code = 2;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  private what;
+  constructor(location: LocationRange, what: string);
+  readonly code = 2;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class UnclosedInlineModifierMessage implements Message {
-    readonly location: LocationRange;
-    private what;
-    constructor(location: LocationRange, what: string);
-    readonly code = 3;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  private what;
+  constructor(location: LocationRange, what: string);
+  readonly code = 3;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class ArgumentCountMismatchMessage implements Message {
-    readonly location: LocationRange;
-    constructor(location: LocationRange, min?: number, max?: number);
-    private msg;
-    readonly code = 4;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  constructor(location: LocationRange, min?: number, max?: number);
+  private msg;
+  readonly code = 4;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class CannotExpandArgumentMessage implements Message {
-    readonly location: LocationRange;
-    private what?;
-    constructor(location: LocationRange, what?: string | undefined);
-    readonly code = 5;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  private what?;
+  constructor(location: LocationRange, what?: string | undefined);
+  readonly code = 5;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class InvalidArgumentMessage implements Message {
-    readonly location: LocationRange;
-    private what?;
-    constructor(location: LocationRange, what?: string | undefined);
-    readonly code = 6;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  private what?;
+  constructor(location: LocationRange, what?: string | undefined);
+  readonly code = 6;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class EntityNotAllowedMessage implements Message {
-    readonly location: LocationRange;
-    private what?;
-    constructor(location: LocationRange, what?: string | undefined);
-    readonly code = 7;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  private what?;
+  constructor(location: LocationRange, what?: string | undefined);
+  readonly code = 7;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class ReachedRecursionLimitMessage implements Message {
-    readonly location: LocationRange;
-    private limit;
-    private what;
-    constructor(location: LocationRange, limit: number, what: string);
-    readonly code = 8;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  private limit;
+  private what;
+  constructor(location: LocationRange, limit: number, what: string);
+  readonly code = 8;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class SlotUsedOutsideDefinitionMessage implements Message {
-    readonly location: LocationRange;
-    constructor(location: LocationRange);
-    readonly code = 9;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  constructor(location: LocationRange);
+  readonly code = 9;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class NoNestedModuleMessage implements Message {
-    readonly location: LocationRange;
-    constructor(location: LocationRange);
-    readonly code = 10;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  constructor(location: LocationRange);
+  readonly code = 10;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class CannotUseModuleInSelfMessage implements Message {
-    readonly location: LocationRange;
-    constructor(location: LocationRange);
-    readonly code = 11;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  constructor(location: LocationRange);
+  readonly code = 11;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class EitherNormalOrPreMessage implements Message {
-    readonly location: LocationRange;
-    constructor(location: LocationRange);
-    readonly code = 12;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  constructor(location: LocationRange);
+  readonly code = 12;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class MultipleBlocksNotPermittedMessage implements Message {
-    readonly location: LocationRange;
-    constructor(location: LocationRange);
-    readonly code = 13;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  constructor(location: LocationRange);
+  readonly code = 13;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class OnlySimpleParagraphsPermittedMessage implements Message {
-    readonly location: LocationRange;
-    constructor(location: LocationRange);
-    readonly code = 14;
-    readonly severity = MessageSeverity.Error;
-    get info(): string;
+  readonly location: LocationRange;
+  constructor(location: LocationRange);
+  readonly code = 14;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
+}
+declare class ContentExpectedMessage implements Message {
+  readonly location: LocationRange;
+  constructor(location: LocationRange);
+  readonly code = 15;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
+}
+declare class InternalErrorMessage implements Message {
+  readonly location: LocationRange;
+  readonly error: any;
+  constructor(location: LocationRange, error: any);
+  readonly code = 16;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
+}
+declare class DuplicateNamedArgumentMessage implements Message {
+  readonly location: LocationRange;
+  readonly name: string;
+  constructor(location: LocationRange, name: string);
+  readonly code = 17;
+  readonly severity = MessageSeverity.Error;
+  get info(): string;
 }
 declare class UnnecessaryNewlineMessage extends RemoveThingMessage {
-    constructor(location: LocationRange);
+  constructor(location: LocationRange);
 }
 declare class NewBlockShouldBeOnNewlineMessage extends AddThingMessage {
-    constructor(location: LocationRange);
+  constructor(location: LocationRange);
 }
 declare class ShouldBeOnNewlineMessage extends AddThingMessage {
-    constructor(location: LocationRange);
+  constructor(location: LocationRange);
 }
 declare class NameAlreadyDefinedMessage implements Message {
-    readonly location: LocationRange;
-    private what;
-    constructor(location: LocationRange, what: string);
-    readonly code = 4;
-    readonly severity = MessageSeverity.Warning;
-    get info(): string;
+  readonly location: LocationRange;
+  private what;
+  constructor(location: LocationRange, what: string);
+  readonly code = 4;
+  readonly severity = MessageSeverity.Warning;
+  get info(): string;
 }
 declare class UndefinedVariableMessage implements Message {
-    readonly location: LocationRange;
-    private what;
-    constructor(location: LocationRange, what: string);
-    readonly code = 5;
-    readonly severity = MessageSeverity.Warning;
-    get info(): string;
+  readonly location: LocationRange;
+  private what;
+  constructor(location: LocationRange, what: string);
+  readonly code = 5;
+  readonly severity = MessageSeverity.Warning;
+  get info(): string;
 }
 declare class OverwriteDefinitionsMessage implements Message {
-    readonly location: LocationRange;
-    private what;
-    constructor(location: LocationRange, what: string);
-    readonly code = 6;
-    readonly severity = MessageSeverity.Warning;
-    get info(): string;
+  readonly location: LocationRange;
+  private what;
+  constructor(location: LocationRange, what: string);
+  readonly code = 6;
+  readonly severity = MessageSeverity.Warning;
+  get info(): string;
 }
 declare class OverwriteSpecialVariableMessage implements Message {
-    readonly location: LocationRange;
-    private varname;
-    private previous;
-    constructor(location: LocationRange, varname: string, previous: string);
-    readonly code = 6;
-    readonly severity = MessageSeverity.Warning;
-    get info(): string;
-}
-
-type messages_ArgumentCountMismatchMessage = ArgumentCountMismatchMessage;
-declare const messages_ArgumentCountMismatchMessage: typeof ArgumentCountMismatchMessage;
-type messages_CannotExpandArgumentMessage = CannotExpandArgumentMessage;
-declare const messages_CannotExpandArgumentMessage: typeof CannotExpandArgumentMessage;
-type messages_CannotUseModuleInSelfMessage = CannotUseModuleInSelfMessage;
-declare const messages_CannotUseModuleInSelfMessage: typeof CannotUseModuleInSelfMessage;
-type messages_EitherNormalOrPreMessage = EitherNormalOrPreMessage;
-declare const messages_EitherNormalOrPreMessage: typeof EitherNormalOrPreMessage;
-type messages_EntityNotAllowedMessage = EntityNotAllowedMessage;
-declare const messages_EntityNotAllowedMessage: typeof EntityNotAllowedMessage;
-type messages_ExpectedMessage = ExpectedMessage;
-declare const messages_ExpectedMessage: typeof ExpectedMessage;
-type messages_InvalidArgumentMessage = InvalidArgumentMessage;
-declare const messages_InvalidArgumentMessage: typeof InvalidArgumentMessage;
-type messages_MultipleBlocksNotPermittedMessage = MultipleBlocksNotPermittedMessage;
-declare const messages_MultipleBlocksNotPermittedMessage: typeof MultipleBlocksNotPermittedMessage;
-type messages_NameAlreadyDefinedMessage = NameAlreadyDefinedMessage;
-declare const messages_NameAlreadyDefinedMessage: typeof NameAlreadyDefinedMessage;
-type messages_NewBlockShouldBeOnNewlineMessage = NewBlockShouldBeOnNewlineMessage;
-declare const messages_NewBlockShouldBeOnNewlineMessage: typeof NewBlockShouldBeOnNewlineMessage;
-type messages_NoNestedModuleMessage = NoNestedModuleMessage;
-declare const messages_NoNestedModuleMessage: typeof NoNestedModuleMessage;
-type messages_OnlySimpleParagraphsPermittedMessage = OnlySimpleParagraphsPermittedMessage;
-declare const messages_OnlySimpleParagraphsPermittedMessage: typeof OnlySimpleParagraphsPermittedMessage;
-type messages_OverwriteDefinitionsMessage = OverwriteDefinitionsMessage;
-declare const messages_OverwriteDefinitionsMessage: typeof OverwriteDefinitionsMessage;
-type messages_OverwriteSpecialVariableMessage = OverwriteSpecialVariableMessage;
-declare const messages_OverwriteSpecialVariableMessage: typeof OverwriteSpecialVariableMessage;
-type messages_ReachedRecursionLimitMessage = ReachedRecursionLimitMessage;
-declare const messages_ReachedRecursionLimitMessage: typeof ReachedRecursionLimitMessage;
-type messages_ShouldBeOnNewlineMessage = ShouldBeOnNewlineMessage;
-declare const messages_ShouldBeOnNewlineMessage: typeof ShouldBeOnNewlineMessage;
-type messages_SlotUsedOutsideDefinitionMessage = SlotUsedOutsideDefinitionMessage;
-declare const messages_SlotUsedOutsideDefinitionMessage: typeof SlotUsedOutsideDefinitionMessage;
-type messages_UnclosedInlineModifierMessage = UnclosedInlineModifierMessage;
-declare const messages_UnclosedInlineModifierMessage: typeof UnclosedInlineModifierMessage;
-type messages_UndefinedVariableMessage = UndefinedVariableMessage;
-declare const messages_UndefinedVariableMessage: typeof UndefinedVariableMessage;
-type messages_UnknownModifierMessage = UnknownModifierMessage;
-declare const messages_UnknownModifierMessage: typeof UnknownModifierMessage;
-type messages_UnnecessaryNewlineMessage = UnnecessaryNewlineMessage;
-declare const messages_UnnecessaryNewlineMessage: typeof UnnecessaryNewlineMessage;
-declare namespace messages {
-  export { messages_ArgumentCountMismatchMessage as ArgumentCountMismatchMessage, messages_CannotExpandArgumentMessage as CannotExpandArgumentMessage, messages_CannotUseModuleInSelfMessage as CannotUseModuleInSelfMessage, messages_EitherNormalOrPreMessage as EitherNormalOrPreMessage, messages_EntityNotAllowedMessage as EntityNotAllowedMessage, messages_ExpectedMessage as ExpectedMessage, messages_InvalidArgumentMessage as InvalidArgumentMessage, messages_MultipleBlocksNotPermittedMessage as MultipleBlocksNotPermittedMessage, messages_NameAlreadyDefinedMessage as NameAlreadyDefinedMessage, messages_NewBlockShouldBeOnNewlineMessage as NewBlockShouldBeOnNewlineMessage, messages_NoNestedModuleMessage as NoNestedModuleMessage, messages_OnlySimpleParagraphsPermittedMessage as OnlySimpleParagraphsPermittedMessage, messages_OverwriteDefinitionsMessage as OverwriteDefinitionsMessage, messages_OverwriteSpecialVariableMessage as OverwriteSpecialVariableMessage, messages_ReachedRecursionLimitMessage as ReachedRecursionLimitMessage, messages_ShouldBeOnNewlineMessage as ShouldBeOnNewlineMessage, messages_SlotUsedOutsideDefinitionMessage as SlotUsedOutsideDefinitionMessage, messages_UnclosedInlineModifierMessage as UnclosedInlineModifierMessage, messages_UndefinedVariableMessage as UndefinedVariableMessage, messages_UnknownModifierMessage as UnknownModifierMessage, messages_UnnecessaryNewlineMessage as UnnecessaryNewlineMessage };
-}
-
-declare function checkArgumentLength(node: ModifierNode, min?: number, max?: number | undefined): Message[] | null;
-declare function checkArguments(node: ModifierNode, min?: number, max?: number | undefined): Message[] | null;
+  readonly location: LocationRange;
+  private varname;
+  private previous;
+  constructor(location: LocationRange, varname: string, previous: string);
+  readonly code = 6;
+  readonly severity = MessageSeverity.Warning;
+  get info(): string;
+}
+declare namespace modifier_helper_d_exports {
+  export { bindArgs, createParagraphWrapper, createPlaintextWrapper, onlyPermitPlaintextParagraph, onlyPermitSimpleParagraphs, onlyPermitSingleBlock };
+}
+type BindResult<P extends string[], Opt extends string[], N extends Record<string, string>> = {
+  msgs: Message[];
+  args: undefined;
+  nodes: undefined;
+  rest: undefined;
+  restNodes: undefined;
+} | {
+  msgs: null;
+  args: { [key in P[number]]: string } & { [key in Opt[number]]?: string | undefined } & { [key in keyof N]: string };
+  nodes: { [key in P[number]]: ModifierArgument } & { [key in Opt[number]]: ModifierArgument | undefined } & { [key in keyof N]: ModifierArgument | undefined };
+  rest: string[];
+  restNodes: ModifierArgument[];
+};
+declare function bindArgs<P extends string[], Opt extends string[] = [], N extends Record<string, string> = {}>(node: ModifierNode, p: readonly [...P], opts?: {
+  named?: N;
+  optional?: readonly [...Opt];
+  rest?: boolean;
+  restNamed?: boolean;
+  trim?: boolean;
+}): BindResult<P, Opt, N>;
+/**
+ * Helper function to ensure that a modifier only accepts plaintext paragraphs as content.
+ * @returns The content as a string if OK, otherwise an array of error messages.
+ */
 declare function onlyPermitPlaintextParagraph(node: BlockModifierNode<any> | SystemModifierNode<any>): Message[] | string;
+/**
+ * Helper function to ensure that a modifier does not accept any block modifiers inside its content.
+ * @returns `null` if OK, otherwise an array of error messages.
+ */
 declare function onlyPermitSimpleParagraphs(node: BlockModifierNode<any> | SystemModifierNode<any>): Message[] | null;
-declare function onlyPermitSingleBlock(node: BlockModifierNode<any> | SystemModifierNode<any>): Message[] | null;
-
-declare const modifierHelper_checkArgumentLength: typeof checkArgumentLength;
-declare const modifierHelper_checkArguments: typeof checkArguments;
-declare const modifierHelper_onlyPermitPlaintextParagraph: typeof onlyPermitPlaintextParagraph;
-declare const modifierHelper_onlyPermitSimpleParagraphs: typeof onlyPermitSimpleParagraphs;
-declare const modifierHelper_onlyPermitSingleBlock: typeof onlyPermitSingleBlock;
-declare namespace modifierHelper {
-  export { modifierHelper_checkArgumentLength as checkArgumentLength, modifierHelper_checkArguments as checkArguments, modifierHelper_onlyPermitPlaintextParagraph as onlyPermitPlaintextParagraph, modifierHelper_onlyPermitSimpleParagraphs as onlyPermitSimpleParagraphs, modifierHelper_onlyPermitSingleBlock as onlyPermitSingleBlock };
-}
-
+/**
+ * Helper function to ensure that a modifier only accepts one block as its content.
+ * @returns `null` if OK, otherwise an array of error messages.
+ */
+declare function onlyPermitSingleBlock(node: BlockModifierNode<any> | SystemModifierNode<any>, opt?: {
+  optional?: boolean;
+}): Message[] | null;
+declare function createPlaintextWrapper(name: string, get: (cxt: ParseContext) => string | undefined, set: (cxt: ParseContext, value: string) => string, slotType?: ModifierSlotType): SystemModifierDefinition<void>;
+declare function createParagraphWrapper(name: string, get: (cxt: ParseContext) => ParagraphNode | undefined, set: (cxt: ParseContext, value: ParagraphNode) => void, slotType?: ModifierSlotType): SystemModifierDefinition<void>;
+//#endregion
+//#region src/node-util.d.ts
+type CloneNodeOptions = {
+  newLocation?: LocationRange;
+  withState?: boolean;
+};
+declare function cloneNode<T$1 extends DocumentNode>(node: T$1, options?: CloneNodeOptions): T$1;
+declare function cloneNodes<T$1 extends readonly DocumentNode[]>(nodes: T$1, options?: CloneNodeOptions): T$1;
+/** Warning: modifies the original nodes */
+declare function stripNode(...nodes: DocumentNode[]): DocumentNode[];
+//#endregion
+//#region src/builtin/builtin.d.ts
 declare const BuiltinConfiguration: ReadonlyConfiguration;
-
+//#endregion
+//#region src/default/default.d.ts
 declare const DefaultConfiguration: ReadonlyConfiguration;
-
+//#endregion
+//#region src/default/html-renderer.d.ts
 type HTMLRendererOptions = {
-    headPlugins: HTMLComponentPlugin[];
-    headerPlugins: HTMLComponentPlugin[];
-    footerPlugins: HTMLComponentPlugin[];
-    postprocessPlugins: HTMLPostprocessPlugin[];
-    transformAsset: (id: string) => string | undefined;
+  document: Document;
+  headPlugins: HTMLComponentPlugin[];
+  headerPlugins: HTMLComponentPlugin[];
+  footerPlugins: HTMLComponentPlugin[];
+  postprocessPlugins: HTMLPostprocessPlugin[];
+  transformAsset: (id: string) => string | undefined;
 };
 type HTMLRenderType = {
-    state: HTMLRenderState;
-    options: HTMLRendererOptions;
-    document: Document;
-    return: Node | Node[];
+  state: HTMLRenderState;
+  options: HTMLRendererOptions;
+  document: Document;
+  return: Node | Node[];
 };
 type HTMLRenderPlugin = (elem: BlockEntity | InlineEntity, cxt: RenderContext<HTMLRenderType>) => string | undefined;
 type HTMLComponentPlugin = (cxt: RenderContext<HTMLRenderType>) => Node | Node[] | undefined;
 type HTMLPostprocessPlugin = (cxt: RenderContext<HTMLRenderType>, output: Document) => void;
 declare class HTMLRenderState {
-    title: string;
-    stylesheet: string;
-    cssVariables: Map<string, string>;
-    invalidBlock(node: BlockEntity, msg: string): minimal_jsx_runtime.JSX.Element;
-    invalidInline(node: InlineEntity, msg: string): minimal_jsx_runtime.JSX.Element;
-    render(elems: (BlockEntity | InlineEntity)[], cxt: RenderContext<HTMLRenderType>): DocumentFragment;
+  title: string;
+  stylesheet: string;
+  cssVariables: Map<string, string>;
+  invalidBlock(node: BlockEntity, msg: string): minimal_jsx_runtime_jsx_runtime0.JSX.Element;
+  invalidInline(node: InlineEntity, msg: string): minimal_jsx_runtime_jsx_runtime0.JSX.Element;
+  render(elems: (BlockEntity | InlineEntity)[], cxt: RenderContext<HTMLRenderType>): DocumentFragment;
 }
 declare const HTMLRenderConfiguration: ReadonlyRenderConfiguration<HTMLRenderType>;
-
+//#endregion
+//#region src/debug-print.d.ts
 declare const debugPrint: {
-    blockModifier: (x: BlockModifierDefinition<any>) => string;
-    inlineModifier: (x: InlineModifierDefinition<any>) => string;
-    inlineShorthand: (x: InlineShorthand<any>) => string;
-    blockShorthand: (x: BlockShorthand<any>) => string;
-    argument: (arg: ModifierArgument) => string;
-    node: (...nodes: (BlockEntity | InlineEntity)[]) => string;
-    message: typeof debugPrintMsg;
-    range: typeof debugPrintRange;
-    document: typeof debugDumpDocument;
+  blockModifier: (x: BlockModifierDefinition<any>) => string;
+  inlineModifier: (x: InlineModifierDefinition<any>) => string;
+  inlineShorthand: (x: InlineShorthand<any>) => string;
+  blockShorthand: (x: BlockShorthand<any>) => string;
+  argument: (arg: ModifierArgument) => string;
+  node: (...nodes: (BlockEntity | InlineEntity)[]) => string;
+  message: typeof debugPrintMsg;
+  range: typeof debugPrintRange;
+  document: typeof debugDumpDocument;
 };
 declare function debugPrintRange(loc: LocationRange, context?: number): string;
 declare function debugPrintMsg(m: Message): string;
 declare function debugDumpDocument(doc: Document$1): string;
-
+//#endregion
+//#region src/index.d.ts
 declare const emmmVersion = "0.0.6";
 declare function setDebugLevel(level: DebugLevel): void;
-
-export { type ArgumentEntity, ArgumentInterpolatorDefinition, type BlockEntity, BlockModifierDefinition, type BlockModifierNode, type BlockRendererDefiniton, type BlockShorthand, BuiltinConfiguration, Configuration, DebugLevel, DefaultConfiguration, Document$1 as Document, type DocumentNode, type EscapedNode, type HTMLComponentPlugin, type HTMLPostprocessPlugin, HTMLRenderConfiguration, type HTMLRenderPlugin, HTMLRenderState, type HTMLRenderType, type HTMLRendererOptions, type InlineEntity, InlineModifierDefinition, type InlineModifierNode, type InlineRendererDefiniton, type InlineShorthand, type InterpolationNode, type LocationRange, type Message, MessageSeverity, type ModifierArgument, type ModifierNode, ModifierSlotType, type NodeRenderer, type NodeRendererDefinition, NodeType, type ParagraphNode, ParseContext, type ParseContextStoreDefinitions, type ParseContextStoreKey, type PreNode, type ReadonlyConfiguration, type ReadonlyRenderConfiguration, RenderConfiguration, RenderContext, type RendererType, type RootNode, type Scanner, SimpleScanner, type Source, type SourceDescriptor, StringSource, SystemModifierDefinition, type SystemModifierNode, type TextNode, debugPrint, emmmVersion, modifierHelper as helper, messages, parse, setDebugLevel };
+//#endregion
+export { ArgumentEntity, ArgumentInterpolatorDefinition, BlockEntity, BlockModifierDefinition, BlockModifierNode, BlockRendererDefiniton, BlockShorthand, BuiltinConfiguration, CloneNodeOptions, Configuration, DebugLevel, DefaultConfiguration, Document$1 as Document, DocumentNode, EscapedNode, GroupNode, HTMLComponentPlugin, HTMLPostprocessPlugin, HTMLRenderConfiguration, HTMLRenderPlugin, HTMLRenderState, HTMLRenderType, HTMLRendererOptions, InlineEntity, InlineModifierDefinition, InlineModifierNode, InlineRendererDefiniton, InlineShorthand, Inspector, InterpolationNode, KernelConfiguration, LocationRange, Message, MessageSeverity, ModifierArgument, ModifierArguments, ModifierMetadata, ModifierNode, ModifierSlotType, NodeRenderer, NodeRendererDefinition, NodeType, ParagraphNode, ParseContext, ParseContextStoreDefinitions, ParseContextStoreKey, Parser, PreNode, ReadonlyConfiguration, ReadonlyRenderConfiguration, RenderConfiguration, RenderContext, RendererType, RootNode, Scanner, SimpleScanner, Source, SourceDescriptor, StringSource, SystemModifierDefinition, SystemModifierNode, TextNode, cloneNode, cloneNodes, debugPrint, emmmVersion, modifier_helper_d_exports as helper, messages_d_exports as messages, setDebugLevel, stripNode };
+//# sourceMappingURL=index.d.ts.map