@gmb/bitmark-parser-generator 5.37.0 → 5.38.0

package/dist/index.d.cts

@@ -705,6 +705,7 @@ type BitTagConfigKeyTypeType = EnumType<typeof BitTagConfigKeyType>;
  *
  */
 declare const ConfigKey: {
+    readonly group_accessibilityDecorative: "group_accessibilityDecorative";
     readonly group_standardAllBits: "group_standardAllBits";
     readonly group_standardItemLead: "group_standardItemLead";
     readonly group_standardItemLeadInstructionHint: "group_standardItemLeadInstructionHint";
@@ -762,6 +763,8 @@ declare const ConfigKey: {
     readonly group_resourceWebsiteLink: "group_resourceWebsiteLink";
     readonly group_previewImages: "group_previewImages";
     readonly group_previewVideos: "group_previewVideos";
+    readonly property_accessibilityGroupTag: "@accessibilityGroupTag";
+    readonly property_accessibilityTag: "@accessibilityTag";
     readonly property_action: "@action";
     readonly property_activityType: "@activityType";
     readonly property_additionalSolutions: "@additionalSolutions";
@@ -1754,6 +1757,8 @@ interface BitJson {
     slug: string;
     tag: string | string[];
     groupTag: GroupTagJson[];
+    accessibilityTag: string | string[];
+    accessibilityGroupTag: GroupTagJson[];
     reviewTag: string | string[];
     reviewerTag: string | string[];
     reductionTag: string | string[];
@@ -1954,7 +1959,7 @@ interface BitJson {
     level: number;
     toc: boolean;
     progress: boolean;
-    isCollapsible: boolean;
+    isCollapsible: boolean | null;
     anchor: string;
     reference: string | string[];
     referenceEnd: string;
@@ -2390,6 +2395,8 @@ interface Bit {
     slug?: Property;
     tag?: Property;
     groupTag?: GroupTagJson[];
+    accessibilityTag?: Property;
+    accessibilityGroupTag?: GroupTagJson[];
     reviewTag?: Property;
     reviewerTag?: Property;
     reductionTag?: Property;
@@ -2689,6 +2696,10 @@ declare const NodeType: {
     readonly unknown: "unknown";
     readonly __isDefaultExample: "__isDefaultExample";
     readonly __typeAlias: "__typeAlias";
+    readonly accessibilityGroupTag: "accessibilityGroupTag";
+    readonly accessibilityGroupTagValue: "accessibilityGroupTagValue";
+    readonly accessibilityTag: "accessibilityTag";
+    readonly accessibilityTagValue: "accessibilityTagValue";
     readonly action: "action";
     readonly actionValue: "actionValue";
     readonly activityType: "activityType";
@@ -3553,345 +3564,6 @@ declare class Ast {
     private isValue;
 }
 
-declare const BodyTextFormat: {
-    readonly plainText: "text";
-    readonly latex: "latex";
-    readonly json: "json";
-    readonly xml: "xml";
-    readonly bitmarkPlusPlus: "bitmark++";
-};
-type BodyTextFormatType = EnumType<typeof BodyTextFormat>;
-
-/**
- * The location of text.
- *
- * The location of the text affects how breakscaping is applied.
- */
-declare const TextLocation: {
-    readonly tag: "tag";
-    readonly body: "body";
-};
-type TextLocationType = EnumType<typeof TextLocation>;
-
-/**
- * Configuration options for breakscape and unbreakscape operations.
- *
- * @public
- */
-interface BreakscapeOptions$1 {
-    /**
-     * The text format to use for processing.
-     * @defaultValue TextFormat.bitmarkPlusPlus
-     */
-    format?: BodyTextFormatType;
-    /**
-     * The text location context for processing.
-     * @defaultValue TextLocation.body
-     */
-    location?: TextLocationType;
-    /**
-     * Whether to mutate the input array in-place when processing arrays.
-     * If false, a new array will be created.
-     * @defaultValue false
-     */
-    inPlaceArray?: boolean;
-    /**
-     * Legacy: if true, perform v2 breakscaping from JSON
-     */
-    v2?: boolean;
-}
-
-type BreakscapedString = string & {
-    readonly __isBreakscaped: unique symbol;
-};
-
-declare const BitmarkVersion: {
-    readonly v2: 2;
-    readonly v3: 3;
-};
-type BitmarkVersionType = EnumType<typeof BitmarkVersion>;
-
-interface Generator<T extends Node, R = void> {
-    generate: (ast: T, param1?: unknown, param2?: unknown) => Promise<R>;
-    generateSync: (ast: T, param1?: unknown, param2?: unknown) => R;
-}
-
-/**
- * Generator that walks bitmark AST.
- *
- * The implementation should implement functions with the correct naming, and these will be called when
- * walking the AST:
- *
- * enter_<nodeKey>() - called when entering a branch node
- * between_<nodeKey>() - called when between child nodes
- * exit_<nodeKey>() - called when exiting a branch node
- * leaf_<nodeKey>() - called when entering a leaf node
- */
-declare abstract class AstWalkerGenerator<AstType, R, Context = undefined> implements Generator<AstType, R>, AstWalkCallbacks<Context> {
-    protected ast: Ast;
-    protected debugGenerationInline: boolean;
-    protected printed: boolean;
-    abstract generate(ast: AstType, param1?: unknown, param2?: unknown): Promise<R>;
-    abstract generateSync(ast: AstType, param1?: unknown, param2?: unknown): R;
-    enter(node: NodeInfo, route: NodeInfo[], context: Context): boolean | void;
-    between(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[], context: Context): boolean | void;
-    exit(node: NodeInfo, route: NodeInfo[], context: Context): void;
-    leaf(node: NodeInfo, route: NodeInfo[], context: Context): void;
-    protected getParentNode(route: NodeInfo[], nodesBack?: number): NodeInfo | undefined;
-    protected getSiblingNodes(route: NodeInfo[]): {
-        left?: unknown;
-        right?: unknown;
-    };
-    protected isEmptyParagraph(node: TextNode): boolean;
-    protected abstract writeInlineDebug(key: string, state: {
-        open?: boolean;
-        close?: boolean;
-        single?: boolean;
-    }): void;
-}
-
-/**
- * Text generation options
- */
-interface TextOptions {
-    /**
-     * Callback for writing text
-     *
-     * If set, the callback will be called, rather than writing to the output string
-     */
-    writeCallback?: WriteCallback;
-    /**
-     * Callback for rendering body bits
-     */
-    bodyBitCallback?: BodyBitCallback;
-    /**
-     * [development only]
-     * Generate debug information in the output.
-     */
-    debugGenerationInline?: boolean;
-}
-type GenerateOptions = {
-    plainTextDividerAllowed?: boolean;
-    noBreakscaping?: boolean;
-    forceInline?: boolean;
-    noMarkup?: boolean;
-};
-declare const Stage: {
-    enter: string;
-    between: string;
-    exit: string;
-};
-type StageType = EnumType<typeof Stage>;
-type WriteCallback = (s: string) => void;
-type BodyBitCallback = (bodyBit: BodyBitJson, index: number, route: NodeInfo[]) => string;
-interface MediaAttributeOptions {
-    ignoreAttributes?: Set<string>;
-}
-/**
- * Generate text from a bitmark text AST
- */
-declare class TextGenerator extends AstWalkerGenerator<TextAst, BreakscapedString> {
-    protected ast: Ast;
-    private bitmarkVersion;
-    private options;
-    private internalTextGenerator;
-    private generateOptions;
-    private textFormat;
-    private textLocation;
-    private writerText;
-    private nodeIndex;
-    private currentIndent;
-    private prevIndent;
-    private indentationStringCache;
-    private inParagraph;
-    private inHeading;
-    private inCodeBlock;
-    private inBulletList;
-    private inInline;
-    private markDepth;
-    private textDepth;
-    private placeholderIndex;
-    private placeholders;
-    private rootParagraphNodeContentIndex;
-    private previousRootParagraphContextType;
-    private inPreText;
-    private thisNodeIsPreText;
-    private preTextIndexTemp;
-    private havePreText;
-    private preTextIndex;
-    /**
-     * Generate text from a bitmark text AST
-     *
-     * @param bitmarkVersion - bitmark version, use null to use latest version
-     * @param options - text generation options
-     */
-    constructor(bitmarkVersion?: BitmarkVersionType, options?: TextOptions);
-    /**
-     * Generate text from a bitmark text AST
-     *
-     * @param ast bitmark text AST
-     */
-    generate(ast: TextAst, textFormat: TextFormatType, textLocation: TextLocationType, options?: GenerateOptions): Promise<BreakscapedString>;
-    /**
-     * Generate text from a bitmark text AST synchronously
-     *
-     * @param ast bitmark text AST
-     */
-    generateSync(ast: TextAst, textFormat: TextFormatType, textLocation: TextLocationType, options?: GenerateOptions): BreakscapedString;
-    getPlaceholders(): BodyBitsJson;
-    private resetState;
-    private walkAndWrite;
-    protected enter_textAstValue(node: NodeInfo, route: NodeInfo[]): void | false;
-    protected between_textAstValue(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void | false;
-    protected exit_textAstValue(node: NodeInfo, route: NodeInfo[]): void | false;
-    protected enter_contentValue(node: NodeInfo, route: NodeInfo[]): void | false;
-    protected between_contentValue(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void;
-    protected exit_contentValue(node: NodeInfo, route: NodeInfo[]): void | false;
-    protected enter_contentValueValue(node: NodeInfo, route: NodeInfo[]): void | false;
-    protected between_contentValueValue(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void;
-    protected exit_contentValueValue(node: NodeInfo, route: NodeInfo[]): void | false;
-    protected enter_marks(_node: NodeInfo, _route: NodeInfo[]): void | false;
-    protected exit_marks(_node: NodeInfo, _route: NodeInfo[]): void | false;
-    protected handleEnterNode(node: TextNode, route: NodeInfo[]): void | false;
-    protected handleBetweenNode(node: TextNode, _left: NodeInfo, _right: NodeInfo, _route: NodeInfo[]): void;
-    protected handleExitNode(node: TextNode, _route: NodeInfo[]): void | false;
-    protected handleIndent(node: TextNode): void;
-    protected handleDedent(node: TextNode): void;
-    protected handleEnterContentValueNode(_node: NodeInfo, route: NodeInfo[]): void | false;
-    protected handleBetweenContentValueNode(_node: NodeInfo, left: NodeInfo, _right: NodeInfo, route: NodeInfo[]): void;
-    protected handleExitContentValueNode(_node: NodeInfo, route: NodeInfo[]): void | false;
-    private updatePreTextState;
-    protected handleEnterNodePreTextCheck(node: TextNode, route: NodeInfo[]): void;
-    /**
-     * Check if a text node has a link mark, and if so, return the href
-     *
-     * @param node the node to check for a link mark
-     * @returns the href, or false if no link mark
-     */
-    protected getLinkHref(node: TextNode): string | false;
-    /**
-     * Get the current indentation string
-     * @returns
-     */
-    protected getIndentationString(): string;
-    protected writeBodyBit(node: TextNode, route: NodeInfo[]): void;
-    protected writeText(node: TextNode): void;
-    /**
-     * Check if a node is a link node and if so and the node has only the link mark, and the link without the
-     * protocol is the same as the text, return true. Otherwise return false.
-     *
-     * @param node
-     * @returns true if a simple link, otherwise false
-     */
-    protected isSimpleLink(node: TextNode): boolean;
-    /**
-     * Get the link text if the node is a link, otherwise return false
-     *
-     * @param node
-     * @returns
-     */
-    protected getLinkText(node: TextNode): string | false;
-    /**
-     * If the existing written text ends with a half-mark, and the new text starts with the same half-mark, insert a
-     * breakscape ^ between them to break the sequence.
-     *
-     * Only applies to bitmark version > 2
-     *
-     * @param s
-     */
-    protected getInterTextBreakscape(s: string): string;
-    protected validateGenerateOptions(ast: TextNode[]): void;
-    /**
-     * Write the marks for the node.
-     *
-     * All marks need to be considered at once, because if there are multiple marks, they need to be written in
-     * a combined manner.
-     *
-     * e.g. if there are bold and italic marks, they need to be written as
-     *
-     * ==the text==|bold|italic|
-     * rather than
-     * **__the text__**
-     * or
-     * **__the text**__
-     *
-     * @param node the text node
-     * @param start true if starting (before) the text, false if ending (after) the text
-     */
-    protected writeMarks(node: TextNode, stage: StageType): void | false;
-    protected writeParagraph(node: TextNode, route: NodeInfo[]): void;
-    protected writeHardBreak(_node: TextNode): void;
-    protected writeHeading(node: HeadingTextNode): void;
-    protected writeSection(node: SectionTextNode): void;
-    protected writeBullet(node: TextNode, route: NodeInfo[]): void;
-    protected writeImage(node: ImageTextNode | ImageInlineTextNode): void;
-    protected writeCodeBlock(node: CodeBlockTextNode): void;
-    protected writeLatex(node: LatexTextNode): void;
-    protected writeMarkTextWrapper(s: string): void;
-    protected writeInlineMark(mark: TextMark): void;
-    /**
-     * Resolve the marks of a text node into the marks that will actually be written.
-     *
-     * - Merges a legacy standalone 'duration' mark into its sibling 'timer' mark.
-     * - Drops marks the current grammar cannot express (standalone 'duration', 'timer'
-     *   without a duration).
-     * - Moves a 'textStyle'/'color' mark before a preceding bare 'highlight'/'userHighlight'
-     *   mark when its color is a valid highlight color; written in the original order the
-     *   output would re-parse as a highlight-with-color compound mark and change meaning.
-     */
-    protected getWritableMarks(nodeMarks: TextMark[]): TextMark[];
-    /**
-     * True if the mark is written using its standard form (e.g. **bold**, !!highlight!!)
-     * when it is the only mark. A highlight mark with a color attribute is excluded - it
-     * can only be expressed using the inline chain form (==text==|highlight|color:x|).
-     */
-    protected isStandardMark(mark: TextMark): boolean;
-    /**
-     * True if the mark is written using the inline chain form (==text==|mark|).
-     */
-    protected isInlineMark(mark: TextMark): boolean;
-    protected writeCommentMark(mark: CommentMark): void;
-    protected writeLinkMark(mark: LinkMark): void;
-    protected writeRefMark(mark: RefMark): void;
-    protected writeXRefMark(mark: XRefMark): void;
-    protected writeExtRefMark(mark: ExtRefMark): void;
-    protected writeFootnoteMark(mark: FootnoteMark): void;
-    protected writeFootnoteStarMark(mark: FootnoteMark): void;
-    protected writeSymbolMark(mark: SymbolMark): void;
-    protected writeInlineMarkStartEnd(): void;
-    protected writePlainTextDivider(): void;
-    protected writeString(s?: string): void;
-    protected writeNL(): void;
-    protected writeInlineDebug(key: string, state: {
-        open?: boolean;
-        close?: boolean;
-        single?: boolean;
-    }): void;
-    protected getMediaAttrs(mediaType: string, attrs: MediaAttributes, options?: MediaAttributeOptions): string | undefined;
-    protected breakscape(s: string, options: BreakscapeOptions$1): string;
-    protected getBitType(route: NodeInfo[]): BitTypeType | undefined;
-    /**
-     * Writes a string value to the output.
-     * @param value - The string value to be written.
-     */
-    write(value: string): this;
-    /**
-     * Writes a new line to the output. The line is indented automatically. The line is ended with the endOfLineString.
-     * @param value - The line to write. When omitted, only the endOfLineString is written.
-     */
-    writeLine(value?: string): this;
-    /**
-     * Writes a collection of lines to the output. Each line is indented automatically and ended with the endOfLineString.
-     * @param values - The lines to write.
-     * @param delimiter - An optional delimiter to be written at the end of each line, except for the last one.
-     */
-    writeLines(values: string[], delimiter?: string): this;
-    /**
-     * Writes a single whitespace character to the output.
-     */
-    writeWhiteSpace(): this;
-}
-
 declare const ExampleType: {
     readonly none: "none";
     readonly string: "string";
@@ -4171,41 +3843,380 @@ interface ToStringOptions {
     includeChains?: boolean;
     includeConfigs?: boolean;
 }
-declare class BitConfig {
-    readonly since: string;
-    readonly bitType: BitTypeType;
-    readonly inheritedBitTypes: BitTypeType[];
-    readonly inheritedBitTypesSet: Set<BitTypeType>;
-    readonly textFormatDefault: TextFormatType;
-    readonly tags: TagsConfig;
-    readonly cardSet?: CardSetConfig;
-    readonly quizBit?: boolean;
-    readonly deprecated?: string;
-    readonly bodyAllowed?: boolean;
-    readonly bodyRequired?: boolean;
-    readonly footerAllowed?: boolean;
-    readonly footerRequired?: boolean;
-    readonly resourceAttachmentAllowed?: boolean;
-    readonly rootExampleType?: ExampleTypeType;
-    readonly comboResourceConfigKey?: ConfigKeyType;
-    constructor(config: {
-        since: string;
-        bitType: BitTypeType;
-        inheritedBitTypes: BitTypeType[];
-        textFormatDefault: TextFormatType;
-        tags: TagsConfig;
-        cardSet: CardSetConfig | undefined;
-        quizBit: boolean | undefined;
-        deprecated: string | undefined;
-        bodyAllowed: boolean | undefined;
-        bodyRequired: boolean | undefined;
-        footerAllowed: boolean | undefined;
-        footerRequired: boolean | undefined;
-        resourceAttachmentAllowed: boolean | undefined;
-        rootExampleType: ExampleTypeType | undefined;
-        comboResourceConfigKey: ConfigKeyType | undefined;
-    });
-    toString(options?: ToStringOptions): string;
+declare class BitConfig {
+    readonly since: string;
+    readonly bitType: BitTypeType;
+    readonly inheritedBitTypes: BitTypeType[];
+    readonly inheritedBitTypesSet: Set<BitTypeType>;
+    readonly textFormatDefault: TextFormatType;
+    readonly tags: TagsConfig;
+    readonly cardSet?: CardSetConfig;
+    readonly quizBit?: boolean;
+    readonly deprecated?: string;
+    readonly bodyAllowed?: boolean;
+    readonly bodyRequired?: boolean;
+    readonly footerAllowed?: boolean;
+    readonly footerRequired?: boolean;
+    readonly resourceAttachmentAllowed?: boolean;
+    readonly rootExampleType?: ExampleTypeType;
+    readonly comboResourceConfigKey?: ConfigKeyType;
+    constructor(config: {
+        since: string;
+        bitType: BitTypeType;
+        inheritedBitTypes: BitTypeType[];
+        textFormatDefault: TextFormatType;
+        tags: TagsConfig;
+        cardSet: CardSetConfig | undefined;
+        quizBit: boolean | undefined;
+        deprecated: string | undefined;
+        bodyAllowed: boolean | undefined;
+        bodyRequired: boolean | undefined;
+        footerAllowed: boolean | undefined;
+        footerRequired: boolean | undefined;
+        resourceAttachmentAllowed: boolean | undefined;
+        rootExampleType: ExampleTypeType | undefined;
+        comboResourceConfigKey: ConfigKeyType | undefined;
+    });
+    toString(options?: ToStringOptions): string;
+}
+
+declare const BodyTextFormat: {
+    readonly plainText: "text";
+    readonly latex: "latex";
+    readonly json: "json";
+    readonly xml: "xml";
+    readonly bitmarkPlusPlus: "bitmark++";
+};
+type BodyTextFormatType = EnumType<typeof BodyTextFormat>;
+
+/**
+ * The location of text.
+ *
+ * The location of the text affects how breakscaping is applied.
+ */
+declare const TextLocation: {
+    readonly tag: "tag";
+    readonly body: "body";
+};
+type TextLocationType = EnumType<typeof TextLocation>;
+
+/**
+ * Configuration options for breakscape and unbreakscape operations.
+ *
+ * @public
+ */
+interface BreakscapeOptions$1 {
+    /**
+     * The text format to use for processing.
+     * @defaultValue TextFormat.bitmarkPlusPlus
+     */
+    format?: BodyTextFormatType;
+    /**
+     * The text location context for processing.
+     * @defaultValue TextLocation.body
+     */
+    location?: TextLocationType;
+    /**
+     * Whether to mutate the input array in-place when processing arrays.
+     * If false, a new array will be created.
+     * @defaultValue false
+     */
+    inPlaceArray?: boolean;
+    /**
+     * Legacy: if true, perform v2 breakscaping from JSON
+     */
+    v2?: boolean;
+}
+
+type BreakscapedString = string & {
+    readonly __isBreakscaped: unique symbol;
+};
+
+declare const BitmarkVersion: {
+    readonly v2: 2;
+    readonly v3: 3;
+};
+type BitmarkVersionType = EnumType<typeof BitmarkVersion>;
+
+interface Generator<T extends Node, R = void> {
+    generate: (ast: T, param1?: unknown, param2?: unknown) => Promise<R>;
+    generateSync: (ast: T, param1?: unknown, param2?: unknown) => R;
+}
+
+/**
+ * Generator that walks bitmark AST.
+ *
+ * The implementation should implement functions with the correct naming, and these will be called when
+ * walking the AST:
+ *
+ * enter_<nodeKey>() - called when entering a branch node
+ * between_<nodeKey>() - called when between child nodes
+ * exit_<nodeKey>() - called when exiting a branch node
+ * leaf_<nodeKey>() - called when entering a leaf node
+ */
+declare abstract class AstWalkerGenerator<AstType, R, Context = undefined> implements Generator<AstType, R>, AstWalkCallbacks<Context> {
+    protected ast: Ast;
+    protected debugGenerationInline: boolean;
+    protected printed: boolean;
+    abstract generate(ast: AstType, param1?: unknown, param2?: unknown): Promise<R>;
+    abstract generateSync(ast: AstType, param1?: unknown, param2?: unknown): R;
+    enter(node: NodeInfo, route: NodeInfo[], context: Context): boolean | void;
+    between(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[], context: Context): boolean | void;
+    exit(node: NodeInfo, route: NodeInfo[], context: Context): void;
+    leaf(node: NodeInfo, route: NodeInfo[], context: Context): void;
+    protected getParentNode(route: NodeInfo[], nodesBack?: number): NodeInfo | undefined;
+    protected getSiblingNodes(route: NodeInfo[]): {
+        left?: unknown;
+        right?: unknown;
+    };
+    protected isEmptyParagraph(node: TextNode): boolean;
+    protected abstract writeInlineDebug(key: string, state: {
+        open?: boolean;
+        close?: boolean;
+        single?: boolean;
+    }): void;
+}
+
+/**
+ * Text generation options
+ */
+interface TextOptions {
+    /**
+     * Callback for writing text
+     *
+     * If set, the callback will be called, rather than writing to the output string
+     */
+    writeCallback?: WriteCallback;
+    /**
+     * Callback for rendering body bits
+     */
+    bodyBitCallback?: BodyBitCallback;
+    /**
+     * [development only]
+     * Generate debug information in the output.
+     */
+    debugGenerationInline?: boolean;
+}
+type GenerateOptions = {
+    plainTextDividerAllowed?: boolean;
+    noBreakscaping?: boolean;
+    forceInline?: boolean;
+    noMarkup?: boolean;
+};
+declare const Stage: {
+    enter: string;
+    between: string;
+    exit: string;
+};
+type StageType = EnumType<typeof Stage>;
+type WriteCallback = (s: string) => void;
+type BodyBitCallback = (bodyBit: BodyBitJson, index: number, route: NodeInfo[]) => string;
+interface MediaAttributeOptions {
+    ignoreAttributes?: Set<string>;
+}
+/**
+ * Generate text from a bitmark text AST
+ */
+declare class TextGenerator extends AstWalkerGenerator<TextAst, BreakscapedString> {
+    protected ast: Ast;
+    private bitmarkVersion;
+    private options;
+    private internalTextGenerator;
+    private generateOptions;
+    private textFormat;
+    private textLocation;
+    private writerText;
+    private nodeIndex;
+    private currentIndent;
+    private prevIndent;
+    private indentationStringCache;
+    private inParagraph;
+    private inHeading;
+    private inCodeBlock;
+    private inBulletList;
+    private inInline;
+    private markDepth;
+    private textDepth;
+    private placeholderIndex;
+    private placeholders;
+    private rootParagraphNodeContentIndex;
+    private previousRootParagraphContextType;
+    private inPreText;
+    private thisNodeIsPreText;
+    private preTextIndexTemp;
+    private havePreText;
+    private preTextIndex;
+    /**
+     * Generate text from a bitmark text AST
+     *
+     * @param bitmarkVersion - bitmark version, use null to use latest version
+     * @param options - text generation options
+     */
+    constructor(bitmarkVersion?: BitmarkVersionType, options?: TextOptions);
+    /**
+     * Generate text from a bitmark text AST
+     *
+     * @param ast bitmark text AST
+     */
+    generate(ast: TextAst, textFormat: TextFormatType, textLocation: TextLocationType, options?: GenerateOptions): Promise<BreakscapedString>;
+    /**
+     * Generate text from a bitmark text AST synchronously
+     *
+     * @param ast bitmark text AST
+     */
+    generateSync(ast: TextAst, textFormat: TextFormatType, textLocation: TextLocationType, options?: GenerateOptions): BreakscapedString;
+    getPlaceholders(): BodyBitsJson;
+    private resetState;
+    private walkAndWrite;
+    protected enter_textAstValue(node: NodeInfo, route: NodeInfo[]): void | false;
+    protected between_textAstValue(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void | false;
+    protected exit_textAstValue(node: NodeInfo, route: NodeInfo[]): void | false;
+    protected enter_contentValue(node: NodeInfo, route: NodeInfo[]): void | false;
+    protected between_contentValue(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void;
+    protected exit_contentValue(node: NodeInfo, route: NodeInfo[]): void | false;
+    protected enter_contentValueValue(node: NodeInfo, route: NodeInfo[]): void | false;
+    protected between_contentValueValue(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void;
+    protected exit_contentValueValue(node: NodeInfo, route: NodeInfo[]): void | false;
+    protected enter_marks(_node: NodeInfo, _route: NodeInfo[]): void | false;
+    protected exit_marks(_node: NodeInfo, _route: NodeInfo[]): void | false;
+    protected handleEnterNode(node: TextNode, route: NodeInfo[]): void | false;
+    protected handleBetweenNode(node: TextNode, _left: NodeInfo, _right: NodeInfo, _route: NodeInfo[]): void;
+    protected handleExitNode(node: TextNode, _route: NodeInfo[]): void | false;
+    protected handleIndent(node: TextNode): void;
+    protected handleDedent(node: TextNode): void;
+    protected handleEnterContentValueNode(_node: NodeInfo, route: NodeInfo[]): void | false;
+    protected handleBetweenContentValueNode(_node: NodeInfo, left: NodeInfo, _right: NodeInfo, route: NodeInfo[]): void;
+    protected handleExitContentValueNode(_node: NodeInfo, route: NodeInfo[]): void | false;
+    private updatePreTextState;
+    protected handleEnterNodePreTextCheck(node: TextNode, route: NodeInfo[]): void;
+    /**
+     * Check if a text node has a link mark, and if so, return the href
+     *
+     * @param node the node to check for a link mark
+     * @returns the href, or false if no link mark
+     */
+    protected getLinkHref(node: TextNode): string | false;
+    /**
+     * Get the current indentation string
+     * @returns
+     */
+    protected getIndentationString(): string;
+    protected writeBodyBit(node: TextNode, route: NodeInfo[]): void;
+    protected writeText(node: TextNode): void;
+    /**
+     * Check if a node is a link node and if so and the node has only the link mark, and the link without the
+     * protocol is the same as the text, return true. Otherwise return false.
+     *
+     * @param node
+     * @returns true if a simple link, otherwise false
+     */
+    protected isSimpleLink(node: TextNode): boolean;
+    /**
+     * Get the link text if the node is a link, otherwise return false
+     *
+     * @param node
+     * @returns
+     */
+    protected getLinkText(node: TextNode): string | false;
+    /**
+     * If the existing written text ends with a half-mark, and the new text starts with the same half-mark, insert a
+     * breakscape ^ between them to break the sequence.
+     *
+     * Only applies to bitmark version > 2
+     *
+     * @param s
+     */
+    protected getInterTextBreakscape(s: string): string;
+    protected validateGenerateOptions(ast: TextNode[]): void;
+    /**
+     * Write the marks for the node.
+     *
+     * All marks need to be considered at once, because if there are multiple marks, they need to be written in
+     * a combined manner.
+     *
+     * e.g. if there are bold and italic marks, they need to be written as
+     *
+     * ==the text==|bold|italic|
+     * rather than
+     * **__the text__**
+     * or
+     * **__the text**__
+     *
+     * @param node the text node
+     * @param start true if starting (before) the text, false if ending (after) the text
+     */
+    protected writeMarks(node: TextNode, stage: StageType): void | false;
+    protected writeParagraph(node: TextNode, route: NodeInfo[]): void;
+    protected writeHardBreak(_node: TextNode): void;
+    protected writeHeading(node: HeadingTextNode): void;
+    protected writeSection(node: SectionTextNode): void;
+    protected writeBullet(node: TextNode, route: NodeInfo[]): void;
+    protected writeImage(node: ImageTextNode | ImageInlineTextNode): void;
+    protected writeCodeBlock(node: CodeBlockTextNode): void;
+    protected writeLatex(node: LatexTextNode): void;
+    protected writeMarkTextWrapper(s: string): void;
+    protected writeInlineMark(mark: TextMark): void;
+    /**
+     * Resolve the marks of a text node into the marks that will actually be written.
+     *
+     * - Merges a legacy standalone 'duration' mark into its sibling 'timer' mark.
+     * - Drops marks the current grammar cannot express (standalone 'duration', 'timer'
+     *   without a duration).
+     * - Moves a 'textStyle'/'color' mark before a preceding bare 'highlight'/'userHighlight'
+     *   mark when its color is a valid highlight color; written in the original order the
+     *   output would re-parse as a highlight-with-color compound mark and change meaning.
+     */
+    protected getWritableMarks(nodeMarks: TextMark[]): TextMark[];
+    /**
+     * True if the mark is written using its standard form (e.g. **bold**, !!highlight!!)
+     * when it is the only mark. A highlight mark with a color attribute is excluded - it
+     * can only be expressed using the inline chain form (==text==|highlight|color:x|).
+     */
+    protected isStandardMark(mark: TextMark): boolean;
+    /**
+     * True if the mark is written using the inline chain form (==text==|mark|).
+     */
+    protected isInlineMark(mark: TextMark): boolean;
+    protected writeCommentMark(mark: CommentMark): void;
+    protected writeLinkMark(mark: LinkMark): void;
+    protected writeRefMark(mark: RefMark): void;
+    protected writeXRefMark(mark: XRefMark): void;
+    protected writeExtRefMark(mark: ExtRefMark): void;
+    protected writeFootnoteMark(mark: FootnoteMark): void;
+    protected writeFootnoteStarMark(mark: FootnoteMark): void;
+    protected writeSymbolMark(mark: SymbolMark): void;
+    protected writeInlineMarkStartEnd(): void;
+    protected writePlainTextDivider(): void;
+    protected writeString(s?: string): void;
+    protected writeNL(): void;
+    protected writeInlineDebug(key: string, state: {
+        open?: boolean;
+        close?: boolean;
+        single?: boolean;
+    }): void;
+    protected getMediaAttrs(mediaType: string, attrs: MediaAttributes, options?: MediaAttributeOptions): string | undefined;
+    protected breakscape(s: string, options: BreakscapeOptions$1): string;
+    protected getBitType(route: NodeInfo[]): BitTypeType | undefined;
+    /**
+     * Writes a string value to the output.
+     * @param value - The string value to be written.
+     */
+    write(value: string): this;
+    /**
+     * Writes a new line to the output. The line is indented automatically. The line is ended with the endOfLineString.
+     * @param value - The line to write. When omitted, only the endOfLineString is written.
+     */
+    writeLine(value?: string): this;
+    /**
+     * Writes a collection of lines to the output. Each line is indented automatically and ended with the endOfLineString.
+     * @param values - The lines to write.
+     * @param delimiter - An optional delimiter to be written at the end of each line, except for the last one.
+     */
+    writeLines(values: string[], delimiter?: string): this;
+    /**
+     * Writes a single whitespace character to the output.
+     */
+    writeWhiteSpace(): this;
 }
 
 interface BitmarkTextParserOptions {
@@ -4408,6 +4419,8 @@ declare class Builder extends BaseBuilder {
         slug?: string;
         tag?: string | string[];
         groupTag?: Partial<GroupTagJson> | Partial<GroupTagJson>[];
+        accessibilityTag?: string | string[];
+        accessibilityGroupTag?: Partial<GroupTagJson> | Partial<GroupTagJson>[];
         reviewTag?: string | string[];
         reviewerTag?: string | string[];
         reductionTag?: string | string[];
@@ -4612,7 +4625,7 @@ declare class Builder extends BaseBuilder {
         level?: number | string;
         toc?: boolean;
         progress?: boolean;
-        isCollapsible?: boolean;
+        isCollapsible?: boolean | null;
         anchor?: string;
         reference?: string;
         referenceEnd?: string;
@@ -4675,6 +4688,19 @@ declare class Builder extends BaseBuilder {
      * @returns
      */
     protected buildBook(_context: BuildContext, data: Partial<BookJson> | undefined): BookJson | undefined;
+    /**
+     * Resolve the accessibilityGroupTag data, materialising the bit type's default when absent.
+     *
+     * PLAN-019: `group_accessibilityDecorative` re-declares `@accessibilityGroupTag` with a
+     * `defaultValue`, and its chained `@accessibilityTag` likewise. When the bit carries no
+     * authored value, synthesize the default group so it reaches both generators. An authored
+     * value always wins.
+     *
+     * @param bitConfig - the resolved config for the bit
+     * @param data - authored data for the node, if any
+     * @returns
+     */
+    protected resolveAccessibilityGroupTag(bitConfig: BitConfig, data: Partial<GroupTagJson> | Partial<GroupTagJson>[] | undefined): Partial<GroupTagJson> | Partial<GroupTagJson>[] | undefined;
     /**
      * Build groupTag[] node
      *
@@ -5762,6 +5788,7 @@ declare class BitmarkGenerator extends AstWalkerGenerator<BitmarkAst, void> {
     protected exit_bitsValue(_node: NodeInfo, _route: NodeInfo[]): void;
     protected enter_internalComment(node: NodeInfo, route: NodeInfo[]): boolean;
     protected enter_groupTag(node: NodeInfo, route: NodeInfo[]): boolean;
+    protected enter_accessibilityGroupTag(node: NodeInfo, route: NodeInfo[]): boolean;
     protected leaf_labelTrue(node: NodeInfo, route: NodeInfo[]): boolean;
     protected leaf_labelFalse(_node: NodeInfo, _route: NodeInfo[]): boolean;
     protected enter_imageSource(node: NodeInfo, route: NodeInfo[]): boolean;
@@ -6197,10 +6224,14 @@ declare class JsonGenerator extends AstWalkerGenerator<BitmarkAst, void> {
     protected enter_sourceBB(node: NodeInfo, route: NodeInfo[]): boolean;
     protected enter_productId(node: NodeInfo, route: NodeInfo[]): boolean;
     /**
-     * PLAN-016: `isCollapsible` is emitted only when true. `false` is the implied
-     * default for every bit, so it is never written to the JSON — an absent key
-     * means the bit's configured default (`true` for the deprecated
-     * `*-collapsible` bit types, `false` everywhere else).
+     * `isCollapsible` is emitted only when explicitly set on the bit — an explicit
+     * `true`/`false` in the source is emitted as-is, and an absent tag yields no
+     * JSON key (the tag is nullable in the config: no default, unset when absent).
+     *
+     * Two exceptions always carry a value: chapter bits default to `false`
+     * (`defaultValue: 'false'` in the bit config, applied in `cleanBitJson()`),
+     * and the deprecated `*-collapsible` bit types default to `true` (materialised
+     * into the AST by the Builder).
      *
      * Defining these handlers suppresses the generic property handlers that
      * `generatePropertyHandlers()` would otherwise install for this tag.