@the_dissidents/libemmm 0.0.2 → 0.0.3

package/dist/index.d.ts

@@ -11,8 +11,9 @@ declare class NameManager<T extends {
 }> {
     private array;
     private data;
-    constructor(from?: ReadonlyNameManager<T> | readonly T[]);
-    toArray(): readonly T[];
+    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;
@@ -23,33 +24,65 @@ type ReadonlyNameManager<T extends {
     name: string;
 }> = Omit<NameManager<T>, 'add' | 'remove'>;
 
-interface Scanner {
-    position(): number;
-    isEOF(): boolean;
-    peek(str: string): boolean;
-    accept(str: string): boolean;
-    acceptChar(): string;
-    acceptWhitespaceChar(): string | null;
-    acceptUntil(str: string): string | null;
+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>;
+}
+declare class Document {
+    readonly root: RootNode;
+    readonly context: ParseContext;
+    readonly messages: readonly Message[];
+    constructor(root: RootNode, context: ParseContext, messages: readonly Message[]);
+    toStripped(): Document;
+}
+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;
+}
+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;
 }
+
 declare enum MessageSeverity {
     Info = 0,
     Warning = 1,
     Error = 2
 }
-type FixSuggestion = {
-    info: string;
-    apply(src: string, cursor: number): [out_src: string, new_cursor: number];
-};
 type Message = {
     readonly severity: MessageSeverity;
-    readonly position: number;
-    readonly length: number;
+    readonly location: LocationRange;
     readonly info: string;
     readonly code: number;
-    readonly fixes: readonly FixSuggestion[];
 };
