@gmb/bitmark-parser-generator 3.34.0 → 3.36.0

package/dist/esm/generator/json/JsonGenerator.js

@@ -1,1578 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import structuredClone from '@ungap/structured-clone';
-import { Ast } from '../../ast/Ast';
-import { Breakscape } from '../../breakscaping/Breakscape';
-import { Config } from '../../config/Config';
-import { NodeType } from '../../model/ast/NodeType';
-import { BitType } from '../../model/enum/BitType';
-import { BitmarkVersion, DEFAULT_BITMARK_VERSION } from '../../model/enum/BitmarkVersion';
-import { BodyBitType } from '../../model/enum/BodyBitType';
-import { ExampleType } from '../../model/enum/ExampleType';
-import { ResourceTag } from '../../model/enum/ResourceTag';
-import { TextFormat } from '../../model/enum/TextFormat';
-import { TextLocation } from '../../model/enum/TextLocation';
-import { TextNodeType } from '../../model/enum/TextNodeType';
-import { TextParser } from '../../parser/text/TextParser';
-import { BooleanUtils } from '../../utils/BooleanUtils';
-import { NumberUtils } from '../../utils/NumberUtils';
-import { AstWalkerGenerator } from '../AstWalkerGenerator';
-import { TextGenerator } from '../text/TextGenerator';
-const MOVE_BODY_RECURSION_LIMIT = 5000;
-const DEFAULT_OPTIONS = {
-// debugGenerationInline: true,
-};
-/**
- * Generate bitmark JSON from a bitmark AST
- *
- *
- */
-class JsonGenerator extends AstWalkerGenerator {
-    /**
-     * Generate bitmark JSON from a bitmark AST
-     *
-     * @param writer - destination for the output
-     * @param options - JSON generation options
-     */
-    constructor(writer, options) {
-        var _a, _b;
-        super();
-        this.ast = new Ast();
-        this.textParser = new TextParser();
-        // State
-        this.json = [];
-        this.bitWrapperJson = {};
-        this.bitJson = {};
-        this.textDefault = Breakscape.EMPTY_STRING;
-        this.bodyDefault = Breakscape.EMPTY_STRING;
-        this.bodyJson = this.bodyDefault;
-        this.placeholderIndex = 0;
-        // Bind callbacks
-        this.enter = this.enter.bind(this);
-        this.between = this.between.bind(this);
-        this.exit = this.exit.bind(this);
-        this.leaf = this.leaf.bind(this);
-        this.bodyBitCallback = this.bodyBitCallback.bind(this);
-        this.bitmarkVersion = (_a = BitmarkVersion.fromValue(options === null || options === void 0 ? void 0 : options.bitmarkVersion)) !== null && _a !== void 0 ? _a : DEFAULT_BITMARK_VERSION;
-        this.textParserVersion = this.textParser.version();
-        this.options = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options === null || options === void 0 ? void 0 : options.jsonOptions);
-        this.debugGenerationInline = (_b = this.options.debugGenerationInline) !== null && _b !== void 0 ? _b : false;
-        this.jsonPrettifySpace = this.options.prettify === true ? 2 : this.options.prettify || undefined;
-        // Set defaults according to bitmark version
-        if (this.bitmarkVersion === BitmarkVersion.v2) {
-            if (this.options.textAsPlainText === undefined) {
-                this.options.textAsPlainText = true;
-            }
-        }
-        else {
-            if (this.options.textAsPlainText === undefined) {
-                this.options.textAsPlainText = false;
-            }
-        }
-        // Create the text generator for generating v2 texts
-        this.textGenerator = new TextGenerator(BitmarkVersion.v2, {
-            // writeCallback: this.write,
-            bodyBitCallback: this.bodyBitCallback,
-            debugGenerationInline: this.debugGenerationInline,
-        });
-        this.writer = writer;
-        this.generatePropertyHandlers();
-    }
-    /**
-     * Generate bitmark markup from bitmark AST
-     *
-     * @param ast bitmark AST
-     */
-    generate(ast) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Reset the state
-            this.resetState();
-            // Open the writer
-            yield this.writer.open();
-            // Walk the bitmark AST
-            this.walkAndWrite(ast);
-            // Write the JSON object to file
-            this.write(JSON.stringify(this.json, null, this.jsonPrettifySpace));
-            // Close the writer
-            yield this.writer.close();
-        });
-    }
-    /**
-     * Generate text from a bitmark text AST synchronously
-     *
-     * @param ast bitmark text AST
-     */
-    generateSync(ast) {
-        // Reset the state
-        this.resetState();
-        // Open the writer
-        this.writer.openSync();
-        // Walk the bitmark AST
-        this.walkAndWrite(ast);
-        // Close the writer
-        this.writer.closeSync();
-    }
-    resetState() {
-        this.json = [];
-        this.bitWrapperJson = {};
-        this.bitJson = {};
-        this.textDefault = this.options.textAsPlainText ? Breakscape.EMPTY_STRING : [];
-        this.bodyDefault = this.options.textAsPlainText ? Breakscape.EMPTY_STRING : [];
-        this.bodyJson = this.bodyDefault;
-        this.listItem = undefined;
-        this.placeholderIndex = 0;
-        this.printed = false;
-    }
-    walkAndWrite(ast) {
-        // Walk the bitmark AST
-        this.ast.walk(ast, NodeType.bitmarkAst, this, undefined);
-    }
-    //
-    // NODE HANDLERS
-    //
-    //
-    // Non-Terminal nodes (branches)
-    //
-    // bitmark
-    enter_bitmarkAst(_node, _route) {
-        // Reset the JSON
-        this.json = [];
-    }
-    exit_bitmarkAst(_node, _route) {
-        // Convert all bitmark text to plain text if required
-        if (this.options.textAsPlainText) {
-            // Convert all bitmark text to plain text
-            this.convertAllBitmarkTextsToStringsForPlainText(this.json);
-        }
-        // Walk the entire json object and remove all' '_xxx' properties
-        // (which are used to store temporary data during the generation process)
-        this.removeTemporaryProperties(this.json);
-    }
-    // bitmarkAst -> bits
-    // bitmarkAst -> bits -> bitsValue
-    enter_bitsValue(node, _route) {
-        var _a, _b;
-        const bit = node.value;
-        // Reset
-        this.bitWrapperJson = {
-        //
-        };
-        this.json.push(this.bitWrapperJson);
-        this.bitJson = this.createBitJson(bit);
-        this.bitWrapperJson.bit = this.bitJson;
-        // Handle example at the root level - this is bit dependent; configuration is in the bit metadata
-        // There is same logic here to select the correct default value of the example is the default is
-        // required, and this is bit depenedent.
-        // This is ugly, but it is even uglier if the defaults at set in the AST.
-        const bitConfig = Config.getBitConfig(bit.bitType);
-        const textFormat = this.getTextFormat(_route);
-        const hasRootExample = !!bitConfig.rootExampleType;
-        const isBoolean = bitConfig.rootExampleType === ExampleType.boolean;
-        if (hasRootExample) {
-            // Calculate the value of the default example
-            let defaultExample;
-            if (isBoolean) {
-                // Boolean example
-                defaultExample = true;
-                if (Config.isOfBitType(bit.bitType, BitType.trueFalse1)) {
-                    if (((_b = (_a = bit.cardNode) === null || _a === void 0 ? void 0 : _a.statement) === null || _b === void 0 ? void 0 : _b.isCorrect) !== undefined) {
-                        defaultExample = bit.cardNode.statement.isCorrect;
-                    }
-                }
-            }
-            else {
-                // String example
-                // Don't use sampleSolution as the default example for conversation bits
-                // See: https://github.com/getMoreBrain/cosmic/issues/7293
-                // defaultExample = (ArrayUtils.asSingle(bit.sampleSolution) as string) ?? '';
-                defaultExample = 'true';
-            }
-            const exampleRes = this.toExample(bit, {
-                defaultExample,
-                isBoolean,
-                textFormat,
-            });
-            this.bitJson.isExample = exampleRes.isExample;
-            this.bitJson.example = exampleRes.example;
-        }
-        else if (bit.isExample) {
-            this.bitJson.isExample = true;
-        }
-        // Reset the placeholder index
-        this.placeholderIndex = 0;
-    }
-    exit_bitsValue(_node, _route) {
-        // Move isExample / example to end of bit JSON from beginning
-        const isExample = this.bitJson.isExample;
-        const example = this.bitJson.example;
-        delete this.bitJson.isExample;
-        delete this.bitJson.example;
-        this.bitJson.isExample = isExample;
-        this.bitJson.example = example;
-        // Clean up the bit JSON, removing any unwanted values
-        this.cleanBitJson(this.bitJson);
-    }
-    // bitmarkAst -> bits -> bitsValue -> imageSource
-    enter_imageSource(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: false });
-    }
-    // bitmarkAst -> bits -> bitsValue -> person
-    enter_person(node, route) {
-        const bitType = this.getBitType(route);
-        let keyOverride = 'person';
-        if (Config.isOfBitType(bitType, BitType.conversationLeft1)) {
-            // Use the legacy partner property in the JSON for conversation bits, so change to person is backwards compatible
-            keyOverride = 'partner';
-        }
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: false, keyOverride });
-    }
-    // bitmarkAst -> bits -> bitsValue -> ratingLevelStart
-    enter_ratingLevelStart(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: false });
-    }
-    // bitmarkAst -> bits -> bitsValue -> ratingLevelEnd
-    enter_ratingLevelEnd(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: false });
-    }
-    // bitmarkAst -> bits -> bitsValue -> productId
-    enter_productId(node, route) {
-        const productIds = node.value;
-        // Ignore item that is not at the correct level
-        const parent = this.getParentNode(route);
-        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
-            return true;
-        const bitType = this.getBitType(route);
-        if (bitType === BitType.module) {
-            this.addProperty(this.bitJson, 'productId', productIds, { array: true });
-        }
-        else if (productIds.length > 0) {
-            this.addProperty(this.bitJson, 'productId', productIds[productIds.length - 1], { array: false });
-        }
-        // Stop traversal of this branch
-        return false;
-    }
-    // bitmarkAst -> bits -> bitsValue -> markConfig
-    enter_markConfig(_node, _route) {
-        // Handler so markConfig is not processed by the default property handler
-        // Continue traversal
-        return true;
-    }
-    // bitmarkAst -> bits -> bitsValue -> markConfig -> markConfigValue
-    enter_markConfigValue(node, route) {
-        const markJson = node.value;
-        // Ignore item that is not at the correct level
-        const parent = this.getParentNode(route);
-        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.markConfig)
-            return true;
-        if (!this.bitJson.marks)
-            this.bitJson.marks = [];
-        this.bitJson.marks.push(markJson);
-        // Stop traversal of this branch
-        return false;
-    }
-    // bitmarkAst -> bits -> bitsValue -> item
-    enter_item(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> lead
-    enter_lead(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> pageNumber
-    enter_pageNumber(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> marginNumber
-    enter_marginNumber(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> hint
-    enter_hint(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> instruction
-    enter_instruction(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> title
-    enter_title(node, route) {
-        // // Ignore title that are not at the bit or card node level as they are handled elsewhere
-        // const parent = this.getParentNode(route);
-        // if (parent?.key !== NodeType.bitsValue && parent?.key !== NodeType.cardNode) return;
-        // this.bitJson.title = node.value;
-        return this.standardHandler(node, route, [NodeType.bitsValue, NodeType.cardNode], { array: true });
-    }
-    //  bitmarkAst -> bits -> bitsValue -> subtitle
-    enter_subtitle(node, route) {
-        // this.bitJson.subtitle = node.value;
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: true });
-    }
-    //  bitmarkAst -> bits -> bitsValue -> caption
-    enter_caption(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> width
-    enter_width(node, route) {
-        var _a;
-        let value = node.value;
-        const bitType = this.getBitType(route);
-        const parent = this.getParentNode(route);
-        if ((parent === null || parent === void 0 ? void 0 : parent.key) === NodeType.bitsValue && Config.isOfBitType(bitType, BitType.extractorBlock)) {
-            value = (_a = NumberUtils.asNumber(value, 0)) !== null && _a !== void 0 ? _a : 0;
-        }
-        // Add the property
-        return this.standardHandler(node, route, undefined, { array: false, valueOverride: value });
-    }
-    // bitmarkAst -> bits -> bitsValue -> height
-    enter_height(node, route) {
-        var _a;
-        let value = node.value;
-        const bitType = this.getBitType(route);
-        const parent = this.getParentNode(route);
-        if ((parent === null || parent === void 0 ? void 0 : parent.key) === NodeType.bitsValue && Config.isOfBitType(bitType, BitType.extractorBlock)) {
-            value = (_a = NumberUtils.asNumber(value, 0)) !== null && _a !== void 0 ? _a : 0;
-        }
-        // Add the property
-        return this.standardHandler(node, route, undefined, { array: false, valueOverride: value });
-    }
-    // bitmarkAst -> bits -> bitsValue -> extraProperties
-    enter_extraProperties(node, _route) {
-        const extraProperties = node.value;
-        if (!this.options.excludeUnknownProperties && extraProperties) {
-            for (const [key, values] of Object.entries(extraProperties)) {
-                let k = key;
-                if (Object.prototype.hasOwnProperty.call(this.bitJson, key)) {
-                    k = `_${key}`;
-                }
-                this.addProperty(this.bitJson, k, values, { array: true });
-            }
-        }
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> cardBits -> cardBitsValue
-    enter_cardBitsValue(node, route) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        const cardBit = node.value;
-        // How cardBits are handled depends on the bit type
-        const bitType = this.getBitType(route);
-        if (!bitType)
-            return;
-        let listItems;
-        if (bitType === BitType.bookReferenceList) {
-            if (!this.bitJson.bookReferences)
-                this.bitJson.bookReferences = [];
-            const bookReference = {};
-            this.addProperty(bookReference, 'lang', cardBit.lang, { array: false });
-            this.addProperty(bookReference, 'refAuthor', (_a = cardBit.refAuthor) !== null && _a !== void 0 ? _a : [], { array: true });
-            this.addProperty(bookReference, 'refBookTitle', (_b = cardBit.refBookTitle) !== null && _b !== void 0 ? _b : [], { array: false });
-            this.addProperty(bookReference, 'refPublisher', (_c = cardBit.refPublisher) !== null && _c !== void 0 ? _c : [], { array: true });
-            this.addProperty(bookReference, 'refPublicationYear', (_d = cardBit.refPublicationYear) !== null && _d !== void 0 ? _d : [], { array: false });
-            this.addProperty(bookReference, 'citationStyle', (_e = cardBit.citationStyle) !== null && _e !== void 0 ? _e : [], { array: false });
-            this.bitJson.bookReferences.push(bookReference);
-        }
-        else {
-            // Create the listItems / sections if not already created
-            if (bitType === BitType.pageFooter) {
-                if (!this.bitJson.sections)
-                    this.bitJson.sections = [];
-                listItems = this.bitJson.sections;
-            }
-            else {
-                if (!this.bitJson.listItems)
-                    this.bitJson.listItems = [];
-                listItems = this.bitJson.listItems;
-            }
-            // Create this list item
-            this.listItem = {
-                item: ((_f = cardBit.item) !== null && _f !== void 0 ? _f : []),
-                lead: ((_g = cardBit.lead) !== null && _g !== void 0 ? _g : []),
-                hint: ((_h = cardBit.hint) !== null && _h !== void 0 ? _h : []),
-                instruction: ((_j = cardBit.instruction) !== null && _j !== void 0 ? _j : []),
-                // ...this.toItemLeadHintInstruction(node.value),
-                body: this.bodyDefault,
-            };
-            // Delete unwanted properties
-            // const nv = node.value;
-            // const li: Partial<ListItemJson> = this.listItem;
-            listItems.push(this.listItem);
-        }
-    }
-    exit_cardBitsValue(_node, _route) {
-        this.listItem = undefined;
-    }
-    // bitmarkAst -> bits -> bitsValue -> body
-    enter_body(node, route) {
-        const value = node.value;
-        const parent = this.getParentNode(route);
-        if (!parent)
-            return false;
-        const textFormat = this.getTextFormat(route);
-        const isBitmarkText = textFormat === TextFormat.bitmarkText;
-        this.bodyJson = value.body;
-        // Set the correct body property
-        if (parent.key === NodeType.bitsValue) {
-            // Body is at the bit level
-            this.bitJson.body = this.bodyJson;
-            const bodyIsBitmarkText = isBitmarkText && this.isBitmarkText(this.bodyJson);
-            // Convert the body to plain text if required
-            if (this.options.textAsPlainText && bodyIsBitmarkText) {
-                const textBody = this.textGenerator.generateSync(this.bodyJson, textFormat, TextLocation.body, {
-                    noBreakscaping: true,
-                });
-                this.bitJson.body = (textBody !== null && textBody !== void 0 ? textBody : '').trim();
-            }
-            else if (bodyIsBitmarkText) {
-                // If the body is bitmark text, convert the body bits to move their attributes to the attrs property
-                this.bitJson.body = this.moveBodyBitPropertiesToAttrs(this.bodyJson);
-            }
-        }
-        else if (parent.key === NodeType.cardBitsValue) {
-            // Body is at the list item (card bit) level
-            if (this.listItem)
-                this.listItem.body = this.bodyJson;
-        }
-        // Stop traversal of this branch
-        return false;
-    }
-    bodyBitCallback(bodyBit, _index, _route) {
-        // console.log('bodyBitCallback', bodyBit, index, route);
-        var _a;
-        const placeholder = `{${this.placeholderIndex}}`;
-        this.placeholderIndex++;
-        this.bitJson.placeholders = (_a = this.bitJson.placeholders) !== null && _a !== void 0 ? _a : {};
-        this.bitJson.placeholders[placeholder] = bodyBit;
-        return placeholder;
-    }
-    /**
-     * Move all properties of body bits to the attrs property.
-     * This function is called recursively to process all body bits in the body tree.
-     *
-     * NOTE: Internally, the body bit is stored as it appears in bitmark v2, but in v3 all the properties
-     * should be in the `attrs` property. The properies are only moved to 'attrs' for the JSON output
-     *
-     * The original body bit is not modified.
-     * The function returns a new body bit with the properties moved.
-     *
-     * @param nodes the body to process, or the subtree to process
-     * @param recursion leave as default, used for recursion only
-     * @returns
-     */
-    moveBodyBitPropertiesToAttrs(nodes, recursion = 0) {
-        if (recursion === 0) {
-            nodes = structuredClone(nodes);
-        }
-        else if (recursion > MOVE_BODY_RECURSION_LIMIT) {
-            throw new Error('Recursion limit exceeded');
-        }
-        for (const node of nodes) {
-            if (node.type !== BodyBitType.text && BodyBitType.values().includes(node.type)) {
-                const bodyBit = node;
-                bodyBit.attrs = {};
-                // Move all properties except type to the attrs property
-                for (const [key, value] of Object.entries(bodyBit)) {
-                    if (key === 'type' || key === 'attrs')
-                        continue;
-                    bodyBit.attrs[key] = value;
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    delete bodyBit[key];
-                }
-            }
-            else if (Array.isArray(node.content)) {
-                recursion++;
-                this.moveBodyBitPropertiesToAttrs(node.content, recursion);
-            }
-        }
-        return nodes;
-    }
-    // bitmarkAst -> bits -> bitsValue -> footer
-    enter_footer(node, route) {
-        return this.standardHandler(node, route, undefined, { array: true, valueOverride: node.value.footer });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> elements
-    enter_elements(node, route) {
-        return this.standardHandler(node, route, undefined, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> flashcards
-    enter_flashcards(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: true, keyOverride: 'cards' });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> definitions
-    enter_definitions(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> statement
-    enter_statement(node, route) {
-        var _a, _b;
-        const statement = node.value;
-        // Ignore statement that is not at the cardNode level as it is handled elsewhere
-        const parent = this.getParentNode(route);
-        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.cardNode)
-            return;
-        if (statement) {
-            this.bitJson.statement = (_a = statement.statement) !== null && _a !== void 0 ? _a : '';
-            this.bitJson.isCorrect = (_b = statement.isCorrect) !== null && _b !== void 0 ? _b : false;
-            this.bitJson.example = statement.example;
-            this.bitJson.isExample = statement.isExample;
-        }
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> statements -> statementsValue
-    enter_statements(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> choices
-    // X bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> choices
-    // X bitmarkAst -> bits -> bitsValue -> cardNode -> feedbacks -> feedbacksValue -> choices
-    enter_choices(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> responses
-    // X bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> responses
-    enter_responses(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> feedbacks
-    enter_feedbacks(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes
-    enter_quizzes(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> heading
-    enter_heading(node, route) {
-        return this.standardHandler(node, route, undefined, { array: false });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> pairs
-    enter_pairs(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> matrix
-    enter_matrix(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> pronunciationTable
-    enter_pronunciationTable(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: false });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> table
-    enter_table(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: false });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> questions
-    enter_questions(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses
-    enter_botResponses(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: true, keyOverride: 'responses' });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> ingredients -> ingredientsValue
-    enter_ingredients(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> captionDefinitionList
-    enter_captionDefinitionList(node, route) {
-        return this.standardHandler(node, route, NodeType.cardNode, { array: false });
-    }
-    // bitmarkAst -> bits -> bitsValue -> backgroundWallpaper
-    enter_backgroundWallpaper(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: false });
-    }
-    // bitmarkAst -> bits -> bitsValue -> imagePlaceholder
-    enter_imagePlaceholder(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: false });
-    }
-    // bitmarkAst -> bits -> bitsValue -> resources
-    enter_resources(node, route) {
-        var _a, _b;
-        const resources = node.value;
-        const bitType = this.getBitType(route);
-        const resourceType = this.getResourceType(route);
-        if (!resources || !bitType)
-            return true;
-        let resourceJson;
-        const bitConfig = Config.getBitConfig(bitType);
-        const bitResourcesConfig = Config.getBitResourcesConfig(bitType, resourceType);
-        const comboMap = bitResourcesConfig.comboResourceTagTypesMap;
-        if (bitResourcesConfig.comboResourceTagTypesMap.size > 0) {
-            // The resource is a combo resource
-            // Extract the resource types from the combo resource
-            // NOTE: There should only ever be one combo resource per bit, but the code can handle multiple
-            // except for overwriting resourceJson
-            for (const [comboTagType, resourceTags] of comboMap.entries()) {
-                // Create the combo resource wrapper
-                const wrapper = {
-                    type: comboTagType,
-                    __typeAlias: comboTagType,
-                };
-                // For each of the resources in this combo resource, find the actual resource and add it to the JSON
-                for (const rt of resourceTags) {
-                    const r = resources.find((r) => r.__typeAlias === rt);
-                    // Extract everything except the type from the resource
-                    if (r) {
-                        const tagConfig = Config.getTagConfigForTag(bitConfig.tags, r.__typeAlias);
-                        const key = (_a = tagConfig === null || tagConfig === void 0 ? void 0 : tagConfig.jsonKey) !== null && _a !== void 0 ? _a : r.__typeAlias;
-                        const tag = (_b = tagConfig === null || tagConfig === void 0 ? void 0 : tagConfig.tag) !== null && _b !== void 0 ? _b : r.__typeAlias;
-                        const json = r.__typeAlias === tag ? r : undefined;
-                        if (json) {
-                            for (const [k, v] of Object.entries(json)) {
-                                if (k !== 'type') {
-                                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                                    wrapper[key] = v;
-                                }
-                            }
-                        }
-                    }
-                }
-                resourceJson = wrapper;
-            }
-        }
-        else if (Config.isOfBitType(bitType, [BitType.imagesLogoGrave, BitType.prototypeImages])) {
-            // The resource is a logo-grave  / prototpye-images resource
-            const images = [];
-            for (const r of resources) {
-                if (r.type === ResourceTag.image) {
-                    images.push(r);
-                }
-            }
-            if (bitType === BitType.imagesLogoGrave) {
-                this.bitJson.logos = images;
-            }
-            else {
-                this.bitJson.images = images;
-            }
-        }
-        else {
-            // This is a standard resource. If there is more than one resource, use the first one.
-            // There should not be more than one because of validation
-            if (resources.length >= 1) {
-                resourceJson = resources[0]; // this.parseResourceToJson(bitType, resources[0]);
-            }
-        }
-        this.bitJson.resource = resourceJson;
-        return false;
-    }
-    //  bitmarkAst -> bits -> bitsValue -> level
-    leaf_level(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: false });
-    }
-    // bitmarkAst -> bits -> bitsValue -> book (array)
-    enter_book(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: true });
-    }
-    // bitmarkAst -> bits -> bitsValue -> book (single)
-    leaf_book(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: false });
-    }
-    //  bitmarkAst -> bits -> bitsValue -> anchor
-    leaf_anchor(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: false });
-    }
-    //  bitmarkAst -> bits -> bitsValue -> reference
-    leaf_reference(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: false });
-    }
-    //  bitmarkAst -> bits -> bitsValue -> referenceEnd
-    leaf_referenceEnd(node, route) {
-        return this.standardHandler(node, route, NodeType.bitsValue, { array: false });
-    }
-    // bitmarkAst -> bits -> bitsValue -> markup
-    leaf_markup(node, _route) {
-        const bitmark = node.value;
-        if (bitmark)
-            this.bitWrapperJson.bitmark = bitmark;
-        // Stop traversal of this branch
-        return false;
-    }
-    // bitmarkAst -> bits -> bitsValue -> * -> internalComment
-    enter_internalComment(_node, _route) {
-        // Stop traversal of this branch, handled in enter_parser()
-        return false;
-    }
-    // bitmarkAst -> bits -> bitsValue -> parser
-    enter_parser(node, route) {
-        const parser = node.value;
-        const bitType = this.getBitType(route);
-        const parent = this.getParentNode(route);
-        if (parser && bitType) {
-            const { version, excessResources: parserExcessResources, warnings, errors } = parser, parserRest = __rest(parser, ["version", "excessResources", "warnings", "errors"]);
-            const bitmarkVersion = `${this.bitmarkVersion}`;
-            const textParserVersion = this.textParserVersion;
-            // Parse resources to JSON from AST
-            let excessResources;
-            if (Array.isArray(parserExcessResources) && parserExcessResources.length > 0) {
-                excessResources = [];
-                for (const r of parserExcessResources) {
-                    excessResources.push(r);
-                }
-            }
-            // Extract internal comments from the AST and add to the parser
-            const internalComments = this.getInternalComments(route);
-            if ((parent === null || parent === void 0 ? void 0 : parent.key) === NodeType.bitsValue) {
-                // Bit level parser information
-                this.bitWrapperJson.parser = Object.assign(Object.assign({ version,
-                    bitmarkVersion,
-                    textParserVersion,
-                    internalComments }, parserRest), { warnings,
-                    errors,
-                    excessResources });
-                if (!this.options.enableWarnings) {
-                    // Remove warnings if not enabled
-                    delete this.bitWrapperJson.parser.warnings;
-                }
-            }
-            else {
-                // Top level parser information (not specific to a bit)
-                // TODO - not sure where this error can be written
-                // this.bitWrapperJson.parser = {
-                //   errors,
-                // };
-            }
-        }
-    }
-    // bitmarkAst -> errors
-    // protected enter_errors(node: NodeInfo, _route: NodeInfo[],
-    // context: Context): void {
-    //   const errors = node.value as ParserError[] | undefined;
-    //   if (errors && errors.length > 0) {
-    //     // Complete bit is invalid
-    //     // TODO - not sure where this error can be written
-    //     // this.bitWrapperJson.parser = {
-    //     //   errors,
-    //     // };
-    //   }
-    // }
-    //
-    // Generated Node Handlers
-    //
-    /**
-     * Generate the handlers for properties, as they are mostly the same, but not quite
-     */
-    generatePropertyHandlers() {
-        var _a;
-        const propertiesConfig = Config.getRawPropertiesConfig();
-        for (const propertyConfig of Object.values(propertiesConfig)) {
-            const astKey = (_a = propertyConfig.astKey) !== null && _a !== void 0 ? _a : propertyConfig.tag;
-            const funcName = `enter_${astKey}`;
-            // Skip if the function already exists, allows for custom handlers
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            if (typeof this[funcName] === 'function') {
-                continue;
-            }
-            // Skip 'example' property as it is non-standard and handled elsewhere
-            if (astKey === 'example')
-                continue;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this[funcName] = (node, route) => {
-                var _a;
-                const value = node.value;
-                if (value == null)
-                    return;
-                // if (key === 'progress') debugger;
-                // Ignore any property that is not at the bit level as that will be handled by a different handler
-                const parent = this.getParentNode(route);
-                if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
-                    return;
-                // Convert key as needed
-                const jsonKey = (_a = propertyConfig.jsonKey) !== null && _a !== void 0 ? _a : propertyConfig.tag;
-                // Add the property
-                this.addProperty(this.bitJson, jsonKey, value, { array: !propertyConfig.single });
-            };
-            // Bind this
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this[funcName] = this[funcName].bind(this);
-        }
-    }
-    // // END NODE HANDLERS
-    //
-    // HELPER FUNCTIONS
-    //
-    /**
-     * Default handler for properties.
-     *
-     * @param node the node
-     * @param route  the route to the node
-     * @param parentNodeTypes the parent node types for which to handle the node
-     * @returns
-     */
-    standardHandler(node, route, parentNodeTypes, options) {
-        var _a, _b;
-        // Ignore items not at the nodeType level
-        if (parentNodeTypes) {
-            const nodeTypeArray = Array.isArray(parentNodeTypes) ? parentNodeTypes : [parentNodeTypes];
-            const parent = this.getParentNode(route);
-            if (!(parent === null || parent === void 0 ? void 0 : parent.key) || !nodeTypeArray.includes(parent === null || parent === void 0 ? void 0 : parent.key))
-                return true;
-        }
-        // Add the property
-        this.addProperty(this.bitJson, (_a = options.keyOverride) !== null && _a !== void 0 ? _a : node.key, (_b = options.valueOverride) !== null && _b !== void 0 ? _b : node.value, options);
-        // Stop traversal of this branch
-        return false;
-    }
-    addProperty(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    target, name, values, options) {
-        if (values !== undefined) {
-            let finalValue;
-            if (!Array.isArray(values))
-                values = [values];
-            const valuesArr = values;
-            // if (valuesArr.length > 0) {
-            if (!options.array && valuesArr.length >= 1) {
-                finalValue = valuesArr[valuesArr.length - 1];
-            }
-            else {
-                finalValue = valuesArr;
-            }
-            // }
-            if (options.allowNull || finalValue != null) {
-                target[name] = finalValue;
-            }
-        }
-    }
-    toExample(node, options) {
-        const { isExample, example, __isDefaultExample } = node;
-        const { defaultExample, isBoolean } = options;
-        if (!isExample) {
-            return {
-                isExample: false,
-                example: null,
-            };
-        }
-        let exampleValue;
-        if (__isDefaultExample) {
-            exampleValue = isBoolean
-                ? BooleanUtils.toBoolean(defaultExample)
-                : this.convertBreakscapedStringToJsonText(defaultExample, options.textFormat, TextLocation.tag);
-        }
-        else {
-            exampleValue = isBoolean
-                ? BooleanUtils.toBoolean(example)
-                : this.convertBreakscapedStringToJsonText(example, options.textFormat, TextLocation.tag);
-        }
-        return {
-            isExample: true,
-            example: exampleValue,
-        };
-    }
-    /**
-     * Get the bit type from any node
-     *
-     * @param route the route to the current node
-     * @returns the bit type
-     */
-    getBitType(route) {
-        for (const node of route) {
-            if (node.key === NodeType.bitsValue) {
-                const n = node.value;
-                return n === null || n === void 0 ? void 0 : n.bitType;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Get the text format from any node
-     *
-     * @param route the route to the current node
-     * @returns the text format
-     */
-    getTextFormat(route) {
-        var _a;
-        const bitType = this.getBitType(route);
-        if (bitType) {
-            const bitConfig = Config.getBitConfig(bitType);
-            for (const node of route) {
-                if (node.key === NodeType.bitsValue) {
-                    const n = node.value;
-                    return (_a = TextFormat.fromValue(n === null || n === void 0 ? void 0 : n.textFormat)) !== null && _a !== void 0 ? _a : bitConfig.textFormatDefault;
-                }
-            }
-        }
-        return TextFormat.bitmarkText;
-    }
-    /**
-     * Get the bit resourceType atttachment from any node
-     *
-     * @param route the route to the current node
-     * @returns the bit type
-     */
-    getResourceType(route) {
-        for (const node of route) {
-            if (node.key === NodeType.bitsValue) {
-                const n = node.value;
-                return n === null || n === void 0 ? void 0 : n.resourceType;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Get the internal comments from any node
-     *
-     * @param route the route to the current node
-     * @returns the text format
-     */
-    getInternalComments(route) {
-        const bitType = this.getBitType(route);
-        if (bitType) {
-            for (const node of route) {
-                if (node.key === NodeType.bitsValue) {
-                    const n = node.value;
-                    return n.internalComment;
-                }
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Convert the text from the AST to the JSON format:
-     * Input:
-     *  - breakscaped string
-     * Output:
-     *  - text: plain text
-     *  - json: bitmark text JSON
-     *  - Bitmark v2: breakscaped string
-     *  - Bitmark v3: bitmark text JSON (TextAst)
-     *
-     * In the case of Bitmark v2 type texts, there is nothing to do but cast the type.
-     *
-     * @param text
-     * @returns
-     */
-    convertBreakscapedStringToJsonText(text, format, textLocation) {
-        if (!text)
-            undefined;
-        const isBitmarkText = format === TextFormat.bitmarkText;
-        if (!isBitmarkText) {
-            // Not bitmark text, so plain text, so  unbreakscape only the start of bit tags
-            return text || '';
-        }
-        const asPlainText = this.options.textAsPlainText;
-        if (asPlainText) {
-            return text || '';
-        }
-        // Use the text parser to parse the text
-        const textAst = this.textParser.toAst(text, {
-            format,
-            location: textLocation,
-        });
-        return textAst;
-    }
-    /**
-     * Concatenates a plain JSON text with a JsonText that may be plain (v2) or BitmarkText (v3)
-     * Returns the combined text.
-     *
-     * @param text the text to concatenate
-     * @param textPlain the plain text to concatenate
-     */
-    concatenatePlainTextWithJsonTexts(text, extraBreaks, textPlain) {
-        var _a;
-        if (Array.isArray(text)) {
-            textPlain = textPlain.trim();
-            if (textPlain) {
-                const splitText = textPlain.split('\n');
-                const content = [];
-                for (let i = 0; i < extraBreaks; i++) {
-                    content.push({
-                        type: TextNodeType.hardBreak,
-                    });
-                }
-                for (let i = 0; i < splitText.length; i++) {
-                    const t = splitText[i];
-                    if (t) {
-                        content.push({
-                            text: t,
-                            type: TextNodeType.text,
-                        });
-                    }
-                    // Add a hard break after each paragraph, except the last one
-                    if (i < splitText.length - 1) {
-                        content.push({
-                            type: TextNodeType.hardBreak,
-                        });
-                    }
-                }
-                // Add the content to the final paragraph, or create a new one if there none
-                const lastNode = text[text.length - 1];
-                if (lastNode && lastNode.type === TextNodeType.paragraph) {
-                    lastNode.content = [...((_a = lastNode.content) !== null && _a !== void 0 ? _a : []), ...content];
-                }
-                else {
-                    text.push({
-                        type: TextNodeType.paragraph,
-                        content,
-                        attrs: {},
-                    });
-                }
-            }
-            return text;
-        }
-        return `${text !== null && text !== void 0 ? text : ''}${'\n'.repeat(extraBreaks)}${textPlain !== null && textPlain !== void 0 ? textPlain : ''}`;
-    }
-    /**
-     * Check if an object is bitmark text
-     * The check looks for a special tag on the array (__tag: 'text')
-     *
-     * @param obj object that might be bitmark text
-     * @returns
-     */
-    isBitmarkText(obj) {
-        if (obj == null)
-            return false;
-        if (!Array.isArray(obj))
-            return false;
-        // Check for the hidden text tag
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        if (obj.__tag === 'text')
-            return true;
-        return false;
-    }
-    //
-    // WRITE FUNCTIONS
-    //
-    writeInlineDebug(key, state) {
-        let tag = key;
-        if (state.open) {
-            tag = `<${key}>`;
-        }
-        else if (state.close) {
-            tag = `</${key}>`;
-        }
-        else if (state.single) {
-            tag = `<${key} />`;
-        }
-        this.writeString(tag);
-    }
-    writeString(s) {
-        if (s != null)
-            this.write(`${s}`);
-    }
-    /**
-     * Create a new bit json object.
-     * - This function defines the order of the properties in the json.
-     *
-     * @param bit
-     * @returns
-     */
-    createBitJson(bit) {
-        const format = bit.textFormat;
-        const bitJson = {
-            type: bit.isCommented ? BitType._comment : bit.bitType,
-            originalType: bit.isCommented ? bit.bitType : undefined,
-            format,
-            bitLevel: bit.bitLevel,
-        };
-        return bitJson;
-    }
-    /**
-     * Remove wanted properties from bit json object.
-     * - This function defines the defaults for properties in the json.
-     *
-     * TODO: All these defaults should come from the config and be set in the Builder.
-     *
-     * @param bit
-     * @returns
-     */
-    cleanBitJson(bitJson) {
-        var _a, _b, _c, _d, _e, _f;
-        const bitType = Config.getBitType(bitJson.type);
-        const bitConfig = Config.getBitConfig(bitType);
-        // const textFormat = bitJson.format;
-        // const plainText = this.options.textAsPlainText;
-        // Clear 'originalType' if not set
-        if (bitJson.originalType == null)
-            bitJson.originalType = undefined;
-        // Clear 'item' which may be an empty string if 'lead' was set but item not
-        // Only necessary because '.article' does not include a default value for 'item'
-        // which is totally inconsistent, but maybe is wanted.
-        if (!bitJson.item)
-            bitJson.item = undefined;
-        // Add default properties to the bit.
-        // NOTE: Not all bits have the same default properties.
-        //       The properties used are a bit random sometimes?
-        //       It would be better if this functionality was generated from the bit config
-        if (Config.isOfBitType(bitType, [BitType._error, BitType._comment])) {
-            // Special case for _error and _comment bits
-            delete bitJson.format;
-            delete bitJson.item;
-            delete bitJson.lead;
-            delete bitJson.pageNumber;
-            delete bitJson.marginNumber;
-            delete bitJson.hint;
-            delete bitJson.instruction;
-            //
-        }
-        else {
-            let isTopLevelExample = false;
-            let isTopLevelExampleValue = false;
-            // Most bits have these defaults, but there are special cases (not sure if that is by error or design)
-            if (Config.isOfBitType(bitType, [BitType.page])) {
-                // Bits without item, lead, etc
-                if (bitJson.item == null || ((_a = bitJson.item) === null || _a === void 0 ? void 0 : _a.length) === 0)
-                    delete bitJson.item;
-                if (bitJson.lead == null || ((_b = bitJson.lead) === null || _b === void 0 ? void 0 : _b.length) === 0)
-                    delete bitJson.lead;
-                if (bitJson.pageNumber == null || ((_c = bitJson.pageNumber) === null || _c === void 0 ? void 0 : _c.length) === 0)
-                    delete bitJson.pageNumber;
-                if (bitJson.marginNumber == null || ((_d = bitJson.marginNumber) === null || _d === void 0 ? void 0 : _d.length) === 0)
-                    delete bitJson.marginNumber;
-                if (bitJson.hint == null || ((_e = bitJson.hint) === null || _e === void 0 ? void 0 : _e.length) === 0)
-                    delete bitJson.hint;
-                if (bitJson.instruction == null || ((_f = bitJson.instruction) === null || _f === void 0 ? void 0 : _f.length) === 0)
-                    delete bitJson.instruction;
-            }
-            else {
-                // Majority of bits
-                if (bitJson.item == null)
-                    bitJson.item = this.textDefault;
-                if (bitJson.lead == null)
-                    bitJson.lead = this.textDefault;
-                if (bitJson.hint == null)
-                    bitJson.hint = this.textDefault;
-                if (bitJson.instruction == null)
-                    bitJson.instruction = this.textDefault;
-                if (bitJson.pageNumber == null)
-                    bitJson.pageNumber = this.textDefault;
-                if (bitJson.marginNumber == null)
-                    bitJson.marginNumber = this.textDefault;
-            }
-            if (bitJson.body == null)
-                bitJson.body = this.bodyDefault;
-            if (Config.isOfBitType(bitType, [BitType.article])) {
-                //
-            }
-            if (Config.isOfBitType(bitType, [BitType.example])) {
-                // With 'example' value at the bit level.
-                isTopLevelExample = true;
-                isTopLevelExampleValue = true;
-            }
-            if (Config.isOfBitType(bitType, [
-                BitType.multipleChoice1,
-                BitType.multipleResponse1,
-                BitType.multipleChoiceText,
-                BitType.highlightText,
-                BitType.gapText,
-                BitType.gapTextInstructionGrouped,
-                BitType.clozeAndMultipleChoiceText,
-                BitType.sequence,
-                BitType.mark,
-                BitType.flashcard,
-                BitType.definitionList,
-            ])) {
-                // With no 'example' value at the bit level.
-                isTopLevelExample = true;
-                if (bitJson.body == null)
-                    bitJson.body = this.bodyDefault;
-            }
-            if (Config.isOfBitType(bitType, [BitType.sequence])) {
-                // With 'example' value at the bit level.
-                isTopLevelExample = true;
-                isTopLevelExampleValue = true;
-                if (bitJson.body == null)
-                    bitJson.body = this.bodyDefault;
-            }
-            if (Config.isOfBitType(bitType, BitType.cloze)) {
-                // With no 'example' value at the bit level.
-                isTopLevelExample = true;
-                if (Config.isOfBitType(bitType, BitType.clozeSolutionGrouped)) {
-                    // Solution grouped
-                    if (bitJson.quizCountItems == null)
-                        bitJson.quizCountItems = true;
-                    if (bitJson.quizStrikethroughSolutions == null)
-                        bitJson.quizStrikethroughSolutions = true;
-                }
-                else if (Config.isOfBitType(bitType, BitType.clozeInstructionGrouped)) {
-                    // Instruction grouped
-                    if (bitJson.quizCountItems == null)
-                        bitJson.quizCountItems = true;
-                    if (bitJson.quizStrikethroughSolutions == null)
-                        bitJson.quizStrikethroughSolutions = false;
-                }
-            }
-            if (Config.isOfBitType(bitType, [BitType.multipleChoice, BitType.multipleResponse])) {
-                // Default with a card (and hence a footer possibility)
-                isTopLevelExample = true;
-                if (bitJson.body == null)
-                    bitJson.body = this.bodyDefault;
-                if (bitJson.footer == null)
-                    bitJson.footer = this.textDefault;
-            }
-            if (Config.isOfBitType(bitType, BitType.essay)) {
-                // With 'example' value at the bit level.
-                isTopLevelExample = true;
-                isTopLevelExampleValue = true;
-                if (bitJson.body == null)
-                    bitJson.body = this.bodyDefault;
-                if (bitJson.partialAnswer == null)
-                    bitJson.partialAnswer = '';
-                // if (bitJson.sampleSolution == null) bitJson.sampleSolution = '';
-            }
-            if (Config.isOfBitType(bitType, BitType.trueFalse1)) {
-                // With 'example' value at the bit level.
-                isTopLevelExample = true;
-                isTopLevelExampleValue = true;
-                if (bitJson.isCorrect == null)
-                    bitJson.isCorrect = false;
-                if (bitJson.body == null)
-                    bitJson.body = this.bodyDefault;
-            }
-            if (Config.isOfBitType(bitType, BitType.trueFalse)) {
-                // With no 'example' value at the bit level.
-                isTopLevelExample = true;
-                if (bitJson.labelFalse == null)
-                    bitJson.labelFalse = '';
-                if (bitJson.labelTrue == null)
-                    bitJson.labelTrue = '';
-                if (bitJson.body == null)
-                    bitJson.body = this.bodyDefault;
-            }
-            if (Config.isOfBitType(bitType, BitType.chapter)) {
-                //
-                if (bitJson.toc == null)
-                    bitJson.toc = true; // Always set on chapter bits?
-                if (bitJson.progress == null)
-                    bitJson.progress = true; // Always set on chapter bits
-                if (bitJson.level == null)
-                    bitJson.level = 1; // Set level 1 if none set (makes no sense, but in ANTLR parser)
-                if (bitJson.body == null)
-                    bitJson.body = this.bodyDefault;
-                //
-            }
-            if (Config.isOfBitType(bitType, BitType.interview)) {
-                // With no 'example' value at the bit level.
-                isTopLevelExample = true;
-                if (bitJson.body == null)
-                    bitJson.body = this.bodyDefault;
-                if (bitJson.footer == null)
-                    bitJson.footer = this.textDefault;
-                if (bitJson.questions == null)
-                    bitJson.questions = [];
-            }
-            if (bitType === BitType.matchMatrix) {
-                // With no 'example' value at the bit level.
-                isTopLevelExample = true;
-            }
-            if (Config.isOfBitType(bitType, BitType.match)) {
-                // With no 'example' value at the bit level.
-                isTopLevelExample = true;
-                if (bitJson.heading == null)
-                    bitJson.heading = {};
-            }
-            if (Config.isOfBitType(bitType, BitType.learningPathBook)) {
-                //
-                if (bitJson.isTracked == null)
-                    bitJson.isTracked = true;
-                if (bitJson.isInfoOnly == null)
-                    bitJson.isInfoOnly = false;
-                //
-            }
-            if (Config.isOfBitType(bitType, BitType.table)) {
-                //
-                // if (bitJson.content2Buy == null) bitJson.content2Buy = '';
-                if (bitJson.tableFixedHeader == null)
-                    bitJson.tableFixedHeader = false;
-                if (bitJson.tableHeaderWhitespaceNoWrap == null)
-                    bitJson.tableHeaderWhitespaceNoWrap = true;
-                if (bitJson.tableSearch == null)
-                    bitJson.tableSearch = false;
-                if (bitJson.tableSort == null)
-                    bitJson.tableSort = false;
-                if (bitJson.tablePagination == null)
-                    bitJson.tablePagination = false;
-                if (bitJson.tablePaginationLimit == null)
-                    bitJson.tablePaginationLimit = 0;
-                if (bitJson.tableHeight == null)
-                    bitJson.tableHeight = 0;
-                if (bitJson.tableWhitespaceNoWrap == null)
-                    bitJson.tableWhitespaceNoWrap = false;
-                if (bitJson.tableAutoWidth == null)
-                    bitJson.tableAutoWidth = true;
-                if (bitJson.tableResizableColumns == null)
-                    bitJson.tableResizableColumns = false;
-                if (bitJson.tableColumnMinWidth == null)
-                    bitJson.tableColumnMinWidth = 0;
-                //
-            }
-            if (Config.isOfBitType(bitType, BitType.bookReference)) {
-                //
-                if (bitJson.refAuthor == null)
-                    bitJson.refAuthor = [];
-                if (bitJson.refBookTitle == null)
-                    bitJson.refBookTitle = '';
-                if (bitJson.refPublisher == null)
-                    bitJson.refPublisher = [];
-                if (bitJson.refPublicationYear == null)
-                    bitJson.refPublicationYear = '';
-                //
-            }
-            // Page bits
-            if (Config.isOfBitType(bitType, [
-                BitType.pageBanner,
-                BitType.pageBuyButton,
-                BitType.pageBuyButtonAlt,
-                BitType.pageBuyButtonPromotion,
-                BitType.pageFooter,
-                BitType.pageOpenBook,
-                BitType.pagePerson,
-                BitType.pageProduct,
-                BitType.pageProductList,
-                BitType.pageProductVideo,
-                BitType.pageProductVideoList,
-                BitType.pageSectionFolder,
-                BitType.pageSubscribe,
-                BitType.pageSubpage,
-            ])) {
-                //
-                if (bitJson.slug == null)
-                    bitJson.slug = '';
-                if (bitJson.body == null)
-                    bitJson.body = this.bodyDefault;
-                if (Config.isOfBitType(bitType, BitType.pageBuyButton)) {
-                    if (bitJson.content2Buy == null)
-                        bitJson.content2Buy = '';
-                }
-            }
-            // Special case for 'toc-resource' bits
-            if (Config.isOfBitType(bitType, BitType.tocResource)) {
-                if (bitJson.tocResource == null)
-                    bitJson.tocResource = [];
-            }
-            // Special case for 'toc-content' bits
-            if (Config.isOfBitType(bitType, BitType.tocContent)) {
-                if (bitJson.tocContent == null)
-                    bitJson.tocContent = [];
-            }
-            // Special case for 'book' bits
-            if (Config.isOfBitType(bitType, BitType.book)) {
-                if (bitJson.maxTocChapterLevel == null)
-                    bitJson.maxTocChapterLevel = -1;
-                if (bitJson.hasMarkAsDone == null)
-                    bitJson.hasMarkAsDone = false;
-                if (bitJson.processHandIn == null)
-                    bitJson.processHandIn = false;
-                if (bitJson.isPublic == null)
-                    bitJson.isPublic = false;
-                if (bitJson.chatWithBook == null)
-                    bitJson.chatWithBook = false;
-                if (bitJson.chatWithBookBrainKey == null)
-                    bitJson.chatWithBookBrainKey = '';
-            }
-            // Special case for 'ai' bits
-            if (bitType === BitType.articleAi || bitType === BitType.noteAi || bitType === BitType.summaryAi) {
-                if (bitJson.aiGenerated == null)
-                    bitJson.aiGenerated = true;
-            }
-            // Special case for '-responsive...' bits
-            if (Config.isOfBitType(bitType, [BitType.articleResponsive, BitType.pageArticleResponsive])) {
-                if (bitJson.imageFirst == null)
-                    bitJson.imageFirst = true;
-            }
-            // Special case for 'review-...' bits
-            if (Config.isOfBitType(bitType, BitType.reviewNote)) {
-                if (bitJson.resolved == null)
-                    bitJson.resolved = false;
-                if (bitJson.resolvedDate == null)
-                    bitJson.resolvedDate = '';
-                if (bitJson.resolvedBy == null)
-                    bitJson.resolvedBy = '';
-            }
-            // Special case for 'images-logos-grave' / 'prototype-images' / etc bits
-            if (Config.isOfBitType(bitType, [BitType.imagesLogoGrave, BitType.prototypeImages])) {
-                if (bitType === BitType.imagesLogoGrave) {
-                    if (bitJson.logos == null) {
-                        bitJson.logos = [];
-                    }
-                }
-                else {
-                    if (bitJson.images == null)
-                        bitJson.images = [];
-                }
-            }
-            // Special case for 'stepImageScreenshotWithPointer' / surveyMatrix / etc bits
-            if (Config.isOfBitType(bitType, [BitType.stepImageScreenshotWithPointer, BitType.surveyMatrix])) {
-                if (bitJson.pointerTop == null)
-                    bitJson.pointerTop = '';
-                if (bitJson.pointerLeft == null)
-                    bitJson.pointerLeft = '';
-                if (Config.isOfBitType(bitType, [BitType.surveyMatrix])) {
-                    if (bitJson.buttonCaption == null)
-                        bitJson.buttonCaption = '';
-                }
-            }
-            if (Config.isOfBitType(bitType, [BitType.listItem])) {
-                if (bitJson.listItemIndent == null)
-                    bitJson.listItemIndent = 0;
-            }
-            // Special case for 'survey-rating-*' bits
-            if (Config.isOfBitType(bitType, BitType.surveyRating)) {
-                //
-                if (bitJson.ratingLevelStart == null) {
-                    bitJson.ratingLevelStart = {
-                        level: 0,
-                    };
-                }
-                if (bitJson.ratingLevelEnd == null) {
-                    bitJson.ratingLevelEnd = {
-                        level: 0,
-                    };
-                }
-            }
-            // Special case for 'vendor-stripe-pricing-table' bits
-            if (Config.isOfBitType(bitType, BitType.vendorStripePricingTable)) {
-                if (bitJson.stripePricingTableId == null)
-                    bitJson.stripePricingTableId = '';
-                if (bitJson.stripePublishableKey == null)
-                    bitJson.stripePublishableKey = '';
-            }
-            // Special case for 'call-to-action' bits
-            if (Config.isOfBitType(bitType, BitType.callToAction)) {
-                if (bitJson.buttonCaption == null)
-                    bitJson.buttonCaption = '';
-                if (bitJson.callToActionUrl == null)
-                    bitJson.callToActionUrl = '';
-            }
-            // Special case for 'hand-in-file' bits
-            if (Config.isOfBitType(bitType, BitType.handInFile)) {
-                if (bitJson.handInAcceptFileType == null)
-                    bitJson.handInAcceptFileType = [];
-            }
-            // Special case for 'hand-in-submit' bits
-            if (Config.isOfBitType(bitType, BitType.handInSubmit)) {
-                if (bitJson.handInRequirement == null)
-                    bitJson.handInRequirement = [];
-                if (bitJson.handInInstruction == null)
-                    bitJson.handInInstruction = '';
-                if (bitJson.buttonCaption == null)
-                    bitJson.buttonCaption = '';
-            }
-            // Special case for 'module' bits
-            if (Config.isOfBitType(bitType, BitType.module)) {
-                if (bitJson.hasBookNavigation == null)
-                    bitJson.hasBookNavigation = true;
-            }
-            // Special case for 'container' bits
-            if (Config.isOfBitType(bitType, BitType.container)) {
-                if (bitJson.allowedBit == null)
-                    bitJson.allowedBit = [];
-            }
-            // Special case for 'quiz' bits
-            if (bitConfig.quizBit) {
-                if (bitJson.revealSolutions == null)
-                    bitJson.revealSolutions = false;
-            }
-            // Special case for 'platform-path' bits
-            if (Config.isOfBitType(bitType, BitType.platformPath)) {
-                if (bitJson.path == null)
-                    bitJson.path = '';
-            }
-            // Remove top level example if it is not required
-            if (isTopLevelExample) {
-                if (bitJson.isExample == null)
-                    bitJson.isExample = false;
-            }
-            else {
-                // Remove example
-                delete bitJson.isExample;
-                delete bitJson.example;
-            }
-            if (isTopLevelExampleValue) {
-                if (bitJson.example == null)
-                    bitJson.example = null;
-            }
-            else {
-                // Remove example value
-                delete bitJson.example;
-            }
-        }
-        return bitJson;
-    }
-    /**
-     * Convert any bitmark texts to strings.
-     */
-    convertAllBitmarkTextsToStringsForPlainText(json) {
-        if (!this.options.textAsPlainText)
-            return;
-        const obj = json;
-        for (const key in obj) {
-            const val = obj[key];
-            if (this.isBitmarkText(val)) {
-                const s = this.textGenerator.generateSync(val, TextFormat.bitmarkText, TextLocation.tag, {
-                    noBreakscaping: true,
-                });
-                obj[key] = (s !== null && s !== void 0 ? s : '').trim();
-            }
-            else if (typeof obj[key] === 'object') {
-                this.convertAllBitmarkTextsToStringsForPlainText(obj[key]);
-            }
-        }
-    }
-    /**
-     * Remove any property with a key starting with an double underscore.
-     *
-     * @param json
-     */
-    removeTemporaryProperties(json) {
-        const obj = json;
-        for (const key in obj) {
-            if (key.startsWith('__')) {
-                delete obj[key];
-            }
-            else if (typeof obj[key] === 'object') {
-                this.removeTemporaryProperties(obj[key]);
-            }
-        }
-    }
-    //
-    // Writer interface
-    //
-    /**
-     * Writes a string value to the output.
-     * @param value - The string value to be written.
-     */
-    write(value) {
-        this.writer.write(value);
-        return 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) {
-        this.writer.writeLine(value);
-        return 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, delimiter) {
-        this.writer.writeLines(values, delimiter);
-        return this;
-    }
-    /**
-     * Writes a single whitespace character to the output.
-     */
-    writeWhiteSpace() {
-        this.writer.writeWhiteSpace();
-        return this;
-    }
-}
-export { JsonGenerator };
-//# sourceMappingURL=JsonGenerator.js.map