@the_dissidents/libemmm 0.0.7 → 0.0.9

package/dist/index.d.cts

@@ -0,0 +1,727 @@
+import * as minimal_jsx_runtime_jsx_runtime0 from "minimal-jsx-runtime/jsx-runtime";
+
+//#region rolldown:runtime
+//#endregion
+//#region src/debug.d.ts
+declare enum DebugLevel {
+  Trace = 0,
+  Info = 1,
+  Warning = 2,
+  Error = 3,
+  None = 4,
+}
+//#endregion
+//#region src/source.d.ts
+type SourceDescriptor = {
+  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;
+}
+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;
+}
+//#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;
+}
+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$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 {
+  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)[];
+}
+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 kernel: KernelConfiguration;
+}
+declare class Configuration implements ReadonlyConfiguration {
+  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,
+}
+type Message = {
+  readonly severity: MessageSeverity;
+  readonly location: LocationRange;
+  readonly info: string;
+  readonly code: number;
+};
+type LocationRange = {
+  original?: LocationRange;
+  source: Source;
+  start: number;
+  end: number;
+  actualEnd?: number;
+};
+declare enum NodeType {
+  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[];
+};
+type PreNode = {
+  location: LocationRange;
+  type: NodeType.Preformatted;
+  content: {
+    start: number;
+    end: number;
+    text: string;
+  };
+};
+type TextNode = {
+  location: LocationRange;
+  type: NodeType.Text;
+  content: string;
+};
+type EscapedNode = {
+  location: LocationRange;
+  type: NodeType.Escaped;
+  content: string;
+};
+type ModifierArguments = {
+  positional: ModifierArgument[];
+  named: Map<string, ModifierArgument>;
+  location: LocationRange;
+};
+type ModifierNodeBase<TState> = {
+  location: LocationRange;
+  state?: TState;
+  head: LocationRange;
+  arguments: ModifierArguments;
+};
+type SystemModifierNode<TState> = ModifierNodeBase<TState> & {
+  type: NodeType.SystemModifier;
+  mod: SystemModifierDefinition<TState>;
+  content: BlockEntity[];
+  expansion?: never[];
+};
+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$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;
+};
+type ModifierArgument = {
+  location: LocationRange;
+  content: ArgumentEntity[];
+  expansion?: string;
+};
+type ArgumentEntity = TextNode | EscapedNode | InterpolationNode;
+//#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;
+};
+type AnyRendererType = RendererType<any, any, any, any>;
+type getState<Type> = Type extends RendererType<infer T, any, any, any> ? T : never;
+type getReturn<Type> = Type extends RendererType<any, infer T, any, any> ? T : never;
+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>];
+declare class RenderContext<Type extends AnyRendererType> {
+  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>;
+}
+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>;
+}
+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);
+}
+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);
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+}
+declare class SlotUsedOutsideDefinitionMessage implements Message {
+  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;
+}
+declare class CannotUseModuleInSelfMessage implements Message {
+  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;
+}
+declare class MultipleBlocksNotPermittedMessage implements Message {
+  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;
+}
+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);
+}
+declare class NewBlockShouldBeOnNewlineMessage extends AddThingMessage {
+  constructor(location: LocationRange);
+}
+declare class ShouldBeOnNewlineMessage extends AddThingMessage {
+  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;
+}
+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;
+}
+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;
+}
+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;
+}
+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;
+/**
+ * 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 = {
+  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[];
+};
+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_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;
+};
+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;
+//#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.cts.map