@flex-development/docmark-util-types 1.0.0-dev.1

package/dist/index.d.mts

@@ -0,0 +1,1957 @@
+import type { Construct as Construct$1, Extension as Extension$1, Constructs as Constructs$1, State as State$1, Code as Code$1, CommentKindMap as CommentKindMap$1, AnyConstruct as AnyConstruct$1, ConstructPack as ConstructPack$1, ConstructPosition as ConstructPosition$1, Exiter as Exiter$1, Previous as Previous$1, Resolver as Resolver$1, Tokenizer as Tokenizer$1, ConstructRecord as ConstructRecord$1, CommentKind as CommentKind$1, Point as Point$1, TokenizeContext as TokenizeContext$1, Place as Place$1, Attempt as Attempt$1, Check, Consume as Consume$1, Enter as Enter$1, Exit as Exit$1, Interrupt, EncodingMap as EncodingMap$1, TokenType as TokenType$1, TokenFields as TokenFields$1, Token as Token$1, EventType as EventType$1, Effects as Effects$1, AttentionMarkers as AttentionMarkers$1, Disable as Disable$1, InsideSpan as InsideSpan$1, Value as Value$1, Initializer as Initializer$1, ContentType as ContentType$1, InitialConstruct as InitialConstruct$1, Create as Create$1, FullNormalizedExtension as FullNormalizedExtension$1, Lazy as Lazy$1, AnyExtension as AnyExtension$1, FinalizeContext as FinalizeContext$1, InitialConstructs as InitialConstructs$1, Column as Column$1, Line as Line$1, Offset as Offset$1, FileLike as FileLike$1, Encoding as Encoding$1, Chunk as Chunk$1, Event as Event$1, Position as Position$1, SerializeOptions as SerializeOptions$1, TokenTypeMap as TokenTypeMap$1, ContainerState as ContainerState$1, DefineSkip as DefineSkip$1, Now as Now$1, ParseContext as ParseContext$1, SliceSerialize as SliceSerialize$1, SliceStream as SliceStream$1, Write as Write$1 } from '@flex-development/docmark-util-types';
+import type * as micromark from 'micromark-util-types';
+import type { Debugger } from 'debug';
+import type { Numeric } from '@flex-development/mark/core';
+
+/**
+ * @file AnyConstruct
+ * @module docmark-util-types/AnyConstruct
+ */
+
+/**
+ * A `docmark` or `micromark` construct.
+ *
+ * @see {@linkcode Construct}
+ * @see {@linkcode micromark.Construct}
+ */
+type AnyConstruct = Construct$1 | micromark.Construct;
+
+/**
+ * @file AnyExtension
+ * @module docmark-util-types/AnyExtension
+ */
+
+/**
+ * A `docmark` or `micromark` syntax extension.
+ *
+ * @see {@linkcode Extension}
+ * @see {@linkcode micromark.Extension}
+ */
+type AnyExtension = Extension$1 | micromark.Extension;
+
+/**
+ * @file Attempt
+ * @module docmark-util-types/Attempt
+ */
+
+/**
+ * Attempt deals with several constructs,
+ * and tries to parse according to those constructs.
+ *
+ * If a construct results in `ok`, the tokens that were produced are used and
+ * the `ok` state is switched to.
+ *
+ * If the result is `nok`, the attempt failed and the state machine reverts back
+ * to its original state.
+ *
+ * @see {@linkcode Constructs}
+ * @see {@linkcode State}
+ *
+ * @this {void}
+ *
+ * @param {Constructs} construct
+ *  The construct, construct list, or construct record to try
+ * @param {State} ok
+ *  The successful tokenization state
+ * @param {State | undefined} [nok]
+ *  The failed tokenization state
+ * @return {State}
+ *  The next state
+ */
+type Attempt = (this: void, construct: Constructs$1, ok: State$1, nok?: State$1 | undefined) => State$1;
+
+/**
+ * @file AttentionMarkers
+ * @module docmark-util-types/AttentionMarkers
+ */
+
+/**
+ * Attention marker settings.
+ */
+interface AttentionMarkers {
+    /**
+     * The list of character codes representing attention markers.
+     *
+     * @see {@linkcode Code}
+     */
+    null?: Code$1[] | undefined;
+}
+
+/**
+ * @file Chunk
+ * @module docmark-util-types/Chunk
+ */
+
+/**
+ * A character code or a slice of a buffer in the form of a string.
+ *
+ * Chunks are used because strings are more efficient storage that character
+ * codes, but limited in what they can represent.
+ *
+ * @see {@linkcode Code}
+ */
+type Chunk = Code$1 | string;
+
+/**
+ * @file Code
+ * @module docmark-util-types/Code
+ */
+/**
+ * A character code.
+ *
+ * This often the same as what [`String#codePointAt`][codepointat] yields,
+ * but docmark adds meaning to other values as well.
+ *
+ * The code `null` represents the end of the input stream (`eos`).
+ * Negative integers are used instead of certain sequences of characters (such
+ * as line endings and tabs).
+ *
+ * [codepointat]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt
+ */
+type Code = number | null;
+
+/**
+ * @file Column
+ * @module docmark-util-types/Column
+ */
+/**
+ * A column in the source content (`1`-indexed integer).
+ */
+type Column = number;
+
+/**
+ * @file CommentKindMap
+ * @module docmark-util-types/CommentKindMap
+ */
+/**
+ * Registry of comment kinds.
+ *
+ * Libraries and other tools can augment this interface to register custom
+ * comment kinds.
+ *
+ * @example
+ *  declare module '@flex-development/docmark-util-types' {
+ *    interface CommentKindMap {
+ *      hashbang: 'hashbang'
+ *    }
+ *  }
+ */
+interface CommentKindMap {
+    block: 'block';
+    docblock: 'docblock';
+    line: 'line';
+}
+
+/**
+ * @file CommentKind
+ * @module docmark-util-types/CommentKind
+ */
+
+/**
+ * Union of registered comment kinds.
+ *
+ * To register custom comment kinds, augment {@linkcode CommentKindMap}.
+ * They will be added to this union automatically.
+ */
+type CommentKind = CommentKindMap$1[keyof CommentKindMap$1];
+
+/**
+ * @file ConstructPack
+ * @module docmark-util-types/ConstructPack
+ */
+
+/**
+ * A construct or a list of constructs.
+ *
+ * @see {@linkcode AnyConstruct}
+ */
+type ConstructPack = AnyConstruct$1 | AnyConstruct$1[];
+
+/**
+ * @file ConstructPosition
+ * @module docmark-util-types/ConstructPosition
+ */
+/**
+ * Union of construct positions.
+ *
+ * Positions determine whether a construct,
+ * when in a {@linkcode ConstructRecord}, takes precedence over existing
+ * constructs for the same character code when merged.
+ */
+type ConstructPosition = 'after' | 'before';
+
+/**
+ * @file ConstructRecord
+ * @module docmark-util-types/ConstructRecord
+ */
+
+/**
+ * Several constructs, mapped from their initial codes.
+ */
+interface ConstructRecord {
+    /**
+     * Try tokenizing constructs that start with the specified character code.
+     *
+     * @see {@linkcode ConstructPack}
+     * @see {@linkcode Numeric}
+     */
+    [code: Numeric | number]: ConstructPack$1 | undefined;
+    /**
+     * Try tokenizing constructs that start with any character code.
+     *
+     * @see {@linkcode ConstructPack}
+     */
+    null?: ConstructPack$1 | undefined;
+}
+
+/**
+ * @file Construct
+ * @module docmark-util-types/Construct
+ */
+
+/**
+ * Object describing how to tokenize a syntax construct.
+ */
+interface Construct {
+    /**
+     * Whether the construct, when in a {@linkcode ConstructRecord},
+     * takes precedence over existing constructs for the same character code
+     * when merged.
+     *
+     * @see {@linkcode ConstructPosition}
+     */
+    add?: ConstructPosition$1 | undefined;
+    /**
+     * Whether the construct is concrete.
+     *
+     * Concrete constructs cannot be interrupted by other constructs.
+     *
+     * For example, when parsing a markdown document (containers, such as block
+     * quotes and lists) and this construct is parsing fenced code:
+     *
+     * ````markdown
+     * > ```js
+     * > - list?
+     * ````
+     *
+     * …then `- list?` cannot form if this fenced code construct is concrete.
+     *
+     * An example of a construct that is not concrete is a GFM table:
+     *
+     * ````markdown
+     * | a |
+     * | - |
+     * > | b |
+     * ````
+     *
+     * ...`b` is not part of the table.
+     */
+    concrete?: boolean | undefined;
+    /**
+     * For containers, a continuation construct.
+     */
+    continuation?: Construct | undefined;
+    /**
+     * For containers, a final exit hook.
+     *
+     * @see {@linkcode Exiter}
+     */
+    exit?: Exiter$1 | undefined;
+    /**
+     * The name of the construct, used to toggle constructs off.
+     *
+     * > 👉 **Note**: Named constructs must not be {@linkcode partial}.
+     */
+    name?: string | undefined;
+    /**
+     * Whether the construct represents a partial construct.
+     *
+     * > 👉 **Note**: Partial constructs must not have a {@linkcode name}.
+     */
+    partial?: boolean | undefined;
+    /**
+     * Check if the previous character code can precede this construct.
+     *
+     * @see {@linkcode Previous}
+     */
+    previous?: Previous$1 | undefined;
+    /**
+     * Resolve the events parsed by {@linkcode tokenize}.
+     *
+     * @see {@linkcode Resolver}
+     */
+    resolve?: Resolver$1 | undefined;
+    /**
+     * Resolve all events when the content is complete, from the start to the end.
+     *
+     * > 👉 **Note**: Only called if {@linkcode tokenize} is successful at least
+     * > once in the content.
+     *
+     * @see {@linkcode Resolver}
+     */
+    resolveAll?: Resolver$1 | undefined;
+    /**
+     * Resolve the events parsed from the start of the content (which may include
+     * other constructs) to the last one parsed by {@linkcode tokenize}.
+     *
+     * @see {@linkcode Resolver}
+     */
+    resolveTo?: Resolver$1 | undefined;
+    /**
+     * Set up a state machine to handle character codes streaming in.
+     *
+     * @see {@linkcode Tokenizer}
+     */
+    tokenize: Tokenizer$1;
+}
+
+/**
+ * @file Constructs
+ * @module docmark-util-types/Constructs
+ */
+
+/**
+ * A single construct, a list of constructs, or a record of constructs.
+ *
+ * @see {@linkcode ConstructPack}
+ * @see {@linkcode ConstructRecord}
+ */
+type Constructs = ConstructPack$1 | ConstructRecord$1;
+
+/**
+ * @file Consume
+ * @module docmark-util-types/Consume
+ */
+
+/**
+ * Deal with a character `code` and move onto the next.
+ *
+ * @see {@linkcode Code}
+ *
+ * @this {void}
+ *
+ * @param {Code} code
+ *  The character code to consume
+ * @return {undefined}
+ */
+type Consume = (this: void, code: Code$1) => undefined;
+
+/**
+ * @file ContainerState
+ * @module docmark-util-types/ContainerState
+ */
+
+/**
+ * State shared between container calls.
+ *
+ * This interface can be augmented to register custom fields.
+ *
+ * @example
+ *  declare module '@flex-development/docmark-util-types' {
+ *    interface ContainerState {
+ *      custom?: boolean | null | undefined
+ *    }
+ *  }
+ *
+ * @see {@linkcode micromark.ContainerState}
+ *
+ * @extends {micromark.ContainerState}
+ */
+interface ContainerState extends micromark.ContainerState {
+    /**
+     * The current comment kind.
+     *
+     * The comment kind is captured at the `source` level after a comment has just
+     * been entered.\
+     * The kind ({@linkcode TokenFields._kind}) is extracted from the first event
+     * produced by the current comment construct.
+     *
+     * @see {@linkcode CommentKind}
+     */
+    comment?: CommentKind$1 | undefined;
+}
+
+/**
+ * @file ContentType
+ * @module docmark-util-types/ContentType
+ */
+
+/**
+ * Union of content types.\
+ * Content types are used on tokens to define their subcontent type.
+ *
+ * The highest level of content is `source`, and represents a source document or
+ * source content fragment.
+ *
+ * The next level is `comment`, and represents the contents of a documentation
+ * comment after the opening delimiter and before the closing delimiter.\
+ * By default, comment content consists of an optional summary followed by zero
+ * or more block tags.
+ *
+ * @todo document markdown content levels
+ *
+ * @see {@linkcode micromark.ContentType}
+ */
+type ContentType = micromark.ContentType | 'comment' | 'source' | 'type';
+
+/**
+ * @file ContinuableConstruct
+ * @module docmark-util-types/ContinuableConstruct
+ */
+
+/**
+ * A construct that can be continued.
+ *
+ * @see {@linkcode Construct}
+ *
+ * @extends {Construct}
+ */
+interface ContinuableConstruct extends Construct$1 {
+    /**
+     * The continuation construct.
+     *
+     * @see {@linkcode Construct}
+     *
+     * @override
+     */
+    continuation: Construct$1;
+    /**
+     * For containers, a final exit hook.
+     *
+     * @see {@linkcode Exiter}
+     *
+     * @override
+     */
+    exit: Exiter$1;
+}
+
+/**
+ * @file Create
+ * @module docmark-util-types/Create
+ */
+
+/**
+ * Create a tokenization context.
+ *
+ * @see {@linkcode Point}
+ * @see {@linkcode TokenizeContext}
+ *
+ * @this {void}
+ *
+ * @param {Point | undefined} [from]
+ *  Where to start parsing from
+ * @return {TokenizeContext}
+ *  The new tokenization context
+ */
+type Create = (this: void, from?: Point$1 | undefined) => TokenizeContext$1;
+
+/**
+ * @file DefineSkip
+ * @module docmark-util-types/DefineSkip
+ */
+
+/**
+ * Define a skip.
+ *
+ * Where a line starts after a prefix can be defined here.
+ *
+ * When the tokenizer moves after consuming a line ending corresponding to
+ * the line number in the given point, the tokenizer shifts past the prefix
+ * based on the column in the shifted point.
+ *
+ * @see {@linkcode Place}
+ *
+ * @this {void}
+ *
+ * @param {Place} point
+ *  The skip point
+ * @return {undefined}
+ */
+type DefineSkip = (this: void, point: Place$1) => undefined;
+
+/**
+ * @file Disable
+ * @module docmark-util-types/Disable
+ */
+/**
+ * Disabled construct settings.
+ */
+interface Disable {
+    /**
+     * The list of disabled construct names.
+     */
+    null?: string[] | undefined;
+}
+
+/**
+ * @file Effects
+ * @module docmark-util-types/Effects
+ */
+
+/**
+ * Context object to transition the state machine.
+ */
+interface Effects {
+    /**
+     * Try to tokenize a construct.
+     *
+     * @see {@linkcode Attempt}
+     */
+    attempt: Attempt$1;
+    /**
+     * Try to tokenize a construct, then revert.
+     *
+     * @see {@linkcode Check}
+     */
+    check: Check;
+    /**
+     * Deal with a character code and move onto the next.
+     *
+     * @see {@linkcode Consume}
+     */
+    consume: Consume$1;
+    /**
+     * Start a new token.
+     *
+     * @see {@linkcode Enter}
+     */
+    enter: Enter$1;
+    /**
+     * Close an open token.
+     *
+     * @see {@linkcode Exit}
+     */
+    exit: Exit$1;
+    /**
+     * Try to tokenize a construct, then revert.
+     *
+     * > 👉 **Note**: Sets `context.interrupt` to `true`.
+     *
+     * @see {@linkcode Interrupt}
+     */
+    interrupt: Interrupt;
+}
+
+/**
+ * @file EncodingMap
+ * @module docmark-util-types/EncodingMap
+ */
+/**
+ * Registry of encodings supported by {@linkcode TextDecoder}.
+ *
+ * > 👉 **Note**: Arbitrary encodings can be supported depending on how an
+ * > engine is built, so any string *could* be valid.
+ *
+ * This interface can be augmented to register custom encodings.
+ *
+ * @example
+ *  declare module '@flex-development/docmark-util-types' {
+ *    interface EncodingMap {
+ *      custom: 'custom'
+ *    }
+ *  }
+ *
+ * @see https://nodejs.org/api/util.html#whatwg-supported-encodings
+ */
+interface EncodingMap {
+    unicode: 'unicode-1-1-utf-8';
+    unknown: string & {};
+    utf16: 'utf16';
+    utf16be: 'utf-16be' | 'utf16be';
+    utf16le: 'utf-16le' | 'utf16le';
+    utf8: 'utf-8' | 'utf8';
+}
+
+/**
+ * @file Encoding
+ * @module docmark-util-types/Encoding
+ */
+
+/**
+ * Union of encodings supported by {@linkcode TextDecoder}.
+ *
+ * > 👉 **Note**: Arbitrary encodings can be supported depending on how an
+ * > engine is built, so any string *could* be valid.
+ *
+ * To register custom encodings, augment {@linkcode EncodingMap}.
+ * They will be added to this union automatically.
+ */
+type Encoding = EncodingMap$1[keyof EncodingMap$1];
+
+/**
+ * @file Enter
+ * @module docmark-util-types/Enter
+ */
+
+/**
+ * Start a new token.
+ *
+ * @see {@linkcode TokenFields}
+ * @see {@linkcode TokenType}
+ * @see {@linkcode Token}
+ *
+ * @this {void}
+ *
+ * @param {TokenType} type
+ *  The token type
+ * @param {TokenFields | undefined} [fields]
+ *  The token fields
+ * @return {Token}
+ *  The open token
+ */
+type Enter = (this: void, type: TokenType$1, fields?: TokenFields$1 | undefined) => Token$1;
+
+/**
+ * @file Event
+ * @module docmark-util-types/Event
+ */
+/**
+ * Union of event types.
+ */
+type EventType = 'enter' | 'exit';
+
+/**
+ * @file Event
+ * @module docmark-util-types/Event
+ */
+
+/**
+ * The start or end of a token amongst other events.
+ *
+ * Tokens can "contain" other tokens, even though they are stored in a flat
+ * list, through `enter`ing before them, and `exit`ing after them.
+ *
+ * @see {@linkcode EventType}
+ * @see {@linkcode TokenType}
+ * @see {@linkcode TokenizeContext}
+ * @see {@linkcode Token}
+ *
+ * @template {TokenType} [T=TokenType]
+ *  The token type
+ */
+type Event<T extends TokenType$1 = TokenType$1> = [
+    event: EventType$1,
+    token: Token$1<T>,
+    context: TokenizeContext$1
+];
+
+/**
+ * @file Exit
+ * @module docmark-util-types/Exit
+ */
+
+/**
+ * Close an open token.
+ *
+ * @see {@linkcode TokenType}
+ * @see {@linkcode Token}
+ *
+ * @this {void}
+ *
+ * @param {TokenType} type
+ *  The token type
+ * @return {Token}
+ *  The closed token
+ */
+type Exit = (this: void, type: TokenType$1) => Token$1;
+
+/**
+ * @file Exiter
+ * @module docmark-util-types/Exiter
+ */
+
+/**
+ * The final hook to run when a container must be closed.
+ *
+ * > 👉 **Note**: Like a {@linkcode Tokenizer}, but without `ok` and `nok`, and
+ * > returns `undefined`.
+ *
+ * @see {@linkcode Effects}
+ * @see {@linkcode TokenizeContext}
+ *
+ * @this {TokenizeContext}
+ *
+ * @param {Effects} effects
+ *  The context object used to transition the state machine
+ * @return {undefined}
+ */
+type Exiter = (this: TokenizeContext$1, effects: Effects$1) => undefined;
+
+/**
+ * @file Extension
+ * @module docmark-util-types/Extension
+ */
+
+/**
+ * A syntax extension.
+ *
+ * Syntax extensions are objects whose fields are typically the names of hooks,
+ * referring to where constructs "hook" into. The fields at such objects are
+ * character codes, mapping to constructs as values.
+ *
+ * This interface can be augmented to register custom fields.
+ *
+ * @example
+ *  declare module '@flex-development/docmark-util-types' {
+ *    interface Extension {
+ *      custom?: { null?: Code[] | undefined } | undefined
+ *    }
+ *  }
+ */
+interface Extension {
+    /**
+     * The attention marker settings.
+     *
+     * @see {@linkcode AttentionMarkers}
+     */
+    attentionMarkers?: AttentionMarkers$1 | undefined;
+    /**
+     * @todo `comment`
+     *
+     * @see {@linkcode ConstructRecord}
+     */
+    comment?: ConstructRecord$1 | undefined;
+    /**
+     * @todo `content`
+     *
+     * @see {@linkcode ConstructRecord}
+     */
+    content?: ConstructRecord$1 | undefined;
+    /**
+     * @todo `contentInitial`
+     *
+     * @see {@linkcode ConstructRecord}
+     */
+    contentInitial?: ConstructRecord$1 | undefined;
+    /**
+     * The disabled construct settings.
+     *
+     * @see {@linkcode Disable}
+     */
+    disable?: Disable$1 | undefined;
+    /**
+     * @todo `document`
+     *
+     * @see {@linkcode ConstructRecord}
+     */
+    document?: ConstructRecord$1 | undefined;
+    /**
+     * @todo `flow`
+     *
+     * @see {@linkcode ConstructRecord}
+     */
+    flow?: ConstructRecord$1 | undefined;
+    /**
+     * @todo `flowInitial`
+     *
+     * @see {@linkcode ConstructRecord}
+     */
+    flowInitial?: ConstructRecord$1 | undefined;
+    /**
+     * @todo `insideSpan`
+     *
+     * @see {@linkcode InsideSpan}
+     */
+    insideSpan?: InsideSpan$1 | undefined;
+    /**
+     * @todo `source`
+     *
+     * @see {@linkcode ConstructRecord}
+     */
+    source?: ConstructRecord$1 | undefined;
+    /**
+     * @todo `string`
+     *
+     * @see {@linkcode ConstructRecord}
+     */
+    string?: ConstructRecord$1 | undefined;
+    /**
+     * @todo `text`
+     *
+     * @see {@linkcode ConstructRecord}
+     */
+    text?: ConstructRecord$1 | undefined;
+    /**
+     * @todo `type`
+     *
+     * @see {@linkcode ConstructRecord}
+     */
+    type?: ConstructRecord$1 | undefined;
+}
+
+/**
+ * @file FileLike
+ * @module docmark-util-types/FileLike
+ */
+
+/**
+ * A file-like structure.
+ */
+type FileLike = {
+    /**
+     * The contents of the file.
+     *
+     * @see {@linkcode Value}
+     */
+    value: Value$1;
+};
+
+/**
+ * @file FinalizeContext
+ * @module docmark-util-types/FinalizeContext
+ */
+
+/**
+ * Finalize the tokenization context.
+ *
+ * @see {@linkcode TokenizeContext}
+ *
+ * @this {void}
+ *
+ * @param {TokenizeContext} context
+ *  The current tokenization context
+ * @return {undefined}
+ */
+type FinalizeContext = (this: void, context: TokenizeContext$1) => undefined;
+
+/**
+ * @file FullNormalizedExtension
+ * @module docmark-util-types/FullNormalizedExtension
+ */
+
+/**
+ * A full, filtered, and normalized extension, where all properties are required
+ * and defined.
+ *
+ * @see {@linkcode Extension}
+ */
+type FullNormalizedExtension = {
+    [K in keyof Extension$1]-?: Exclude<Extension$1[K], null | undefined>;
+};
+
+/**
+ * @file InitialConstruct
+ * @module docmark-util-types/InitialConstruct
+ */
+
+/**
+ * An initial construct.
+ *
+ * > 👉 **Note**: Like a construct,
+ * > but `tokenize` does not accept `ok` or `nok`.
+ *
+ * @see {@linkcode Construct}
+ *
+ * @extends {Construct}
+ */
+interface InitialConstruct extends Construct$1 {
+    /**
+     * Set up a state machine to handle character codes streaming in.
+     *
+     * @see {@linkcode Initializer}
+     *
+     * @override
+     */
+    tokenize: Initializer$1;
+}
+
+/**
+ * @file InitialConstructs
+ * @module docmark-util-types/InitialConstructs
+ */
+
+/**
+ * Record where each key is {@linkcode ContentType},
+ * and each value is an {@linkcode InitialConstruct}.
+ */
+type InitialConstructs = {
+    [K in ContentType$1]: InitialConstruct$1;
+};
+
+/**
+ * @file Initializer
+ * @module docmark-util-types/Initializer
+ */
+
+/**
+ * Set up an initial state machine.
+ *
+ * > 👉 **Note**: Like a {@linkcode Tokenizer}, but without `ok` and `nok`.
+ *
+ * @see {@linkcode Effects}
+ * @see {@linkcode State}
+ * @see {@linkcode TokenizeContext}
+ *
+ * @this {TokenizeContext}
+ *
+ * @param {Effects} effects
+ *  The context object used to transition the state machine
+ * @return {State}
+ *  The initial state
+ */
+type Initializer = (this: TokenizeContext$1, effects: Effects$1) => State$1;
+
+/**
+ * @file InsideSpan
+ * @module docmark-util-types/InsideSpan
+ */
+
+/**
+ * Resolvers to run inside a span.
+ */
+interface InsideSpan {
+    /**
+     * The list of resolvers to run.
+     *
+     * @see {@linkcode AnyConstruct}
+     */
+    null?: Pick<AnyConstruct$1, 'resolveAll'>[] | undefined;
+}
+
+/**
+ * @file Lazy
+ * @module docmark-util-types/Lazy
+ */
+
+/**
+ * Record, where each key is a line number, and each value is a boolean
+ * indicating if the line is lazy (as opposed to the line before it).
+ *
+ * For example:
+ *
+ * ```markdown
+ * > a
+ * b
+ * ```
+ *
+ * L1 is not lazy, but L2 is.
+ *
+ * @see {@linkcode Line}
+ */
+type Lazy = {
+    [line: Line]: boolean;
+};
+
+/**
+ * @file Line
+ * @module docmark-util-types/Line
+ */
+/**
+ * A line in the source content (`1`-indexed integer).
+ */
+type Line = number;
+
+/**
+ * @file NamedConstruct
+ * @module docmark-util-types/NamedConstruct
+ */
+
+/**
+ * A construct with a name.
+ *
+ * @see {@linkcode Construct}
+ *
+ * @extends {Construct}
+ */
+interface NamedConstruct extends Construct$1 {
+    /**
+     * The name of the construct.
+     *
+     * @override
+     */
+    name: string;
+}
+
+/**
+ * @file NormalizedExtension
+ * @module docmark-util-types/NormalizedExtension
+ */
+
+/**
+ * A filtered, combined extension, where all properties are optional,
+ * but defined.
+ *
+ * @see {@linkcode Extension}
+ */
+type NormalizedExtension = {
+    [Key in keyof Extension$1]: Exclude<Extension$1[Key], null | undefined>;
+};
+
+/**
+ * @file Now
+ * @module docmark-util-types/Now
+ */
+
+/**
+ * Get the current place in the content.
+ *
+ * @see {@linkcode Place}
+ *
+ * @this {void}
+ *
+ * @return {Place}
+ *  The current place
+ */
+type Now = (this: void) => Place$1;
+
+/**
+ * @file Offset
+ * @module docmark-util-types/Offset
+ */
+/**
+ * A position in the source content (`0`-indexed integer).
+ */
+type Offset = number;
+
+/**
+ * @file ParseContext
+ * @module docmark-util-types/ParseContext
+ */
+
+/**
+ * Context object to assist with parsing.
+ *
+ * This interface can be augmented to register custom fields.
+ *
+ * @example
+ *  declare module '@flex-development/docmark-util-types' {
+ *    interface ParseContext {
+ *      list: string[]
+ *    }
+ *  }
+ */
+interface ParseContext {
+    /**
+     * Whether the current line is blank.
+     */
+    atBlankLine?: boolean | null | undefined;
+    /**
+     * Create a comment content parser.
+     *
+     * @see {@linkcode Create}
+     */
+    comment: Create$1;
+    /**
+     * The normalized syntax extension.
+     *
+     * @see {@linkcode FullNormalizedExtension}
+     */
+    constructs: FullNormalizedExtension$1;
+    /**
+     * Create a markdown content parser.
+     *
+     * @see {@linkcode Create}
+     */
+    content: Create$1;
+    /**
+     * The list of defined markdown identifiers.
+     */
+    defined: string[];
+    /**
+     * Create a markdown document parser.
+     *
+     * @see {@linkcode Create}
+     */
+    document: Create$1;
+    /**
+     * Create a markdown flow parser.
+     *
+     * @see {@linkcode Create}
+     */
+    flow: Create$1;
+    /**
+     * Whether a comment was just added.
+     */
+    freshComment?: boolean | null | undefined;
+    /**
+     * Whether a comment region was just added.
+     */
+    freshRegion?: boolean | null | undefined;
+    /**
+     * At the `document` level, a record where each key is a line number, and each
+     * value is a boolean indicating if the line is lazy (as opposed to the line
+     * before it).
+     *
+     * For example:
+     *
+     * ```markdown
+     * > a
+     * b
+     * ```
+     *
+     * L1 is not lazy, but L2 is.
+     *
+     * @see {@linkcode Lazy}
+     */
+    lazy: Lazy$1;
+    /**
+     * Whether the previous line is blank.
+     */
+    previousBlankLine?: boolean | null | undefined;
+    /**
+     * Whether a comment summary is not allowed.
+     */
+    skipSummary?: boolean | undefined;
+    /**
+     * Create a source document parser.
+     *
+     * @see {@linkcode Create}
+     */
+    source: Create$1;
+    /**
+     * Create a markdown string parser.
+     *
+     * @see {@linkcode Create}
+     */
+    string: Create$1;
+    /**
+     * Create a markdown text parser.
+     *
+     * @see {@linkcode Create}
+     */
+    text: Create$1;
+    /**
+     * Create a type expression parser.
+     *
+     * @see {@linkcode Create}
+     */
+    type: Create$1;
+}
+
+/**
+ * @file ParseOptions
+ * @module docmark-util-types/ParseOptions
+ */
+
+/**
+ * Configuration object defining how to parse.
+ *
+ * This interface can be augmented to register custom fields.
+ *
+ * @example
+ *  declare module '@flex-development/docmark-util-types' {
+ *    interface ParseOptions {
+ *      from?: Point | null | undefined
+ *    }
+ *  }
+ */
+interface ParseOptions {
+    /**
+     * The list of syntax extensions to apply.
+     *
+     * @see {@linkcode AnyExtension}
+     */
+    extensions?: AnyExtension$1[] | null | undefined;
+    /**
+     * Finalize the tokenization context.
+     *
+     * @see {@linkcode FinalizeContext}
+     */
+    finalizeContext?: FinalizeContext$1 | null | undefined;
+    /**
+     * Record where each key is {@linkcode ContentType},
+     * and each value is an {@linkcode InitialConstruct} override.
+     */
+    initializers?: Partial<InitialConstructs$1> | null | undefined;
+}
+
+/**
+ * @file PartialConstruct
+ * @module docmark-util-types/PartialConstruct
+ */
+
+/**
+ * A partial construct.
+ *
+ * @see {@linkcode Construct}
+ *
+ * @extends {Construct}
+ */
+interface PartialConstruct extends Construct$1 {
+    /**
+     * Whether the construct represents a partial construct.
+     *
+     * @override
+     */
+    partial: true;
+}
+
+/**
+ * @file Place
+ * @module docmark-util-types/Place
+ */
+
+/**
+ * A location in the source content (`line`/`column`/`offset`)
+ * and chunk (`_index`, `_bufferIndex`).
+ *
+ * @see {@linkcode Point}
+ *
+ * @extends {Point}
+ */
+interface Place extends Point$1 {
+    /**
+     * The position in a string chunk (or `-1` when pointing to a numeric chunk).
+     */
+    _bufferIndex: number;
+    /**
+     * The position in a list of chunks.
+     */
+    _index: number;
+}
+
+/**
+ * @file Point
+ * @module docmark-util-types/Point
+ */
+
+/**
+ * A location in the source content.
+ */
+interface Point {
+    /**
+     * The column in the source content (`1`-indexed integer).
+     *
+     * @see {@linkcode Column}
+     */
+    column: Column$1;
+    /**
+     * The line in the source content (`1`-indexed integer).
+     *
+     * @see {@linkcode Line}
+     */
+    line: Line$1;
+    /**
+     * The position in the source content (`0`-indexed integer).
+     *
+     * @see {@linkcode Offset}
+     */
+    offset: Offset$1;
+}
+
+/**
+ * @file Position
+ * @module docmark-util-types/Position
+ */
+
+/**
+ * Range between two points in a source file.
+ */
+interface Position {
+    /**
+     * The place of the last character code in the range.
+     *
+     * @see {@linkcode Place}
+     */
+    end: Place$1;
+    /**
+     * The place of the first character code in the range.
+     *
+     * @see {@linkcode Place}
+     */
+    start: Place$1;
+}
+
+/**
+ * @file PreprocessOptions
+ * @module docmark-util-types/PreprocessOptions
+ */
+/**
+ * Options for configuring a preprocessor.
+ */
+interface PreprocessOptions {
+    /**
+     * The number of spaces a tab is equivalent to.
+     *
+     * @default constants.tabSize
+     */
+    tabSize?: number | null | undefined;
+}
+
+/**
+ * @file Preprocessor
+ * @module docmark-util-types/Preprocessor
+ */
+
+/**
+ * Turn a code, file, or value into chunks.
+ *
+ * @see {@linkcode Chunk}
+ * @see {@linkcode Code}
+ * @see {@linkcode Encoding}
+ * @see {@linkcode FileLike}
+ * @see {@linkcode Value}
+ */
+type Preprocess = {
+    /**
+     * Turn `value` into chunks.
+     *
+     * @see {@linkcode Code}
+     * @see {@linkcode Encoding}
+     * @see {@linkcode FileLike}
+     * @see {@linkcode Value}
+     *
+     * @this {void}
+     *
+     * @param {Code | FileLike | Value | undefined} value
+     *  The code, file, or value to preprocess
+     * @param {Encoding | null | undefined} encoding
+     *  The character encoding to use when `value`
+     *  or its contents is an {@linkcode Uint8Array}
+     * @param {true} end
+     *  Whether the end of stream has been reached
+     * @return {[...NonNullable<Chunk>[], null]}
+     *  The list of chunks
+     */
+    (this: void, value: Code$1 | FileLike$1 | Value$1 | undefined, encoding: Encoding$1 | null | undefined, end: true): [...NonNullable<Chunk$1>[], null];
+    /**
+     * Turn `value` into chunks.
+     *
+     * @see {@linkcode Code}
+     * @see {@linkcode Encoding}
+     * @see {@linkcode FileLike}
+     * @see {@linkcode Value}
+     *
+     * @this {void}
+     *
+     * @param {Code | FileLike | Value | undefined} value
+     *  The code, file, or value to preprocess
+     * @param {Encoding | null | undefined} encoding
+     *  The character encoding to use when `value`
+     *  or its contents is an {@linkcode Uint8Array}
+     * @param {false | null | undefined} [end]
+     *  Whether the end of stream has been reached
+     * @return {NonNullable<Chunk>[]}
+     *  The list of chunks
+     */
+    (this: void, value: Code$1 | FileLike$1 | Value$1 | undefined, encoding?: Encoding$1 | null | undefined, end?: false | null | undefined): NonNullable<Chunk$1>[];
+    /**
+     * Turn `value` into chunks.
+     *
+     * @see {@linkcode Code}
+     * @see {@linkcode Encoding}
+     * @see {@linkcode FileLike}
+     * @see {@linkcode Value}
+     *
+     * @this {void}
+     *
+     * @param {Code | FileLike | Value | undefined} value
+     *  The code, file, or value to preprocess
+     * @param {Encoding | null | undefined} [encoding]
+     *  The character encoding to use when `value`
+     *  or its contents is an {@linkcode Uint8Array}
+     * @param {boolean | null | undefined} [end]
+     *  Whether the end of stream has been reached
+     * @return {Chunk[]}
+     *  The list of chunks
+     */
+    (this: void, value: Code$1 | FileLike$1 | Value$1 | undefined, encoding?: Encoding$1 | null | undefined, end?: boolean | null | undefined): Chunk$1[];
+};
+
+/**
+ * @file Previous
+ * @module docmark-util-types/Previous
+ */
+
+/**
+ * Check if the previous character `code` can precede a construct.
+ *
+ * > 👉 **Note**: A construct can hook into many potential start characters.
+ * > Instead of setting up an attempt to parse that construct for most
+ * > characters, this is a speedy way to reduce that.
+ *
+ * @see {@linkcode Code}
+ * @see {@linkcode TokenizeContext}
+ *
+ * @this {TokenizeContext}
+ *
+ * @param {Code} code
+ *  The previous character code
+ * @return {boolean}
+ *  Whether `code` is allowed before the construct
+ */
+type Previous = (this: TokenizeContext$1, code: Code$1) => boolean;
+
+/**
+ * @file Resolver
+ * @module docmark-util-types/Resolver
+ */
+
+/**
+ * Handle events coming from `tokenize`.
+ *
+ * @see {@linkcode Construct.tokenize}
+ * @see {@linkcode Event}
+ * @see {@linkcode TokenizeContext}
+ *
+ * @this {void}
+ *
+ * @param {Event[]} events
+ *  The current list of events
+ * @param {TokenizeContext} context
+ *  The tokenize context
+ * @return {Event[]}
+ *  The list of changed events
+ */
+type Resolver = (this: void, events: Event$1[], context: TokenizeContext$1) => Event$1[];
+
+/**
+ * @file SerializeOptions
+ * @module docmark-util-types/SerializeOptions
+ */
+/**
+ * Options for serializing chunks.
+ */
+interface SerializeOptions {
+    /**
+     * A string representing a serialized stream break, a boolean indicating
+     * whether the stream break code should be serialized to a space (` `) rather
+     * than an empty string, or `null` to error on serialization attempt.
+     *
+     * @default null
+     */
+    breaks?: boolean | string | null | undefined;
+    /**
+     * Whether to expand tabs.
+     */
+    expandTabs?: boolean | null | undefined;
+}
+
+/**
+ * @file SliceSerialize
+ * @module docmark-util-types/SliceSerialize
+ */
+
+/**
+ * Get the text spanning `range`.
+ *
+ * @see {@linkcode Position}
+ * @see {@linkcode SerializeOptions}
+ *
+ * @this {void}
+ *
+ * @param {Position} range
+ *  The position in stream
+ * @param {SerializeOptions | boolean | null | undefined} [options]
+ *  Options for serializing or whether to expand tabs
+ * @return {string}
+ *  The serialized slice
+ */
+type SliceSerialize = (this: void, range: Position$1, options?: SerializeOptions$1 | boolean | null | undefined) => string;
+
+/**
+ * @file SliceStream
+ * @module docmark-util-types/SliceStream
+ */
+
+/**
+ * Get the chunks spanning `range`.
+ *
+ * @see {@linkcode Chunk}
+ * @see {@linkcode Position}
+ *
+ * @this {void}
+ *
+ * @param {Position} range
+ *  The position in stream
+ * @return {Chunk[]}
+ *  The chunks in stream spanning `range`
+ */
+type SliceStream = (this: void, range: Position$1) => Chunk$1[];
+
+/**
+ * @file State
+ * @module docmark-util-types/State
+ */
+
+/**
+ * The main unit in the state machine: a function that gets a character code and
+ * has certain effects.
+ *
+ * A state function returns another function: the next state-as-a-function to go
+ * to, or `undefined` when a final state is reached.
+ *
+ * @see {@linkcode Code}
+ *
+ * @this {void}
+ *
+ * @param {Code} code
+ *  The current character code
+ * @return {State | undefined}
+ *  The next state
+ */
+type State = (this: void, code: Code$1) => State | undefined;
+
+/**
+ * @file TokenFields
+ * @module docmark-util-types/TokenFields
+ */
+
+/**
+ * Registry of token fields.
+ *
+ * This interface can be augmented to register custom token fields.
+ *
+ * @example
+ *  declare module '@flex-development/docmark-util-types' {
+ *    interface TokenFields {
+ *      value?: string | null | undefined
+ *    }
+ *  }
+ */
+interface TokenFields {
+    /**
+     * Whether a link opening is balanced balanced:
+     * it’s not a link opening, but has a balanced closing.
+     */
+    _balanced?: boolean | undefined;
+    /**
+     * Whether an attention sequence is a closer.
+     *
+     * Depending on the character before sequences (`**`), the sequence can open,
+     * close, both, or none.
+     */
+    _close?: boolean | undefined;
+    /**
+     * Whether the token represents a `document`, `comment`,
+     * or `source`-level container.
+     */
+    _container?: boolean | undefined;
+    /**
+     * When {@linkcode contentType} is `string` or `text`, whether trailing
+     * whitespace is sensitive and allowed.\
+     * Normally, trailing spaces and tabs are dropped.
+     */
+    _contentTypeTextTrailing?: boolean | undefined;
+    /**
+     * Whether a link opening cannot be used because links are incorrect.
+     */
+    _inactive?: boolean | undefined;
+    /**
+     * When parsing GFM task lists, whether a token is in the first content of a
+     * list item construct.
+     */
+    _isInFirstContentOfListItem?: boolean | undefined;
+    /**
+     * The comment kind.
+     *
+     * @see {@linkcode CommentKind}
+     */
+    _kind?: CommentKind$1 | undefined;
+    /**
+     * When parsing lists, whether a list is loose or not.
+     */
+    _loose?: boolean | undefined;
+    /**
+     * Whether an attention sequence is an opener.
+     *
+     * Depending on the character before sequences (`**`), the sequence can open,
+     * close, both, or none.
+     */
+    _open?: boolean | undefined;
+    /**
+     * When {@linkcode contentType} is `comment`, whether the token represents a
+     * comment region.
+     */
+    _region?: boolean | undefined;
+    /**
+     * The connected tokenizer, used when dealing with linked tokens.
+     *
+     * @see {@linkcode TokenizeContext}
+     */
+    _tokenizer?: TokenizeContext$1 | undefined;
+    /**
+     * At the `comment` or `source` level, whether a `whitespace` token represents
+     * trailing whitespace.\
+     * Depending on the next logical comment line, trailing whitespaces are
+     * resolved into hard breaks or line suffixes.
+     */
+    _trailing?: boolean | undefined;
+    /**
+     * Declare the token as having content of a certain type.
+     *
+     * @see {@linkcode ContentType}
+     */
+    contentType?: ContentType$1 | undefined;
+    /**
+     * The next token in a list of linked tokens.
+     *
+     * @see {@linkcode Token}
+     */
+    next?: Token$1 | undefined;
+    /**
+     * The previous token in a list of linked tokens.
+     *
+     * @see {@linkcode Token}
+     */
+    previous?: Token$1 | undefined;
+}
+
+/**
+ * @file TokenTypeMap
+ * @module docmark-util-types/TokenTypeMap
+ */
+
+/**
+ * Registry of token types.
+ *
+ * The token type `null` is forbidden.
+ * The ecosystem uses the `null` key to support additional functionality.
+ *
+ * Libraries and other tools can augment this interface
+ * to register custom token types.
+ *
+ * @example
+ *  declare module '@flex-development/docmark-util-types' {
+ *    interface TokenTypeMap {
+ *      custom: 'custom'
+ *    }
+ *  }
+ *
+ * @see {@linkcode micromark.TokenTypeMap}
+ *
+ * @extends {micromark.TokenTypeMap}
+ */
+interface TokenTypeMap extends micromark.TokenTypeMap {
+    blockTag: 'blockTag';
+    chunkComment: 'chunkComment';
+    chunkMarkdown: 'chunkMarkdown';
+    chunkType: 'chunkType';
+    comment: 'comment';
+    commentCloser: 'commentCloser';
+    commentLineMarker: 'commentLineMarker';
+    commentLinePrefix: 'commentLinePrefix';
+    commentOpener: 'commentOpener';
+    commentPadding: 'commentPadding';
+    eoc: 'eoc';
+    identifier: 'identifier';
+    inlineTag: 'inlineTag';
+    inlineTagMarker: 'inlineTagMarker';
+    inlineTagText: 'inlineTagText';
+    namepath: 'namepath';
+    namepathConnector: 'namepathConnector';
+    namepathIdentifier: 'namepathIdentifier';
+    namepathMarker: 'namepathMarker';
+    /**
+     * Forbidden token type.
+     *
+     * The ecosystem uses the `null` key to support additional functionality.
+     */
+    null: never;
+    summary: 'summary';
+    summaryMarker: 'summaryMarker';
+    tagName: 'tagName';
+    tagNameIdentifier: 'tagNameIdentifier';
+    tagNameMarker: 'tagNameMarker';
+    typeExpression: 'typeExpression';
+    typeExpressionValue: 'typeExpressionValue';
+    typeMetadata: 'typeMetadata';
+    typeMetadataMarker: 'typeMetadataMarker';
+}
+
+/**
+ * @file TokenType
+ * @module docmark-util-types/TokenType
+ */
+
+/**
+ * Union of registered token types.
+ *
+ * The token type `null` is forbidden.
+ * The `docmark` ecosystem uses the `null` key
+ * to support additional functionality.
+ *
+ * To register custom token types, augment {@linkcode TokenTypeMap}.
+ * They will be added to this union automatically.
+ */
+type TokenType = TokenTypeMap$1[keyof TokenTypeMap$1];
+
+/**
+ * @file Token
+ * @module docmark-util-types/Token
+ */
+
+/**
+ * A span of one (`1`) or more chunks.
+ *
+ * Tokens are the core of what docmark produces: libraries and other tools can
+ * turn them into different things.
+ *
+ * Tokens are essentially names attached to a slice of chunks, such as
+ * `lineEndingBlank` for certain line endings, `codeFenced` for fenced code, or
+ * `summary` for an entire comment summary.
+ *
+ * Sometimes, more info is attached to tokens, such as `_open` and `_close`
+ * by `attention` (strong, emphasis) to signal whether the sequence can open
+ * or close an attention run.
+ *
+ * Linked tokens are used because outer constructs are parsed first.
+ * For example:
+ *
+ * ```markdown
+ * > *a
+ * b*.
+ * ```
+ *
+ * 1.  The block quote marker and the space after it is parsed first
+ * 2.  The rest of the line is a `chunkFlow` token
+ * 3.  The two spaces on the second line are a `linePrefix`
+ * 4.  The rest of the line is another `chunkFlow` token
+ *
+ * The two `chunkFlow` tokens are linked together.
+ * The chunks they span are then passed through the `flow` tokenizer.
+ *
+ * Sometimes tokens need more info!
+ * This interface can be augmented to register custom token fields.
+ *
+ * @example
+ *  declare module '@flex-development/docmark-util-types' {
+ *    interface Token {
+ *      value?: string | null | undefined
+ *    }
+ *  }
+ *
+ * @see {@linkcode Code}
+ * @see {@linkcode Position}
+ * @see {@linkcode TokenFields}
+ * @see {@linkcode TokenType}
+ *
+ * @template {TokenType} [T=TokenType]
+ *  The token type
+ *
+ * @extends {Position}
+ * @extends {TokenFields}
+ */
+interface Token<T extends TokenType$1 = TokenType$1> extends Position$1, TokenFields$1 {
+    /**
+     * The token type.
+     */
+    type: T;
+}
+
+/**
+ * @file TokenizeContext
+ * @module docmark-util-types/TokenizeContext
+ */
+
+/**
+ * Context object to assist with tokenizing syntax constructs.
+ *
+ * This interface can be augmented to register custom fields.
+ *
+ * @example
+ *  declare module '@flex-development/docmark-util-types' {
+ *    interface TokenizeContext {
+ *      field?: string | undefined
+ *    }
+ *  }
+ */
+interface TokenizeContext {
+    /**
+     * Whether trailing whitespace is sensitive and allowed when tokenizing `text`
+     * or `string` content.\
+     * Normally, trailing spaces and tabs are dropped.
+     */
+    _contentTypeTextTrailing?: boolean | undefined;
+    /**
+     * Whether the tokenizer is tokenizing the first content of a list item
+     * construct.
+     *
+     * > 👉 **Note**: Shared with `micromark-extension-gfm-task-list-item`.
+     */
+    _gfmTasklistFirstContentOfListItem?: boolean | undefined;
+    /**
+     * Whether a speculative check is being ran.
+     *
+     * @see {@linkcode Check}
+     */
+    check?: boolean | undefined;
+    /**
+     * The current character code.
+     *
+     * @see {@linkcode Code}
+     */
+    code: Code$1;
+    /**
+     * Whether concrete markdown was detected.
+     *
+     * Concrete constructs cannot be interrupted by other constructs.
+     */
+    concrete?: boolean | undefined;
+    /**
+     * Shared state set when parsing containers.
+     *
+     * Containers are parsed in separate phases:
+     * their first line (`tokenize`), continued lines (`continuation.tokenize`),
+     * and finally `exit`.
+     * This record can be used to store information between these hooks.
+     *
+     * @see {@linkcode ContainerState}
+     */
+    containerState?: ContainerState$1 | undefined;
+    /**
+     * The content type the tokenizer deals with.
+     *
+     * @see {@linkcode ContentType}
+     *
+     * @readonly
+     */
+    readonly contentType: ContentType$1;
+    /**
+     * The current construct.
+     *
+     * Constructs that are not `partial` are set here.
+     *
+     * @see {@linkcode Construct}
+     */
+    currentConstruct?: Construct$1 | undefined;
+    /**
+     * The debug logger.
+     *
+     * @see {@linkcode Debugger}
+     *
+     * @readonly
+     */
+    readonly debug: Debugger;
+    /**
+     * Define a skip.
+     *
+     * As containers (comment lines, block quotes, lists), "nibble" a prefix from
+     * the margins, where a line starts after that prefix can be defined here.
+     *
+     * When the tokenizer moves after consuming a line ending corresponding to
+     * the line number in the given point, the tokenizer shifts past the prefix
+     * based on the column in the shifted point.
+     *
+     * @see {@linkcode DefineSkip}
+     */
+    defineSkip: DefineSkip$1;
+    /**
+     * The current list of events.
+     *
+     * @see {@linkcode Event}
+     */
+    events: Event$1[];
+    /**
+     * Whether we're currently interrupting.
+     *
+     * For example:
+     *
+     * ```markdown
+     * a
+     * # b
+     * ```
+     *
+     * At `2:1`, we’re "interrupting".
+     */
+    interrupt?: boolean | undefined;
+    /**
+     * Whether to error on empty tokens.
+     *
+     * > 👉 **Note**: Error only thrown with `development` export condition.
+     *
+     * @see https://github.com/wooorm/devlop#okvalue-message
+     */
+    noEmptyTokens?: boolean | undefined;
+    /**
+     * Get the current place in the content.
+     *
+     * @see {@linkcode Now}
+     */
+    now: Now$1;
+    /**
+     * The relevant parsing context.
+     *
+     * Tokenizers deal with one content type.
+     * The parser is the object dealing with it all.
+     *
+     * @see {@linkcode ParseContext}
+     */
+    parser: ParseContext$1;
+    /**
+     * The previous character code.
+     *
+     * @see {@linkcode Code}
+     */
+    previous: Code$1;
+    /**
+     * Get the text that spans a token (or location).
+     *
+     * @see {@linkcode SliceSerialize}
+     */
+    sliceSerialize: SliceSerialize$1;
+    /**
+     * Get the chunks that span a token (or location).
+     *
+     * @see {@linkcode SliceStream}
+     */
+    sliceStream: SliceStream$1;
+    /**
+     * Write a slice of chunks.
+     *
+     * The eos code (`null`) can be used to signal the end of the stream.
+     *
+     * @see {@linkcode Write}
+     */
+    write: Write$1;
+}
+
+/**
+ * @file Tokenizer
+ * @module docmark-util-types/Tokenizer
+ */
+
+/**
+ * Set up a state machine to handle character codes streaming in.
+ *
+ * @see {@linkcode Effects}
+ * @see {@linkcode State}
+ * @see {@linkcode TokenizeContext}
+ *
+ * @this {TokenizeContext}
+ *
+ * @param {Effects} effects
+ *  The context object used to transition the state machine
+ * @param {State} ok
+ *  The successful tokenization state
+ * @param {State} nok
+ *  The failed tokenization state
+ * @return {State}
+ *  The initial state
+ */
+type Tokenizer = (this: TokenizeContext$1, effects: Effects$1, ok: State$1, nok: State$1) => State$1;
+
+/**
+ * @file Value
+ * @module docmark-util-types/Value
+ */
+/**
+ * The contents of a file.
+ *
+ * Can either be text, or a {@linkcode Uint8Array} like structure.
+ */
+type Value = Uint8Array | string;
+
+/**
+ * @file Write
+ * @module docmark-util-types/Write
+ */
+
+/**
+ * Write a slice of chunks.
+ *
+ * The eos code (`null`) can be used to signal end of stream.
+ *
+ * @see {@linkcode Chunk}
+ * @see {@linkcode Event}
+ *
+ * @this {void}
+ *
+ * @param {Chunk[]} slice
+ *  The list of chunks to write
+ * @return {Event[]}
+ *  The current list of events
+ */
+type Write = (this: void, slice: Chunk$1[]) => Event$1[];
+
+export type { AnyConstruct, AnyExtension, Attempt, AttentionMarkers, Attempt as Check, Chunk, Code, Column, CommentKind, CommentKindMap, Construct, ConstructPack, ConstructPosition, ConstructRecord, Constructs, Consume, ContainerState, ContentType, ContinuableConstruct, Create, DefineSkip, Disable, Effects, Encoding, EncodingMap, Enter, Event, EventType, Exit, Exiter, Extension, FileLike, FinalizeContext, FullNormalizedExtension, InitialConstruct, InitialConstructs, Initializer, InsideSpan, Attempt as Interrupt, Lazy, Line, NamedConstruct, NormalizedExtension, Now, Offset, ParseContext, ParseOptions, PartialConstruct, Place, Point, Position, PreprocessOptions, Preprocess as Preprocessor, Previous, Resolver, SerializeOptions, SliceSerialize, SliceStream, State, Token, TokenFields, TokenType, TokenTypeMap, TokenizeContext, Tokenizer, Value, Write };