-type PositionRange = {
+type SourceDescriptor = {
+    name: string;
+};
+type LocationRange = {
+    original?: LocationRange;
+    source: SourceDescriptor;
     start: number;
     end: number;
     actualEnd?: number;
@@ -65,81 +98,94 @@ declare enum NodeType {
     BlockModifier = 7,
     Interpolation = 8
 }
-type ParagraphNode = PositionRange & {
+type ParagraphNode = {
+    location: LocationRange;
     type: NodeType.Paragraph;
     content: InlineEntity[];
 };
-type PreNode = PositionRange & {
+type PreNode = {
+    location: LocationRange;
     type: NodeType.Preformatted;
-    content: PositionRange & {
+    content: {
+        start: number;
+        end: number;
         text: string;
     };
 };
-type TextNode = PositionRange & {
+type TextNode = {
+    location: LocationRange;
     type: NodeType.Text;
     content: string;
 };
-type EscapedNode = PositionRange & {
+type EscapedNode = {
+    location: LocationRange;
     type: NodeType.Escaped;
     content: string;
 };
-type SystemModifierNode<TState> = PositionRange & {
+type SystemModifierNode<TState> = {
+    location: LocationRange;
     type: NodeType.SystemModifier;
     mod: SystemModifierDefinition<TState>;
     state?: TState;
-    head: PositionRange;
+    head: LocationRange;
     arguments: ModifierArgument[];
     content: BlockEntity[];
     expansion?: never[];
 };
-type BlockModifierNode<TState> = PositionRange & {
+type BlockModifierNode<TState> = {
+    location: LocationRange;
     type: NodeType.BlockModifier;
     mod: BlockModifierDefinition<TState>;
     state?: TState;
-    head: PositionRange;
+    head: LocationRange;
     arguments: ModifierArgument[];
     content: BlockEntity[];
     expansion?: BlockEntity[];
 };
-type InlineModifierNode<TState> = PositionRange & {
+type InlineModifierNode<TState> = {
+    location: LocationRange;
     type: NodeType.InlineModifier;
     mod: InlineModifierDefinition<TState>;
     state?: TState;
-    head: PositionRange;
+    head: LocationRange;
     arguments: ModifierArgument[];
     content: InlineEntity[];
     expansion?: InlineEntity[];
 };
-type RootNode = PositionRange & {
+type RootNode = {
     type: NodeType.Root;
     content: BlockEntity[];
+    source: SourceDescriptor;
 };
 type ModifierNode<T = any> = BlockModifierNode<T> | InlineModifierNode<T> | SystemModifierNode<T>;
 type BlockEntity = ParagraphNode | PreNode | BlockModifierNode<any> | SystemModifierNode<any>;
 type InlineEntity = TextNode | EscapedNode | InlineModifierNode<any> | SystemModifierNode<any>;
 type DocumentNode = BlockEntity | InlineEntity | RootNode;
-type InterpolationNode = PositionRange & {
+type InterpolationNode = {
+    location: LocationRange;
     type: NodeType.Interpolation;
     definition: ArgumentInterpolatorDefinition;
     argument: ModifierArgument;
     expansion?: string;
 };
-type ModifierArgument = PositionRange & {
+type ModifierArgument = {
+    location: LocationRange;
     content: ArgumentEntity[];
     expansion?: string;
 };
 type ArgumentEntity = TextNode | EscapedNode | InterpolationNode;
-declare enum ModifierFlags {
+declare enum ModifierSlotType {
     Normal = 0,
     /** Content is preformatted: no escaping, no inner tags */
     Preformatted = 1,
     /** No content slot */
-    Marker = 2
+    None = 2
 }
 declare class ModifierBase<TNode, TEntity> {
     readonly name: string;
-    readonly flags: ModifierFlags;
-    constructor(name: string, flags?: ModifierFlags, args?: Partial<ModifierBase<TNode, TEntity>>);
+    readonly slotType: ModifierSlotType;
+    constructor(name: string, slotType?: ModifierSlotType, args?: Partial<ModifierBase<TNode, TEntity>>);
+    roleHint?: string;
     delayContentExpansion: boolean;
     alwaysTryExpand: boolean;
     beforeParseContent?: (node: TNode, cxt: ParseContext, immediate: boolean) => Message[];
@@ -162,225 +208,238 @@ declare class ArgumentInterpolatorDefinition {
     alwaysTryExpand: boolean;
     expand?: (content: string, cxt: ParseContext, immediate: boolean) => string | undefined;
 }
-type BlockInstantiationData = {
-    mod: BlockModifierDefinition<any>;
-    slotContent: BlockEntity[];
-    args: Map<string, string>;
-};
-type InlineInstantiationData = {
-    mod: InlineModifierDefinition<any>;
-    slotContent: InlineEntity[];
-    args: Map<string, string>;
+type Shorthand<TMod> = {
+    name: string;
+    parts: readonly string[];
+    postfix: string | undefined;
+    mod: TMod;
 };
-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>;
-}
-declare class Document {
-    root: RootNode;
-    context: ParseContext;
-    messages: Message[];
-    constructor(root: RootNode, context: ParseContext, messages: Message[]);
-    debugPrint(source: string): string;
-}
-interface ReadonlyConfiguration {
-    initializers: readonly ((cxt: ParseContext) => void)[];
-    blockModifiers: ReadonlyNameManager<BlockModifierDefinition<any>>;
-    inlineModifiers: ReadonlyNameManager<InlineModifierDefinition<any>>;
-    systemModifiers: ReadonlyNameManager<SystemModifierDefinition<any>>;
-    argumentInterpolators: ReadonlyNameManager<ArgumentInterpolatorDefinition>;
-    reparseDepthLimit: number;
-}
-declare class Configuration {
-    initializers: ((cxt: ParseContext) => void)[];
-    blockModifiers: NameManager<BlockModifierDefinition<any>>;
-    inlineModifiers: NameManager<InlineModifierDefinition<any>>;
-    systemModifiers: NameManager<SystemModifierDefinition<any>>;
-    argumentInterpolators: NameManager<ArgumentInterpolatorDefinition>;
-    reparseDepthLimit: number;
-    constructor(from?: ReadonlyConfiguration);
-}
+type BlockShorthand<TState> = Shorthand<BlockModifierDefinition<TState>>;
+type InlineShorthand<TState> = Shorthand<InlineModifierDefinition<TState>>;
 
 declare class SimpleScanner implements Scanner {
     private src;
+    readonly source: SourceDescriptor;
     private pos;
-    constructor(src: string);
+    constructor(src: string, source?: SourceDescriptor);
     position(): number;
     isEOF(): boolean;
     peek(str: string): boolean;
     acceptChar(): string;
     accept(str: string): boolean;
     acceptWhitespaceChar(): string | null;
-    acceptUntil(str: string): string | null;
+}
+interface Scanner {
+    readonly source: SourceDescriptor;
+    position(): number;
+    isEOF(): boolean;
+    peek(str: string): boolean;
+    accept(str: string): boolean;
+    acceptChar(): string;
+    acceptWhitespaceChar(): string | null;
 }
 
-declare function parse(scanner: Scanner, config: Configuration): Document;
+declare function parse(scanner: Scanner, cxt: ParseContext): Document;
 
-declare class ReferredMessage implements Message {
-    readonly original: Message;
-    readonly position: number;
-    readonly length: number;
-    constructor(original: Message, position: number, length: number);
-    get severity(): MessageSeverity;
-    get info(): string;
-    get code(): number;
-    readonly fixes: readonly FixSuggestion[];
+type RendererType<TState, TReturn, TOptions = undefined> = {
+    state: TState;
+    return: TReturn;
+    options: TOptions;
+};
+type AnyRendererType = RendererType<any, any, any>;
+type getState<Type> = Type extends RendererType<infer T, any, any> ? T : never;
+type getReturn<Type> = Type extends RendererType<any, infer T, any> ? T : never;
+type getOptions<Type> = Type extends RendererType<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 parseContext: ParseContext;
+    state: getState<Type>;
+    renderEntity(node: BlockEntity | InlineEntity): getReturn<Type> | undefined;
+    constructor(config: RenderConfiguration<Type>, parseContext: ParseContext, 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>) => getReturn<Type>;
+    render(doc: Document, state: getState<Type>): getReturn<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>) => getReturn<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>) => getReturn<Type>);
+    render(doc: Document, state: getState<Type>): getReturn<Type>;
+    addBlockRenderer(...rs: BlockRendererDefiniton<Type>[]): void;
+    addInlineRenderer(...rs: InlineRendererDefiniton<Type>[]): void;
+    static from<Type extends AnyRendererType>(from: ReadonlyRenderConfiguration<Type>): RenderConfiguration<Type>;
 }
+
 declare class AddThingMessage implements Message {
     readonly code: number;
     readonly severity: MessageSeverity;
-    readonly position: number;
-    readonly length: number;
+    readonly location: LocationRange;
     readonly info: string;
-    private fixstr;
-    private what;
-    constructor(code: number, severity: MessageSeverity, position: number, length: number, info: string, fixstr: string, what: string);
-    get fixes(): readonly FixSuggestion[];
+    constructor(code: number, severity: MessageSeverity, location: LocationRange, info: string);
 }
 declare class RemoveThingMessage implements Message {
     readonly code: number;
     readonly severity: MessageSeverity;
-    readonly position: number;
-    readonly length: number;
+    readonly location: LocationRange;
     readonly info: string;
-    private fixstr;
-    constructor(code: number, severity: MessageSeverity, position: number, length: number, info: string, fixstr: string);
-    get fixes(): readonly FixSuggestion[];
+    constructor(code: number, severity: MessageSeverity, location: LocationRange, info: string);
 }
 declare class ExpectedMessage implements Message {
-    readonly position: number;
+    readonly location: LocationRange;
     private what;
-    constructor(position: number, what: string);
+    constructor(location: LocationRange, what: string);
     readonly code = 1;
     readonly severity = MessageSeverity.Error;
-    get length(): number;
     get info(): string;
-    get fixes(): readonly FixSuggestion[];
 }
 declare class UnknownModifierMessage implements Message {
-    readonly position: number;
-    readonly length: number;
+    readonly location: LocationRange;
     private what;
-    constructor(position: number, length: number, what: string);
+    constructor(location: LocationRange, what: string);
     readonly code = 2;
     readonly severity = MessageSeverity.Error;
     get info(): string;
-    get fixes(): readonly FixSuggestion[];
 }
 declare class UnclosedInlineModifierMessage implements Message {
-    readonly position: number;
+    readonly location: LocationRange;
     private what;
-    constructor(position: number, what: string);
+    constructor(location: LocationRange, what: string);
     readonly code = 3;
     readonly severity = MessageSeverity.Error;
-    readonly length = 0;
-    readonly fixes: readonly FixSuggestion[];
     get info(): string;
 }
 declare class ArgumentCountMismatchMessage implements Message {
-    readonly position: number;
-    readonly length: number;
-    constructor(position: number, length: number, min?: number, max?: number);
+    readonly location: LocationRange;
+    constructor(location: LocationRange, min?: number, max?: number);
     private msg;
     readonly code = 4;
     readonly severity = MessageSeverity.Error;
-    readonly fixes: readonly FixSuggestion[];
     get info(): string;
 }
 declare class CannotExpandArgumentMessage implements Message {
-    readonly position: number;
-    readonly length: number;
+    readonly location: LocationRange;
     private what?;
-    constructor(position: number, length: number, what?: string | undefined);
+    constructor(location: LocationRange, what?: string | undefined);
     readonly code = 5;
     readonly severity = MessageSeverity.Error;
-    readonly fixes: readonly FixSuggestion[];
     get info(): string;
 }
 declare class InvalidArgumentMessage implements Message {
-    readonly position: number;
-    readonly length: number;
+    readonly location: LocationRange;
     private what?;
-    constructor(position: number, length: number, what?: string | undefined);
+    constructor(location: LocationRange, what?: string | undefined);
     readonly code = 6;
     readonly severity = MessageSeverity.Error;
-    readonly fixes: readonly FixSuggestion[];
     get info(): string;
 }
-declare class InlineDefinitonInvalidEntityMessage implements Message {
-    readonly position: number;
-    readonly length: number;
-    constructor(position: number, length: number);
+declare class EntityNotAllowedMessage implements Message {
+    readonly location: LocationRange;
+    private what?;
+    constructor(location: LocationRange, what?: string | undefined);
     readonly code = 7;
     readonly severity = MessageSeverity.Error;
-    readonly fixes: readonly FixSuggestion[];
     get info(): string;
 }
 declare class ReachedRecursionLimitMessage implements Message {
-    readonly position: number;
-    readonly length: number;
+    readonly location: LocationRange;
     private limit;
     private what;
-    constructor(position: number, length: number, limit: number, what: string);
+    constructor(location: LocationRange, limit: number, what: string);
     readonly code = 8;
     readonly severity = MessageSeverity.Error;
-    readonly fixes: readonly FixSuggestion[];
     get info(): string;
 }
 declare class SlotUsedOutsideDefinitionMessage implements Message {
-    readonly position: number;
-    readonly length: number;
-    constructor(position: number, length: number);
+    readonly location: LocationRange;
+    constructor(location: LocationRange);
     readonly code = 9;
     readonly severity = MessageSeverity.Error;
-    readonly fixes: readonly FixSuggestion[];
     get info(): string;
 }
-declare class CannotPopNotationMessage implements Message {
-    readonly position: number;
-    readonly length: number;
-    constructor(position: number, length: number);
+declare class NoNestedModuleMessage implements Message {
+    readonly location: LocationRange;
+    constructor(location: LocationRange);
     readonly code = 10;
     readonly severity = MessageSeverity.Error;
-    readonly fixes: readonly FixSuggestion[];
+    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 UnnecessaryNewlineMessage extends RemoveThingMessage {
-    constructor(pos: number, len: number);
+    constructor(location: LocationRange);
 }
 declare class NewBlockShouldBeOnNewlineMessage extends AddThingMessage {
-    constructor(pos: number);
+    constructor(location: LocationRange);
 }
 declare class ContentShouldBeOnNewlineMessage extends AddThingMessage {
-    constructor(pos: number);
+    constructor(location: LocationRange);
 }
 declare class NameAlreadyDefinedMessage implements Message {
-    readonly position: number;
-    readonly length: number;
+    readonly location: LocationRange;
     private what;
-    constructor(position: number, length: number, what: string);
+    constructor(location: LocationRange, what: string);
     readonly code = 4;
     readonly severity = MessageSeverity.Warning;
-    readonly fixes: readonly FixSuggestion[];
     get info(): string;
 }
 declare class UndefinedVariableMessage implements Message {
-    readonly position: number;
-    readonly length: number;
+    readonly location: LocationRange;
     private what;
-    constructor(position: number, length: number, what: string);
+    constructor(location: LocationRange, what: string);
     readonly code = 5;
     readonly severity = MessageSeverity.Warning;
-    readonly fixes: readonly FixSuggestion[];
+    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;
 }
 
@@ -388,24 +447,32 @@ type messages_ArgumentCountMismatchMessage = ArgumentCountMismatchMessage;
 declare const messages_ArgumentCountMismatchMessage: typeof ArgumentCountMismatchMessage;
 type messages_CannotExpandArgumentMessage = CannotExpandArgumentMessage;
 declare const messages_CannotExpandArgumentMessage: typeof CannotExpandArgumentMessage;
-type messages_CannotPopNotationMessage = CannotPopNotationMessage;
-declare const messages_CannotPopNotationMessage: typeof CannotPopNotationMessage;
+type messages_CannotUseModuleInSelfMessage = CannotUseModuleInSelfMessage;
+declare const messages_CannotUseModuleInSelfMessage: typeof CannotUseModuleInSelfMessage;
 type messages_ContentShouldBeOnNewlineMessage = ContentShouldBeOnNewlineMessage;
 declare const messages_ContentShouldBeOnNewlineMessage: typeof ContentShouldBeOnNewlineMessage;
+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_InlineDefinitonInvalidEntityMessage = InlineDefinitonInvalidEntityMessage;
-declare const messages_InlineDefinitonInvalidEntityMessage: typeof InlineDefinitonInvalidEntityMessage;
 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_ReachedRecursionLimitMessage = ReachedRecursionLimitMessage;
 declare const messages_ReachedRecursionLimitMessage: typeof ReachedRecursionLimitMessage;
-type messages_ReferredMessage = ReferredMessage;
-declare const messages_ReferredMessage: typeof ReferredMessage;
 type messages_SlotUsedOutsideDefinitionMessage = SlotUsedOutsideDefinitionMessage;
 declare const messages_SlotUsedOutsideDefinitionMessage: typeof SlotUsedOutsideDefinitionMessage;
 type messages_UnclosedInlineModifierMessage = UnclosedInlineModifierMessage;
@@ -417,11 +484,50 @@ 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_CannotPopNotationMessage as CannotPopNotationMessage, messages_ContentShouldBeOnNewlineMessage as ContentShouldBeOnNewlineMessage, messages_ExpectedMessage as ExpectedMessage, messages_InlineDefinitonInvalidEntityMessage as InlineDefinitonInvalidEntityMessage, messages_InvalidArgumentMessage as InvalidArgumentMessage, messages_NameAlreadyDefinedMessage as NameAlreadyDefinedMessage, messages_NewBlockShouldBeOnNewlineMessage as NewBlockShouldBeOnNewlineMessage, messages_ReachedRecursionLimitMessage as ReachedRecursionLimitMessage, messages_ReferredMessage as ReferredMessage, messages_SlotUsedOutsideDefinitionMessage as SlotUsedOutsideDefinitionMessage, messages_UnclosedInlineModifierMessage as UnclosedInlineModifierMessage, messages_UndefinedVariableMessage as UndefinedVariableMessage, messages_UnknownModifierMessage as UnknownModifierMessage, messages_UnnecessaryNewlineMessage as UnnecessaryNewlineMessage };
+  export { messages_ArgumentCountMismatchMessage as ArgumentCountMismatchMessage, messages_CannotExpandArgumentMessage as CannotExpandArgumentMessage, messages_CannotUseModuleInSelfMessage as CannotUseModuleInSelfMessage, messages_ContentShouldBeOnNewlineMessage as ContentShouldBeOnNewlineMessage, 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_ReachedRecursionLimitMessage as ReachedRecursionLimitMessage, messages_SlotUsedOutsideDefinitionMessage as SlotUsedOutsideDefinitionMessage, messages_UnclosedInlineModifierMessage as UnclosedInlineModifierMessage, messages_UndefinedVariableMessage as UndefinedVariableMessage, messages_UnknownModifierMessage as UnknownModifierMessage, messages_UnnecessaryNewlineMessage as UnnecessaryNewlineMessage };
 }
 
 declare const BuiltinConfiguration: ReadonlyConfiguration;
 
+declare const DefaultConfiguration: ReadonlyConfiguration;
+
+type HTMLRendererOptions = {
+    headPlugins: HTMLComponentPlugin[];
+    headerPlugins: HTMLComponentPlugin[];
+    footerPlugins: HTMLComponentPlugin[];
+    transformAsset: (url: URL) => string | undefined;
+};
+type HTMLRenderType = {
+    state: HTMLRenderState;
+    options: HTMLRendererOptions;
+    return: string;
+};
+type HTMLRenderPlugin = (elem: BlockEntity | InlineEntity, cxt: RenderContext<HTMLRenderType>) => string | undefined;
+type HTMLComponentPlugin = (cxt: RenderContext<HTMLRenderType>) => string | undefined;
+type HTMLPostprocessPlugin = (cxt: RenderContext<HTMLRenderType>, output: string) => string;
+declare class HTMLRenderState {
+    title: string;
+    stylesheet: string;
+    cssVariables: Map<string, string>;
+    escape(content: string): string;
+    invalidBlock(node: BlockEntity, msg: string): string;
+    invalidInline(node: InlineEntity, msg: string): string;
+    render(elems: (BlockEntity | InlineEntity)[], cxt: RenderContext<HTMLRenderType>): string;
+}
+declare const HTMLRenderConfiguration: ReadonlyRenderConfiguration<HTMLRenderType>;
+
+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: (m: Message, source?: string, descriptor?: SourceDescriptor) => string;
+    document: typeof debugDumpDocument;
+};
+declare function debugDumpDocument(doc: Document, source: string): string;
+
 declare function setDebugLevel(level: DebugLevel): void;
 
-export { type ArgumentEntity, ArgumentInterpolatorDefinition, type BlockEntity, type BlockInstantiationData, BlockModifierDefinition, type BlockModifierNode, BuiltinConfiguration, Configuration, DebugLevel, Document, type DocumentNode, type EscapedNode, type FixSuggestion, type InlineEntity, type InlineInstantiationData, InlineModifierDefinition, type InlineModifierNode, type InterpolationNode, type Message, MessageSeverity, type ModifierArgument, ModifierFlags, type ModifierNode, NodeType, type ParagraphNode, ParseContext, type ParseContextStoreDefinitions, type ParseContextStoreKey, type PositionRange, type PreNode, type ReadonlyConfiguration, type RootNode, type Scanner, SimpleScanner, SystemModifierDefinition, type SystemModifierNode, type TextNode, messages, parse, setDebugLevel };
+export { type ArgumentEntity, ArgumentInterpolatorDefinition, type BlockEntity, BlockModifierDefinition, type BlockModifierNode, type BlockRendererDefiniton, type BlockShorthand, BuiltinConfiguration, Configuration, DebugLevel, DefaultConfiguration, 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 SourceDescriptor, SystemModifierDefinition, type SystemModifierNode, type TextNode, debugPrint, messages, parse, setDebugLevel };