@gmb/bitmark-parser-generator 1.0.11

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

@@ -0,0 +1,2046 @@
+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 { Ast } from '../../ast/Ast';
+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 { PropertyKey } from '../../model/enum/PropertyKey';
+import { ResourceType } from '../../model/enum/ResourceType';
+import { TextFormat } from '../../model/enum/TextFormat';
+import { TextParser } from '../../parser/text/TextParser';
+import { ArrayUtils } from '../../utils/ArrayUtils';
+import { StringUtils } from '../../utils/StringUtils';
+import { UrlUtils } from '../../utils/UrlUtils';
+const DEFAULT_OPTIONS = {
+// debugGenerationInline: true,
+};
+/**
+ * Generate bitmark JSON from a bitmark AST
+ *
+ * TODO: NOT IMPLEMENTED!
+ */
+class JsonGenerator {
+    /**
+     * Generate bitmark JSON from a bitmark AST
+     *
+     * @param writer - destination for the output
+     * @param options - JSON generation options
+     */
+    constructor(writer, options) {
+        var _a;
+        this.ast = new Ast();
+        this.textParser = new TextParser();
+        // State
+        this.json = [];
+        this.bitWrapperJson = {};
+        this.bitJson = {};
+        this.textDefault = '';
+        this.bodyDefault = '';
+        // Debug
+        this.printed = false;
+        this.bitmarkVersion = (_a = BitmarkVersion.fromValue(options === null || options === void 0 ? void 0 : options.bitmarkVersion)) !== null && _a !== void 0 ? _a : DEFAULT_BITMARK_VERSION;
+        this.options = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options === null || options === void 0 ? void 0 : options.jsonOptions);
+        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;
+            }
+        }
+        this.writer = writer;
+        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.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 ? '' : [];
+        this.bodyDefault = this.options.textAsPlainText ? '' : [];
+        this.printed = false;
+    }
+    walkAndWrite(ast) {
+        // Walk the bitmark AST
+        this.ast.walk(ast, NodeType.bitmarkAst, this, undefined);
+    }
+    enter(node, parent, route) {
+        let res = void 0;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const gen = this;
+        const funcName = `enter_${node.key}`;
+        if (!this.printed) {
+            this.printed = true;
+        }
+        if (this.options.debugGenerationInline)
+            this.writeInlineDebug(node.key, { open: true });
+        if (typeof gen[funcName] === 'function') {
+            res = gen[funcName](node, parent, route);
+        }
+        return res;
+    }
+    between(node, left, right, parent, route) {
+        let res = void 0;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const gen = this;
+        const funcName = `between_${node.key}`;
+        if (this.options.debugGenerationInline)
+            this.writeInlineDebug(node.key, { single: true });
+        if (typeof gen[funcName] === 'function') {
+            res = gen[funcName](node, left, right, parent, route);
+        }
+        return res;
+    }
+    exit(node, parent, route) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const gen = this;
+        const funcName = `exit_${node.key}`;
+        if (this.options.debugGenerationInline)
+            this.writeInlineDebug(node.key, { close: true });
+        if (typeof gen[funcName] === 'function') {
+            gen[funcName](node, parent, route);
+        }
+    }
+    leaf(node, parent, route) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const gen = this;
+        const funcName = `leaf_${node.key}`;
+        if (this.options.debugGenerationInline)
+            this.writeInlineDebug(node.key, { open: true });
+        if (typeof gen[funcName] === 'function') {
+            gen[funcName](node, parent, route);
+        }
+        if (this.options.debugGenerationInline)
+            this.writeInlineDebug(node.key, { close: true });
+    }
+    //
+    // NODE HANDLERS
+    //
+    //
+    // Non-Terminal nodes (branches)
+    //
+    // bitmark
+    enter_bitmarkAst(_node, _parent, _route) {
+        // Reset the JSON
+        this.json = [];
+    }
+    // bitmarkAst -> bits
+    // bitmarkAst -> bits -> bitsValue
+    enter_bitsValue(node, _parent, _route) {
+        const bit = node.value;
+        // Reset
+        this.bitWrapperJson = {
+        //
+        };
+        this.json.push(this.bitWrapperJson);
+        this.bitJson = this.createBitJson(bit);
+        this.bitWrapperJson.bit = this.bitJson;
+    }
+    exit_bitsValue(_node, _parent, _route) {
+        // Clean up the bit JSON, removing any unwanted values
+        this.cleanAndSetDefaultsForBitJson(this.bitJson);
+    }
+    // bitmarkAst -> bits -> bitsValue -> partner
+    enter_partner(node, parent, _route) {
+        const partner = node.value;
+        // Ignore example that is not at the bit level as it are handled elsewhere
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return;
+        const { name, avatarImage } = partner;
+        const partnerJson = {};
+        this.addProperty(partnerJson, 'name', name !== null && name !== void 0 ? name : '', true);
+        if (avatarImage) {
+            const res = this.parseResourceToJson(avatarImage);
+            if (res && res.type === ResourceType.image) {
+                partnerJson.avatarImage = res.image;
+            }
+        }
+        this.bitJson.partner = partnerJson;
+    }
+    // bitmarkAst -> bits -> bitsValue -> sampleSolution
+    enter_sampleSolution(node, _parent, _route) {
+        if (node.value != null)
+            this.addProperty(this.bitJson, 'sampleSolution', node.value, true);
+    }
+    // bitmarkAst -> bits -> bitsValue -> itemLead
+    enter_itemLead(node, parent, _route) {
+        const itemLead = node.value;
+        const { item, lead } = itemLead;
+        // Ignore item / lead that are not at the bit level as they are handled elsewhere
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return;
+        if (item != null) {
+            this.bitJson.item = this.toTextAstOrString(item);
+        }
+        if (lead != null) {
+            this.bitJson.lead = this.toTextAstOrString(lead);
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> extraProperties
+    enter_extraProperties(node, _parent, _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);
+            }
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> body -> bodyParts
+    enter_bodyParts(node, _parent, route) {
+        const bodyParts = node.value;
+        const plainText = this.options.textAsPlainText;
+        const textFormat = this.getTextFormat(route);
+        let fullBodyTextStr = '';
+        let placeholderIndex = 0;
+        // Ensure body exists
+        if (this.bitJson.body == null)
+            this.bitJson.body = this.bodyDefault;
+        // Function for creating the placeholder keys
+        const createPlaceholderKeys = (i) => {
+            return {
+                // Old placeholder style (for backwards compatibility) = {0}
+                legacyPlaceholderKey: `{${i}}`,
+                // New placeholder style (cannot clash as bitmark parser would have removed it) = [!0]
+                placeholderKey: `[!${i}]`,
+            };
+        };
+        // Loop the text bodyParts creating full body text with the correct placeholders
+        //
+        // For text output 'fullBodyTextStr:
+        // - is created and written to the JSON
+        // - has placeholders inserted into 'fullBodyTextStr' in the format {0}
+        //
+        // For JSON output 'fullBodyTextStr:
+        // - is created and passed into the text parser to create the body text AST
+        // - has placeholders inserted into 'fullBodyTextStr' in the format [!0] to allow the text parser to identify
+        //   where the body bits should be inserted
+        //
+        for (let i = 0; i < bodyParts.length; i++) {
+            const bodyPart = bodyParts[i];
+            const isText = bodyPart.type === BodyBitType.text;
+            if (isText) {
+                const asText = bodyPart;
+                const bodyTextPart = asText.data.bodyText;
+                // Append the text part to the full text body
+                fullBodyTextStr += bodyTextPart;
+            }
+            else {
+                const { legacyPlaceholderKey, placeholderKey } = createPlaceholderKeys(placeholderIndex);
+                // Append the placeholder to the full text body
+                fullBodyTextStr += plainText ? legacyPlaceholderKey : placeholderKey;
+                placeholderIndex++;
+            }
+        }
+        // Add string or AST to the body
+        this.bitJson.body = this.toTextAstOrString(fullBodyTextStr, textFormat);
+        const bodyAst = this.bitJson.body;
+        // Loop the body parts again to create the body bits:
+        // - For text output the body bits are inserted into the 'placeholders' object
+        // - For JSON output the body bits are inserted into body AST, replacing the placeholders created by the text parser
+        placeholderIndex = 0;
+        for (let i = 0; i < bodyParts.length; i++) {
+            const bodyPart = bodyParts[i];
+            // Skip text body parts as they are handled above
+            const isText = bodyPart.type === BodyBitType.text;
+            if (isText)
+                continue;
+            const bodyBit = bodyPart;
+            let bodyBitJson;
+            const { legacyPlaceholderKey } = createPlaceholderKeys(placeholderIndex);
+            switch (bodyPart.type) {
+                case BodyBitType.gap: {
+                    const gap = bodyBit;
+                    bodyBitJson = this.createGapJson(gap);
+                    break;
+                }
+                case BodyBitType.select: {
+                    const select = bodyBit;
+                    bodyBitJson = this.createSelectJson(select);
+                    break;
+                }
+                case BodyBitType.highlight: {
+                    const highlight = bodyBit;
+                    bodyBitJson = this.createHighlightJson(highlight);
+                    break;
+                }
+            }
+            // Add the gap to the placeholders
+            if (bodyBitJson) {
+                if (plainText) {
+                    // Ensure placeholders exists
+                    if (!this.bitJson.placeholders)
+                        this.bitJson.placeholders = {};
+                    // Add the body bit to the placeholders
+                    this.bitJson.placeholders[legacyPlaceholderKey] = bodyBitJson;
+                }
+                else {
+                    // Insert the body bit into the body AST
+                    this.replacePlaceholderWithBodyBit(bodyAst, bodyBitJson, placeholderIndex);
+                }
+            }
+            placeholderIndex++;
+        }
+        // Stop traversal of this branch for efficiency
+        return false;
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> elements
+    enter_elements(node, _parent, _route) {
+        const elements = node.value;
+        // Ignore elements that are not at the bit level as they are handled elsewhere as quizzes
+        // if (parent?.key !== NodeType.bitsValue) return;
+        if (elements && elements.length > 0) {
+            this.bitJson.elements = elements;
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> statement
+    enter_statement(node, parent, _route) {
+        var _a, _b;
+        const statement = node.value;
+        // Ignore statement that is not at the bit level as it is handled elsewhere
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return;
+        if (statement) {
+            this.bitJson.statement = (_a = statement.text) !== null && _a !== void 0 ? _a : '';
+            this.bitJson.isCorrect = (_b = statement.isCorrect) !== null && _b !== void 0 ? _b : false;
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> statements -> statementsValue
+    enter_statements(node, parent, _route) {
+        var _a, _b, _c, _d;
+        const statements = node.value;
+        // Ignore statements that are not at the card node level as they are handled elsewhere
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.cardNode)
+            return;
+        const statementsJson = [];
+        if (statements) {
+            for (const s of statements) {
+                // Create the statement
+                const statementJson = Object.assign(Object.assign({ statement: (_a = s.text) !== null && _a !== void 0 ? _a : '', isCorrect: (_b = s.isCorrect) !== null && _b !== void 0 ? _b : false }, this.toItemLeadHintInstruction(s)), this.toExampleAndIsExample(s.example));
+                // Delete unwanted properties
+                if (((_c = s.itemLead) === null || _c === void 0 ? void 0 : _c.item) == null)
+                    delete statementJson.item;
+                if (((_d = s.itemLead) === null || _d === void 0 ? void 0 : _d.lead) == null)
+                    delete statementJson.lead;
+                if ((s === null || s === void 0 ? void 0 : s.hint) == null)
+                    delete statementJson.hint;
+                if ((s === null || s === void 0 ? void 0 : s.instruction) == null)
+                    delete statementJson.instruction;
+                if ((s === null || s === void 0 ? void 0 : s.example) == null)
+                    delete statementJson.example;
+                statementsJson.push(statementJson);
+            }
+        }
+        if (statementsJson.length > 0) {
+            this.bitJson.statements = statementsJson;
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> choices
+    // X bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> choices
+    enter_choices(node, parent, _route) {
+        var _a, _b, _c;
+        const choices = node.value;
+        // Ignore choices that are not at the bit level as they are handled elsewhere as quizzes
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return;
+        const choicesJson = [];
+        if (choices) {
+            for (const c of choices) {
+                // Create the choice
+                const choiceJson = Object.assign({ choice: (_a = c.text) !== null && _a !== void 0 ? _a : '', isCorrect: (_b = c.isCorrect) !== null && _b !== void 0 ? _b : false }, this.toItemLeadHintInstruction(c));
+                // Delete unwanted properties
+                if (((_c = c.itemLead) === null || _c === void 0 ? void 0 : _c.lead) == null)
+                    delete choiceJson.lead;
+                choicesJson.push(choiceJson);
+            }
+        }
+        if (choicesJson.length > 0) {
+            this.bitJson.choices = choicesJson;
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> responses
+    // X bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> responses
+    enter_responses(node, parent, _route) {
+        var _a, _b, _c;
+        const responses = node.value;
+        // Ignore responses that are not at the bit level as they are handled elsewhere as quizzes
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return;
+        const responsesJson = [];
+        if (responses) {
+            for (const r of responses) {
+                // Create the response
+                const responseJson = Object.assign({ response: (_a = r.text) !== null && _a !== void 0 ? _a : '', isCorrect: (_b = r.isCorrect) !== null && _b !== void 0 ? _b : false }, this.toItemLeadHintInstruction(r));
+                // Delete unwanted properties
+                if (((_c = r.itemLead) === null || _c === void 0 ? void 0 : _c.lead) == null)
+                    delete responseJson.lead;
+                responsesJson.push(responseJson);
+            }
+        }
+        if (responsesJson.length > 0) {
+            this.bitJson.responses = responsesJson;
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes
+    enter_quizzes(node, _parent, _route) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const quizzes = node.value;
+        const quizzesJson = [];
+        if (quizzes) {
+            for (const q of quizzes) {
+                // Choices
+                const choicesJson = [];
+                if (q.choices) {
+                    for (const c of q.choices) {
+                        // Create the choice
+                        const choiceJson = Object.assign({ choice: (_a = c.text) !== null && _a !== void 0 ? _a : '', isCorrect: (_b = c.isCorrect) !== null && _b !== void 0 ? _b : false }, this.toItemLeadHintInstruction(c));
+                        // Delete unwanted properties
+                        if (((_c = q.itemLead) === null || _c === void 0 ? void 0 : _c.lead) == null)
+                            delete choiceJson.lead;
+                        choicesJson.push(choiceJson);
+                    }
+                }
+                // Responses
+                const responsesJson = [];
+                if (q.responses) {
+                    for (const c of q.responses) {
+                        // Create the choice
+                        const responseJson = Object.assign({ response: (_d = c.text) !== null && _d !== void 0 ? _d : '', isCorrect: (_e = c.isCorrect) !== null && _e !== void 0 ? _e : false }, this.toItemLeadHintInstruction(c));
+                        // Delete unwanted properties
+                        if (((_f = q.itemLead) === null || _f === void 0 ? void 0 : _f.lead) == null)
+                            delete responseJson.lead;
+                        responsesJson.push(responseJson);
+                    }
+                }
+                // Create the quiz
+                const quizJson = Object.assign(Object.assign(Object.assign({}, this.toItemLeadHintInstruction(q)), this.toExampleAndIsExample(q.example)), { choices: q.choices ? choicesJson : undefined, responses: q.responses ? responsesJson : undefined });
+                // Delete unwanted properties
+                if (((_g = q.itemLead) === null || _g === void 0 ? void 0 : _g.lead) == null)
+                    delete quizJson.lead;
+                quizzesJson.push(quizJson);
+            }
+        }
+        if (quizzesJson.length > 0) {
+            this.bitJson.quizzes = quizzesJson;
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> heading
+    enter_heading(node, _parent, _route) {
+        var _a, _b;
+        const heading = node.value;
+        // Ensure the heading is valid for writing out (it will be valid, but if it is empty, it should not be written)
+        let valid = false;
+        if (heading && heading.forKeys /*&& heading.forValues && heading.forValues.length > 0*/) {
+            valid = true;
+        }
+        if (!valid)
+            return false;
+        // Create the heading
+        const headingJson = {
+            forKeys: (_a = heading.forKeys) !== null && _a !== void 0 ? _a : '',
+        };
+        // TODO: Should probably check wether bit is a match or a matrix and add a string for match and array for matrix
+        if (Array.isArray(heading.forValues)) {
+            if (heading.forValues.length > 1) {
+                headingJson.forValues = heading.forValues;
+            }
+            else if (heading.forValues.length === 1) {
+                headingJson.forValues = heading.forValues[0];
+            }
+            else {
+                headingJson.forValues = heading.forValues;
+            }
+        }
+        else {
+            headingJson.forValues = (_b = heading.forValues) !== null && _b !== void 0 ? _b : '';
+        }
+        this.bitJson.heading = headingJson;
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> pairs
+    enter_pairs(node, _parent, _route) {
+        var _a, _b, _c, _d, _e;
+        const pairs = node.value;
+        const pairsJson = [];
+        if (pairs) {
+            for (const p of pairs) {
+                // Create the question
+                const pairJson = Object.assign(Object.assign(Object.assign({ key: (_a = p.key) !== null && _a !== void 0 ? _a : '', keyAudio: p.keyAudio ? this.addAudioResource(p.keyAudio) : undefined, keyImage: p.keyImage ? this.addImageResource(p.keyImage) : undefined, values: (_b = p.values) !== null && _b !== void 0 ? _b : [] }, this.toItemLeadHintInstruction(p)), this.toExampleAndIsExample(p.example)), { isCaseSensitive: (_c = p.isCaseSensitive) !== null && _c !== void 0 ? _c : true, isLongAnswer: (_d = !p.isShortAnswer) !== null && _d !== void 0 ? _d : false });
+                // Delete unwanted properties
+                if (((_e = p.itemLead) === null || _e === void 0 ? void 0 : _e.lead) == null)
+                    delete pairJson.lead;
+                if (pairJson.key) {
+                    delete pairJson.keyAudio;
+                    delete pairJson.keyImage;
+                }
+                if (pairJson.keyAudio != null) {
+                    delete pairJson.key;
+                    delete pairJson.keyImage;
+                }
+                if (pairJson.keyImage != null) {
+                    delete pairJson.key;
+                    delete pairJson.keyAudio;
+                }
+                pairsJson.push(pairJson);
+            }
+        }
+        if (pairsJson.length > 0) {
+            this.bitJson.pairs = pairsJson;
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> matrix
+    enter_matrix(node, _parent, _route) {
+        var _a, _b, _c, _d, _e, _f;
+        const matrix = node.value;
+        const matrixJsonArray = [];
+        if (matrix) {
+            for (const m of matrix) {
+                // Choices
+                const matrixCellsJson = [];
+                if (m.cells) {
+                    for (const c of m.cells) {
+                        // Create the choice
+                        const matrixCellJson = Object.assign(Object.assign({ values: (_a = c.values) !== null && _a !== void 0 ? _a : [] }, this.toItemLeadHintInstruction(c)), this.toExampleAndIsExample(c.example));
+                        // Delete unwanted properties
+                        if (((_b = c.itemLead) === null || _b === void 0 ? void 0 : _b.lead) == null)
+                            delete matrixCellJson.lead;
+                        if (c.hint == null)
+                            delete matrixCellJson.hint;
+                        if (c.example == null)
+                            delete matrixCellJson.isExample;
+                        if (c.example == null)
+                            delete matrixCellJson.example;
+                        matrixCellsJson.push(matrixCellJson);
+                    }
+                }
+                // Create the matrix
+                const matrixJson = Object.assign(Object.assign(Object.assign({ key: (_c = m.key) !== null && _c !== void 0 ? _c : '', cells: matrixCellsJson !== null && matrixCellsJson !== void 0 ? matrixCellsJson : [] }, this.toItemLeadHintInstruction(m)), this.toExampleAndIsExample(m.example)), { isCaseSensitive: (_d = m.isCaseSensitive) !== null && _d !== void 0 ? _d : true, isLongAnswer: (_e = !m.isShortAnswer) !== null && _e !== void 0 ? _e : false });
+                // Delete unwanted properties
+                if (((_f = m.itemLead) === null || _f === void 0 ? void 0 : _f.lead) == null)
+                    delete matrixJson.lead;
+                if (m.instruction == null)
+                    delete matrixJson.instruction;
+                matrixJsonArray.push(matrixJson);
+            }
+        }
+        if (matrixJsonArray.length > 0) {
+            this.bitJson.matrix = matrixJsonArray;
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> questions
+    enter_questions(node, _parent, _route) {
+        var _a, _b, _c, _d, _e;
+        const questions = node.value;
+        const questionsJson = [];
+        if (questions) {
+            for (const q of questions) {
+                // Create the question
+                const questionJson = Object.assign(Object.assign(Object.assign({ question: (_a = q.question) !== null && _a !== void 0 ? _a : '', partialAnswer: (_b = ArrayUtils.asSingle(q.partialAnswer)) !== null && _b !== void 0 ? _b : '', sampleSolution: (_c = q.sampleSolution) !== null && _c !== void 0 ? _c : '' }, this.toItemLeadHintInstruction(q)), this.toExampleAndIsExample(q.example)), { 
+                    // isCaseSensitive: q.isCaseSensitive ?? true,
+                    isShortAnswer: (_d = q.isShortAnswer) !== null && _d !== void 0 ? _d : true });
+                // Delete unwanted properties
+                if (((_e = q.itemLead) === null || _e === void 0 ? void 0 : _e.lead) == null)
+                    delete questionJson.lead;
+                questionsJson.push(questionJson);
+            }
+        }
+        if (questionsJson.length > 0) {
+            this.bitJson.questions = questionsJson;
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses
+    enter_botResponses(node, parent, _route) {
+        var _a, _b, _c, _d;
+        const botResponses = node.value;
+        // Ignore responses that are not at the cardNode level as they are handled elsewhere
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.cardNode)
+            return;
+        const responsesJson = [];
+        if (botResponses) {
+            for (const r of botResponses) {
+                // Create the response
+                const responseJson = Object.assign({ response: (_a = r.response) !== null && _a !== void 0 ? _a : '', reaction: (_b = r.reaction) !== null && _b !== void 0 ? _b : '', feedback: (_c = r.feedback) !== null && _c !== void 0 ? _c : '' }, this.toItemLeadHintInstruction(r));
+                // Delete unwanted properties
+                if (((_d = r.itemLead) === null || _d === void 0 ? void 0 : _d.lead) == null)
+                    delete responseJson.lead;
+                if (r.hint == null)
+                    delete responseJson.hint;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                delete responseJson.instruction;
+                responsesJson.push(responseJson);
+            }
+        }
+        if (responsesJson.length > 0) {
+            this.bitJson.responses = responsesJson;
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> resource
+    enter_resource(node, _parent, _route) {
+        const resource = node.value;
+        // This is a resource - handle it with the common code
+        this.bitJson.resource = this.parseResourceToJson(resource);
+    }
+    //
+    // Terminal nodes (leaves)
+    //
+    // bitmarkAst -> bits -> bitsValue -> title
+    leaf_title(node, _parent, _route) {
+        this.bitJson.title = this.toTextAstOrString(node.value);
+    }
+    //  bitmarkAst -> bits -> bitsValue -> subtitle
+    leaf_subtitle(node, _parent, _route) {
+        this.bitJson.subtitle = this.toTextAstOrString(node.value);
+    }
+    // //  bitmarkAst -> bits -> bitsValue -> level
+    leaf_level(node, _parent, _route) {
+        var _a;
+        if (node.value != null)
+            this.addProperty(this.bitJson, 'level', (_a = node.value) !== null && _a !== void 0 ? _a : 1, true);
+    }
+    // bitmarkAst -> bits -> bitsValue -> book
+    leaf_book(node, _parent, _route) {
+        if (node.value != null)
+            this.addProperty(this.bitJson, 'book', node.value, true);
+    }
+    //  bitmarkAst -> bits -> bitsValue -> anchor
+    leaf_anchor(node, _parent, _route) {
+        if (node.value != null)
+            this.addProperty(this.bitJson, 'anchor', node.value, true);
+    }
+    //  bitmarkAst -> bits -> bitsValue -> reference
+    leaf_reference(node, _parent, _route) {
+        if (node.value != null)
+            this.addProperty(this.bitJson, 'reference', node.value, true);
+    }
+    //  bitmarkAst -> bits -> bitsValue -> referenceEnd
+    leaf_referenceEnd(node, _parent, _route) {
+        if (node.value != null)
+            this.addProperty(this.bitJson, 'referenceEnd', node.value, true);
+    }
+    //  bitmarkAst -> bits -> bitsValue ->  * -> hint
+    leaf_hint(node, parent, _route) {
+        const hint = node.value;
+        // Ignore hint that is not at the bit level as it are handled elsewhere
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return;
+        this.bitJson.hint = this.toTextAstOrString(hint);
+    }
+    // bitmarkAst -> bits -> bitsValue ->  * -> instruction
+    leaf_instruction(node, parent, _route) {
+        const instruction = node.value;
+        // Ignore instruction that is not at the bit level as it are handled elsewhere
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return;
+        this.bitJson.instruction = this.toTextAstOrString(instruction);
+    }
+    // bitmarkAst -> bits -> bitsValue -> example
+    leaf_example(node, parent, _route) {
+        const example = node.value;
+        // Ignore example that is not at the bit level as it are handled elsewhere
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return;
+        const res = this.toExampleAndIsExample(example);
+        this.bitJson.isExample = res.isExample;
+        this.bitJson.example = res.example;
+    }
+    // bitmarkAst -> bits -> footer -> footerText
+    leaf_footerText(node, _parent, _route) {
+        const footer = node.value;
+        this.bitJson.footer = this.toTextAstOrString(footer);
+    }
+    // bitmarkAst -> bits -> bitsValue -> markup
+    leaf_markup(node, _parent, _route) {
+        const bitmark = node.value;
+        if (bitmark)
+            this.bitWrapperJson.bitmark = bitmark;
+    }
+    // bitmarkAst -> bits -> bitsValue -> parser
+    enter_parser(node, parent, _route) {
+        const parser = node.value;
+        if (parser) {
+            const { version, excessResources: parserExcessResources, warnings, errors } = parser, parserRest = __rest(parser, ["version", "excessResources", "warnings", "errors"]);
+            const bitmarkVersion = `${this.bitmarkVersion}`;
+            // Parse resources to JSON from AST
+            let excessResources;
+            if (Array.isArray(parserExcessResources) && parserExcessResources.length > 0) {
+                excessResources = [];
+                for (const r of parserExcessResources) {
+                    const rJson = this.parseResourceToJson(r);
+                    if (rJson)
+                        excessResources.push(rJson);
+                }
+            }
+            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 }, 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, parent: NodeInfo | undefined, _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;
+        for (const key of PropertyKey.values()) {
+            const validatedKey = PropertyKey.fromValue(key);
+            const meta = (_a = PropertyKey.getMetadata(validatedKey)) !== null && _a !== void 0 ? _a : {};
+            const astKey = meta.astKey ? meta.astKey : key;
+            const funcName = `enter_${astKey}`;
+            // Special cases (handled outside of the automatically generated handlers)
+            if (astKey === PropertyKey.example)
+                continue;
+            if (astKey === PropertyKey.partner)
+                continue;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this[funcName] = (node, parent, _route) => {
+                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
+                if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+                    return;
+                // Convert key as needed
+                let jsonKey = key;
+                if (meta.jsonKey)
+                    jsonKey = meta.jsonKey;
+                // Add the property
+                this.addProperty(this.bitJson, jsonKey, value, meta.isSingle);
+            };
+            // Bind this
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this[funcName] = this[funcName].bind(this);
+        }
+    }
+    // // END NODE HANDLERS
+    //
+    // HELPER FUNCTIONS
+    //
+    createGapJson(gap) {
+        var _a;
+        const data = gap.data;
+        // Create the gap
+        const gapJson = Object.assign(Object.assign(Object.assign({ type: 'gap', solutions: data.solutions }, this.toItemLeadHintInstruction(data)), this.toExampleAndIsExample(data.example)), { isCaseSensitive: (_a = data.isCaseSensitive) !== null && _a !== void 0 ? _a : true });
+        // Remove unwanted properties
+        if (!gapJson.lead)
+            delete gapJson.lead;
+        return gapJson;
+    }
+    createSelectJson(select) {
+        var _a, _b, _c;
+        const data = select.data;
+        // Create the select options
+        const options = [];
+        for (const option of data.options) {
+            const optionJson = Object.assign(Object.assign({ text: option.text, isCorrect: (_a = option.isCorrect) !== null && _a !== void 0 ? _a : false }, this.toItemLeadHintInstruction(option)), this.toExampleAndIsExample(option.example));
+            // Remove unwanted properties
+            if (!optionJson.item)
+                delete optionJson.item;
+            if (!optionJson.lead)
+                delete optionJson.lead;
+            if (!optionJson.instruction)
+                delete optionJson.instruction;
+            if (!optionJson.example)
+                delete optionJson.example;
+            if (!optionJson.isExample)
+                delete optionJson.isExample;
+            if (!optionJson.isCaseSensitive)
+                delete optionJson.isCaseSensitive;
+            options.push(optionJson);
+        }
+        // Create the select
+        const selectJson = Object.assign(Object.assign({ type: 'select', prefix: (_b = data.prefix) !== null && _b !== void 0 ? _b : '', options, postfix: (_c = data.postfix) !== null && _c !== void 0 ? _c : '' }, this.toItemLeadHintInstruction(data)), this.toExampleAndIsExample(data.example));
+        // Remove unwanted properties
+        if (!selectJson.lead)
+            delete selectJson.lead;
+        return selectJson;
+    }
+    createHighlightJson(highlight) {
+        var _a, _b, _c, _d;
+        const data = highlight.data;
+        // Create the highlight options
+        const texts = [];
+        for (const text of data.texts) {
+            const textJson = Object.assign(Object.assign({ text: text.text, isCorrect: (_a = text.isCorrect) !== null && _a !== void 0 ? _a : false, isHighlighted: (_b = text.isHighlighted) !== null && _b !== void 0 ? _b : false }, this.toItemLeadHintInstruction(text)), this.toExampleAndIsExample(text.example));
+            // Remove unwanted properties
+            if (!textJson.item)
+                delete textJson.item;
+            if (!textJson.lead)
+                delete textJson.lead;
+            if (!textJson.hint)
+                delete textJson.hint;
+            if (!textJson.example)
+                delete textJson.example;
+            if (!textJson.isExample)
+                delete textJson.isExample;
+            if (!textJson.isCaseSensitive)
+                delete textJson.isCaseSensitive;
+            texts.push(textJson);
+        }
+        // Create the select
+        const highlightJson = Object.assign(Object.assign({ type: 'highlight', prefix: (_c = data.prefix) !== null && _c !== void 0 ? _c : '', texts, postfix: (_d = data.postfix) !== null && _d !== void 0 ? _d : '' }, this.toItemLeadHintInstruction(data)), this.toExampleAndIsExample(data.example));
+        // Remove unwanted properties
+        if (!highlightJson.lead)
+            delete highlightJson.lead;
+        return highlightJson;
+    }
+    parseResourceToJson(resource) {
+        if (!resource)
+            return undefined;
+        // All resources should now be valid as they are validated in the AST
+        // TODO: remove code below
+        // // Check if a resource has a value, if not, we should not write it (or any of its chained properties)
+        // let valid = false;
+        // if (resource.value) {
+        //   valid = true;
+        // }
+        // // Resource is not valid, return undefined
+        // if (!valid) return undefined;
+        // // Resource is valid, write it.
+        let resourceJson;
+        switch (resource.type) {
+            case ResourceType.image:
+                resourceJson = {
+                    type: ResourceType.image,
+                    image: this.addImageResource(resource),
+                };
+                break;
+            case ResourceType.imageLink:
+                resourceJson = {
+                    type: ResourceType.imageLink,
+                    imageLink: this.addImageLinkResource(resource),
+                };
+                break;
+            case ResourceType.audio:
+                resourceJson = {
+                    type: ResourceType.audio,
+                    audio: this.addAudioResource(resource),
+                };
+                break;
+            case ResourceType.audioEmbed:
+                resourceJson = {
+                    type: ResourceType.audioEmbed,
+                    audioEmbed: this.addAudioEmbedResource(resource),
+                };
+                break;
+            case ResourceType.audioLink:
+                resourceJson = {
+                    type: ResourceType.audioLink,
+                    audioLink: this.addAudioLinkResource(resource),
+                };
+                break;
+            case ResourceType.video:
+                resourceJson = {
+                    type: ResourceType.video,
+                    video: this.addVideoResource(resource),
+                };
+                break;
+            case ResourceType.videoEmbed:
+                resourceJson = {
+                    type: ResourceType.videoEmbed,
+                    videoEmbed: this.addVideoEmbedResource(resource),
+                };
+                resourceJson.videoEmbed = this.addVideoLinkResource(resource);
+                break;
+            case ResourceType.videoLink:
+                resourceJson = {
+                    type: ResourceType.videoLink,
+                    videoLink: this.addVideoLinkResource(resource),
+                };
+                break;
+            case ResourceType.stillImageFilm: {
+                const stillImageFilmResource = resource;
+                // Only write the resource if it has both an image and audio
+                if (stillImageFilmResource.image.value != null && stillImageFilmResource.audio.value != null) {
+                    resourceJson = {
+                        type: ResourceType.stillImageFilm,
+                        image: this.addImageResource(stillImageFilmResource.image),
+                        audio: this.addAudioResource(stillImageFilmResource.audio),
+                    };
+                }
+                break;
+            }
+            case ResourceType.stillImageFilmEmbed:
+                resourceJson = {
+                    type: ResourceType.stillImageFilmEmbed,
+                    stillImageFilmEmbed: this.addStillImageFilmEmbedResource(resource),
+                };
+                break;
+            case ResourceType.stillImageFilmLink:
+                resourceJson = {
+                    type: ResourceType.stillImageFilmLink,
+                    stillImageFilmLink: this.addStillImageFilmLinkResource(resource),
+                };
+                break;
+            case ResourceType.article:
+                resourceJson = {
+                    type: ResourceType.article,
+                    article: this.addArticleResource(resource),
+                };
+                break;
+            case ResourceType.document:
+                resourceJson = {
+                    type: ResourceType.document,
+                    document: this.addDocumentResource(resource),
+                };
+                break;
+            case ResourceType.documentEmbed:
+                resourceJson = {
+                    type: ResourceType.documentEmbed,
+                    documentEmbed: this.addDocumentEmbedResource(resource),
+                };
+                break;
+            case ResourceType.documentLink:
+                resourceJson = {
+                    type: ResourceType.documentLink,
+                    documentLink: this.addDocumentLinkResource(resource),
+                };
+                break;
+            case ResourceType.documentDownload:
+                resourceJson = {
+                    type: ResourceType.documentDownload,
+                    documentDownload: this.addDocumentDownloadResource(resource),
+                };
+                break;
+            case ResourceType.appLink:
+                resourceJson = {
+                    type: ResourceType.appLink,
+                    appLink: this.addAppLinkResource(resource),
+                };
+                break;
+            case ResourceType.websiteLink:
+                resourceJson = {
+                    type: ResourceType.websiteLink,
+                    websiteLink: this.addWebsiteLinkResource(resource),
+                };
+                break;
+            default:
+        }
+        return resourceJson;
+    }
+    addImageResource(resource) {
+        var _a, _b, _c;
+        const resourceJson = {};
+        if (StringUtils.isString(resource)) {
+            const value = resource;
+            resource = {
+                type: ResourceType.image,
+                value,
+                format: UrlUtils.fileExtensionFromUrl(value),
+                provider: UrlUtils.domainFromUrl(value),
+            };
+        }
+        resource = resource; // Keep TS compiler happy
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.src = resource.value;
+        if (resource.src1x != null)
+            resourceJson.src1x = resource.src1x;
+        if (resource.src2x != null)
+            resourceJson.src2x = resource.src2x;
+        if (resource.src3x != null)
+            resourceJson.src3x = resource.src3x;
+        if (resource.src4x != null)
+            resourceJson.src4x = resource.src4x;
+        resourceJson.width = (_a = resource.width) !== null && _a !== void 0 ? _a : null;
+        resourceJson.height = (_b = resource.height) !== null && _b !== void 0 ? _b : null;
+        resourceJson.alt = (_c = resource.alt) !== null && _c !== void 0 ? _c : '';
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addImageLinkResource(resource) {
+        var _a, _b, _c;
+        const resourceJson = {};
+        if (StringUtils.isString(resource)) {
+            const value = resource;
+            resource = {
+                type: ResourceType.imageLink,
+                value,
+                format: UrlUtils.fileExtensionFromUrl(value),
+                provider: UrlUtils.domainFromUrl(value),
+            };
+        }
+        resource = resource; // Keep TS compiler happy
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.url = resource.value;
+        if (resource.src1x != null)
+            resourceJson.src1x = resource.src1x;
+        if (resource.src2x != null)
+            resourceJson.src2x = resource.src2x;
+        if (resource.src3x != null)
+            resourceJson.src3x = resource.src3x;
+        if (resource.src4x != null)
+            resourceJson.src4x = resource.src4x;
+        resourceJson.width = (_a = resource.width) !== null && _a !== void 0 ? _a : null;
+        resourceJson.height = (_b = resource.height) !== null && _b !== void 0 ? _b : null;
+        resourceJson.alt = (_c = resource.alt) !== null && _c !== void 0 ? _c : '';
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addAudioResource(resource) {
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.src = resource.value;
+        if (resource.duration != null)
+            resourceJson.duration = resource.duration;
+        if (resource.mute != null)
+            resourceJson.mute = resource.mute;
+        if (resource.autoplay != null)
+            resourceJson.autoplay = resource.autoplay;
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addAudioEmbedResource(resource) {
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.src = resource.value;
+        if (resource.duration != null)
+            resourceJson.duration = resource.duration;
+        if (resource.mute != null)
+            resourceJson.mute = resource.mute;
+        if (resource.autoplay != null)
+            resourceJson.autoplay = resource.autoplay;
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addAudioLinkResource(resource) {
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.url = resource.value;
+        if (resource.duration != null)
+            resourceJson.duration = resource.duration;
+        if (resource.mute != null)
+            resourceJson.mute = resource.mute;
+        if (resource.autoplay != null)
+            resourceJson.autoplay = resource.autoplay;
+        this.addGenericResourceProperties(resource, resourceJson, true);
+        return resourceJson;
+    }
+    addVideoResource(resource) {
+        var _a, _b;
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.src = resource.value;
+        resourceJson.width = (_a = resource.width) !== null && _a !== void 0 ? _a : null;
+        resourceJson.height = (_b = resource.height) !== null && _b !== void 0 ? _b : null;
+        if (resource.duration != null)
+            resourceJson.duration = resource.duration;
+        if (resource.mute != null)
+            resourceJson.mute = resource.mute;
+        if (resource.autoplay != null)
+            resourceJson.autoplay = resource.autoplay;
+        if (resource.allowSubtitles != null)
+            resourceJson.allowSubtitles = resource.allowSubtitles;
+        if (resource.showSubtitles != null)
+            resourceJson.showSubtitles = resource.showSubtitles;
+        if (resource.alt != null)
+            resourceJson.alt = resource.alt;
+        if (resource.posterImage != null)
+            resourceJson.posterImage = this.addImageResource(resource.posterImage);
+        if (resource.thumbnails != null && resource.thumbnails.length > 0) {
+            resourceJson.thumbnails = [];
+            for (const thumbnail of resource.thumbnails) {
+                resourceJson.thumbnails.push(this.addImageResource(thumbnail));
+            }
+        }
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addVideoEmbedResource(resource) {
+        var _a, _b;
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.src = resource.value;
+        resourceJson.width = (_a = resource.width) !== null && _a !== void 0 ? _a : null;
+        resourceJson.height = (_b = resource.height) !== null && _b !== void 0 ? _b : null;
+        if (resource.duration != null)
+            resourceJson.duration = resource.duration;
+        if (resource.mute != null)
+            resourceJson.mute = resource.mute;
+        if (resource.autoplay != null)
+            resourceJson.autoplay = resource.autoplay;
+        if (resource.allowSubtitles != null)
+            resourceJson.allowSubtitles = resource.allowSubtitles;
+        if (resource.showSubtitles != null)
+            resourceJson.showSubtitles = resource.showSubtitles;
+        if (resource.alt != null)
+            resourceJson.alt = resource.alt;
+        if (resource.posterImage != null)
+            resourceJson.posterImage = this.addImageResource(resource.posterImage);
+        if (resource.thumbnails != null && resource.thumbnails.length > 0) {
+            resourceJson.thumbnails = [];
+            for (const thumbnail of resource.thumbnails) {
+                resourceJson.thumbnails.push(this.addImageResource(thumbnail));
+            }
+        }
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addVideoLinkResource(resource) {
+        var _a, _b;
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.url = resource.value;
+        resourceJson.width = (_a = resource.width) !== null && _a !== void 0 ? _a : null;
+        resourceJson.height = (_b = resource.height) !== null && _b !== void 0 ? _b : null;
+        if (resource.duration != null)
+            resourceJson.duration = resource.duration;
+        if (resource.mute != null)
+            resourceJson.mute = resource.mute;
+        if (resource.autoplay != null)
+            resourceJson.autoplay = resource.autoplay;
+        if (resource.allowSubtitles != null)
+            resourceJson.allowSubtitles = resource.allowSubtitles;
+        if (resource.showSubtitles != null)
+            resourceJson.showSubtitles = resource.showSubtitles;
+        if (resource.alt != null)
+            resourceJson.alt = resource.alt;
+        if (resource.posterImage != null)
+            resourceJson.posterImage = this.addImageResource(resource.posterImage);
+        if (resource.thumbnails != null && resource.thumbnails.length > 0) {
+            resourceJson.thumbnails = [];
+            for (const thumbnail of resource.thumbnails) {
+                resourceJson.thumbnails.push(this.addImageResource(thumbnail));
+            }
+        }
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addStillImageFilmEmbedResource(resource) {
+        var _a, _b;
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.url = resource.value;
+        resourceJson.width = (_a = resource.width) !== null && _a !== void 0 ? _a : null;
+        resourceJson.height = (_b = resource.height) !== null && _b !== void 0 ? _b : null;
+        if (resource.duration != null)
+            resourceJson.duration = resource.duration;
+        if (resource.mute != null)
+            resourceJson.mute = resource.mute;
+        if (resource.autoplay != null)
+            resourceJson.autoplay = resource.autoplay;
+        if (resource.allowSubtitles != null)
+            resourceJson.allowSubtitles = resource.allowSubtitles;
+        if (resource.showSubtitles != null)
+            resourceJson.showSubtitles = resource.showSubtitles;
+        if (resource.alt != null)
+            resourceJson.alt = resource.alt;
+        if (resource.posterImage != null)
+            resourceJson.posterImage = this.addImageResource(resource.posterImage);
+        if (resource.thumbnails != null && resource.thumbnails.length > 0) {
+            resourceJson.thumbnails = [];
+            for (const thumbnail of resource.thumbnails) {
+                resourceJson.thumbnails.push(this.addImageResource(thumbnail));
+            }
+        }
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addStillImageFilmLinkResource(resource) {
+        var _a, _b;
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.url = resource.value;
+        resourceJson.width = (_a = resource.width) !== null && _a !== void 0 ? _a : null;
+        resourceJson.height = (_b = resource.height) !== null && _b !== void 0 ? _b : null;
+        if (resource.duration != null)
+            resourceJson.duration = resource.duration;
+        if (resource.mute != null)
+            resourceJson.mute = resource.mute;
+        if (resource.autoplay != null)
+            resourceJson.autoplay = resource.autoplay;
+        if (resource.allowSubtitles != null)
+            resourceJson.allowSubtitles = resource.allowSubtitles;
+        if (resource.showSubtitles != null)
+            resourceJson.showSubtitles = resource.showSubtitles;
+        if (resource.alt != null)
+            resourceJson.alt = resource.alt;
+        if (resource.posterImage != null)
+            resourceJson.posterImage = this.addImageResource(resource.posterImage);
+        if (resource.thumbnails != null && resource.thumbnails.length > 0) {
+            resourceJson.thumbnails = [];
+            for (const thumbnail of resource.thumbnails) {
+                resourceJson.thumbnails.push(this.addImageResource(thumbnail));
+            }
+        }
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addArticleResource(resource) {
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.body = resource.value;
+        // if (resource.href != null) resourceJson.href = resource.href; // It is never used (and doesn't exist in the AST model)
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addDocumentResource(resource) {
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.url = resource.value;
+        // if (resource.href != null) resourceJson.href = resource.href; // It is never used (and doesn't exist in the AST model)
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addDocumentEmbedResource(resource) {
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.url = resource.value;
+        // if (resource.href != null) resourceJson.href = resource.href; // It is never used (and doesn't exist in the AST model)
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addDocumentLinkResource(resource) {
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.url = resource.value;
+        // if (resource.href != null) resourceJson.href = resource.href; // It is never used (and doesn't exist in the AST model)
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addDocumentDownloadResource(resource) {
+        const resourceJson = {};
+        if (resource.format != null)
+            resourceJson.format = resource.format;
+        if (resource.provider != null)
+            resourceJson.provider = resource.provider;
+        if (resource.value != null)
+            resourceJson.url = resource.value;
+        // if (resource.href != null) resourceJson.href = resource.href; // It is never used (and doesn't exist in the AST model)
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addAppLinkResource(resource) {
+        const resourceJson = {};
+        // if (resource.format != null) resourceJson.format = resource.format;
+        if (resource.value != null)
+            resourceJson.url = resource.value;
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addWebsiteLinkResource(resource) {
+        const resourceJson = {};
+        // if (resource.format != null) resourceJson.format = resource.format;
+        if (resource.value != null)
+            resourceJson.url = resource.value;
+        if (resource.siteName != null)
+            resourceJson.siteName = resource.siteName;
+        this.addGenericResourceProperties(resource, resourceJson);
+        return resourceJson;
+    }
+    addGenericResourceProperties(resource, resourceJson, noDefaults) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (noDefaults) {
+            if (resource.license != null)
+                resourceJson.license = (_a = resource.license) !== null && _a !== void 0 ? _a : '';
+            if (resource.copyright != null)
+                resourceJson.copyright = (_b = resource.copyright) !== null && _b !== void 0 ? _b : '';
+            if (resource.provider != null)
+                resourceJson.provider = resource.provider;
+            if (resource.showInIndex != null)
+                resourceJson.showInIndex = (_c = resource.showInIndex) !== null && _c !== void 0 ? _c : false;
+            if (resource.caption != null)
+                resourceJson.caption = this.toTextAstOrString((_d = resource.caption) !== null && _d !== void 0 ? _d : '');
+        }
+        else {
+            resourceJson.license = (_e = resource.license) !== null && _e !== void 0 ? _e : '';
+            resourceJson.copyright = (_f = resource.copyright) !== null && _f !== void 0 ? _f : '';
+            if (resource.provider != null)
+                resourceJson.provider = resource.provider;
+            resourceJson.showInIndex = (_g = resource.showInIndex) !== null && _g !== void 0 ? _g : false;
+            resourceJson.caption = this.toTextAstOrString((_h = resource.caption) !== null && _h !== void 0 ? _h : '');
+        }
+        return resourceJson;
+    }
+    toItemLeadHintInstruction(item) {
+        var _a, _b, _c, _d, _e, _f;
+        return {
+            item: this.toTextAstOrString((_b = (_a = item.itemLead) === null || _a === void 0 ? void 0 : _a.item) !== null && _b !== void 0 ? _b : ''),
+            lead: this.toTextAstOrString((_d = (_c = item.itemLead) === null || _c === void 0 ? void 0 : _c.lead) !== null && _d !== void 0 ? _d : ''),
+            hint: this.toTextAstOrString((_e = item.hint) !== null && _e !== void 0 ? _e : ''),
+            instruction: this.toTextAstOrString((_f = item.instruction) !== null && _f !== void 0 ? _f : ''),
+        };
+    }
+    toExampleAndIsExample(exampleIn) {
+        let isExample = false;
+        let example = this.textDefault;
+        if (exampleIn === true) {
+            isExample = true;
+        }
+        else if (exampleIn) {
+            isExample = true;
+            example = this.toTextAstOrString(exampleIn);
+        }
+        return {
+            isExample,
+            example,
+        };
+    }
+    addProperty(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    target, name, values, singleWithoutArray) {
+        if (values !== undefined) {
+            if (!Array.isArray(values))
+                values = [values];
+            if (Array.isArray(values) && values.length > 0) {
+                if (singleWithoutArray && values.length >= 1) {
+                    target[name] = values[values.length - 1];
+                }
+                else {
+                    target[name] = values;
+                }
+            }
+        }
+    }
+    /**
+     * Get the bit type from any node
+     *
+     * @param route the route to the node
+     * @returns the bit type
+     */
+    getBitType(route) {
+        for (const node of route) {
+            if (node.key === NodeType.bitsValue) {
+                const n = node.value;
+                return BitType.fromValue(n === null || n === void 0 ? void 0 : n.bitType);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get the text format from any node
+     *
+     * @param route the route to the node
+     * @returns the text format
+     */
+    getTextFormat(route) {
+        for (const node of route) {
+            if (node.key === NodeType.bitsValue) {
+                const n = node.value;
+                return TextFormat.fromValue(n === null || n === void 0 ? void 0 : n.textFormat);
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Convert parse a string to TextAst if required, otherwise just return the string as is.
+     * @param text
+     * @returns
+     */
+    toTextAstOrString(text, format = TextFormat.bitmarkMinusMinus) {
+        if (!text)
+            undefined;
+        if (this.options.textAsPlainText) {
+            return text;
+        }
+        // Use the text parser to parse the text
+        const textAst = this.textParser.toAst(text, {
+            textFormat: format,
+        });
+        return textAst;
+    }
+    /**
+     * Walk the body AST to find the placeholder and replace it with the body bit.
+     *
+     * @param bodyAst the body AST
+     * @param bodyBitJson the body bit json to insert at the placeholder position
+     * @param index the index of the placeholder to replace
+     */
+    replacePlaceholderWithBodyBit(bodyAst, bodyBitJson, index) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const walkRecursive = (node, parent, parentKey) => {
+            if (Array.isArray(node)) {
+                // Walk the array of nodes
+                for (let i = 0; i < node.length; i++) {
+                    const child = node[i];
+                    const done = walkRecursive(child, node, i);
+                    if (done)
+                        return true;
+                }
+            }
+            else {
+                if (node.type === 'bit' && node.index === index) {
+                    // Found the placeholder, replace it with the body bit
+                    parent[parentKey] = bodyBitJson;
+                    return true;
+                }
+                if (node.content) {
+                    // Walk the child content
+                    const done = walkRecursive(node.content, node, 'content');
+                    if (done)
+                        return true;
+                }
+            }
+            return false;
+        };
+        walkRecursive(bodyAst, null, null);
+    }
+    //
+    // 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 bitJson = {
+            type: bit.bitType,
+            format: bit.textFormat,
+            // Properties
+            id: undefined,
+            externalId: undefined,
+            spaceId: undefined,
+            padletId: undefined,
+            AIGenerated: undefined,
+            releaseVersion: undefined,
+            book: undefined,
+            ageRange: undefined,
+            language: undefined,
+            computerLanguage: undefined,
+            subtype: undefined,
+            coverImage: undefined,
+            publisher: undefined,
+            publications: undefined,
+            author: undefined,
+            subject: undefined,
+            date: undefined,
+            location: undefined,
+            theme: undefined,
+            kind: undefined,
+            action: undefined,
+            thumbImage: undefined,
+            focusX: undefined,
+            focusY: undefined,
+            deeplink: undefined,
+            externalLink: undefined,
+            externalLinkText: undefined,
+            videoCallLink: undefined,
+            duration: undefined,
+            list: undefined,
+            textReference: undefined,
+            isTracked: undefined,
+            isInfoOnly: undefined,
+            labelTrue: undefined,
+            labelFalse: undefined,
+            quotedPerson: undefined,
+            partialAnswer: undefined,
+            // Book data
+            title: undefined,
+            subtitle: undefined,
+            level: undefined,
+            toc: undefined,
+            progress: undefined,
+            anchor: undefined,
+            reference: undefined,
+            referenceEnd: undefined,
+            // Item, Lead, Hint, Instruction
+            item: undefined,
+            lead: undefined,
+            hint: undefined,
+            instruction: undefined,
+            // Example
+            example: undefined,
+            isExample: undefined,
+            // Partner .conversion-xxx only
+            partner: undefined,
+            // Extra Properties
+            extraProperties: undefined,
+            // Body
+            body: undefined,
+            // Resource
+            resource: undefined,
+            // Children
+            statement: undefined,
+            isCorrect: undefined,
+            sampleSolution: undefined,
+            elements: undefined,
+            statements: undefined,
+            responses: undefined,
+            quizzes: undefined,
+            heading: undefined,
+            pairs: undefined,
+            matrix: undefined,
+            choices: undefined,
+            questions: undefined,
+            // Placeholders
+            placeholders: undefined,
+            // Footer
+            footer: undefined,
+        };
+        // Add the resource template if there should be a resource (indicated by resourceType) but there is none defined.
+        // if (bit.resourceType && !bitJson.resource) {
+        //   const jsonKey = ResourceType.keyFromValue(bit.resourceType);
+        //   bitJson.resource = {
+        //     type: bit.resourceType,
+        //   } as ResourceJson;
+        //   // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        //   if (jsonKey) (bitJson.resource as any)[jsonKey] = {};
+        // }
+        return bitJson;
+    }
+    /**
+     * Remove wanted properties from bit json object.
+     * - This function defines the defaults for properties in the json.
+     *
+     * @param bit
+     * @returns
+     */
+    cleanAndSetDefaultsForBitJson(bitJson) {
+        const plainText = this.options.textAsPlainText;
+        // 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 in the antlr parser are a bit random sometimes?
+        switch (bitJson.type) {
+            case BitType._error:
+                break;
+            case BitType.article:
+            case BitType.highlightText:
+            case BitType.message:
+            case BitType.sampleSolution:
+            case BitType.page:
+            case BitType.statement:
+                if (bitJson.body == null)
+                    bitJson.body = this.bodyDefault;
+                break;
+            default: // Most bits have these defaults, but there are special cases (not sure if that is by error or design)
+                if (bitJson.item == null)
+                    bitJson.item = this.textDefault;
+                if (bitJson.hint == null)
+                    bitJson.hint = this.textDefault;
+                if (bitJson.isExample == null)
+                    bitJson.isExample = false;
+                if (bitJson.example == null)
+                    bitJson.example = this.textDefault;
+                if (bitJson.body == null)
+                    bitJson.body = this.bodyDefault;
+                break;
+            case BitType.multipleChoice1:
+            case BitType.multipleResponse1:
+            case BitType.sequence:
+                if (bitJson.item == null)
+                    bitJson.item = this.textDefault;
+                if (bitJson.hint == null)
+                    bitJson.hint = this.textDefault;
+                if (bitJson.instruction == null)
+                    bitJson.instruction = this.textDefault;
+                if (bitJson.isExample == null)
+                    bitJson.isExample = false;
+                if (bitJson.example == null)
+                    bitJson.example = this.textDefault;
+                if (bitJson.body == null)
+                    bitJson.body = this.bodyDefault;
+                break;
+            case BitType.essay:
+                if (bitJson.item == null)
+                    bitJson.item = this.textDefault;
+                if (bitJson.hint == null)
+                    bitJson.hint = this.textDefault;
+                if (bitJson.instruction == null)
+                    bitJson.instruction = this.textDefault;
+                if (bitJson.isExample == null)
+                    bitJson.isExample = false;
+                if (bitJson.example == null)
+                    bitJson.example = this.textDefault;
+                if (bitJson.body == null)
+                    bitJson.body = this.bodyDefault;
+                if (bitJson.partialAnswer == null)
+                    bitJson.partialAnswer = '';
+                // if (bitJson.sampleSolution == null) bitJson.sampleSolution = '';
+                break;
+            case BitType.trueFalse1:
+                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.isExample == null)
+                    bitJson.isExample = false;
+                if (bitJson.isCorrect == null)
+                    bitJson.isCorrect = false;
+                if (bitJson.body == null)
+                    bitJson.body = this.bodyDefault;
+                break;
+            case BitType.trueFalse:
+                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.labelFalse == null)
+                    bitJson.labelFalse = '';
+                if (bitJson.labelTrue == null)
+                    bitJson.labelTrue = '';
+                if (bitJson.body == null)
+                    bitJson.body = this.bodyDefault;
+                break;
+            case BitType.chapter:
+                if (bitJson.item == null)
+                    bitJson.item = this.textDefault;
+                if (bitJson.hint == null)
+                    bitJson.hint = this.textDefault;
+                if (bitJson.isExample == null)
+                    bitJson.isExample = false;
+                if (bitJson.example == null)
+                    bitJson.example = this.textDefault;
+                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;
+                break;
+            case BitType.multipleChoice:
+            case BitType.multipleResponse:
+                if (bitJson.item == null)
+                    bitJson.item = this.textDefault;
+                if (bitJson.hint == null)
+                    bitJson.hint = this.textDefault;
+                if (bitJson.instruction == null)
+                    bitJson.instruction = this.textDefault;
+                if (bitJson.body == null)
+                    bitJson.body = this.bodyDefault;
+                if (bitJson.footer == null)
+                    bitJson.footer = this.textDefault;
+                break;
+            case BitType.interview:
+            case BitType.interviewInstructionGrouped:
+                if (bitJson.item == null)
+                    bitJson.item = this.textDefault;
+                if (bitJson.hint == null)
+                    bitJson.hint = this.textDefault;
+                if (bitJson.instruction == null)
+                    bitJson.instruction = this.textDefault;
+                if (bitJson.body == null)
+                    bitJson.body = this.bodyDefault;
+                if (bitJson.footer == null)
+                    bitJson.footer = this.textDefault;
+                if (bitJson.questions == null)
+                    bitJson.questions = [];
+                break;
+            case BitType.match:
+            case BitType.matchReverse:
+            case BitType.matchSolutionGrouped:
+            case BitType.matchAll:
+            case BitType.matchAllReverse:
+                if (bitJson.item == null)
+                    bitJson.item = this.textDefault;
+                if (bitJson.heading == null)
+                    bitJson.heading = {};
+                if (bitJson.body == null)
+                    bitJson.body = this.bodyDefault;
+                break;
+            case BitType.matchMatrix:
+                if (bitJson.item == null)
+                    bitJson.item = this.textDefault;
+                if (bitJson.body == null)
+                    bitJson.body = this.bodyDefault;
+                break;
+            case BitType.learningPathBook:
+            case BitType.learningPathBotTraining:
+            case BitType.learningPathClassroomEvent:
+            case BitType.learningPathClassroomTraining:
+            case BitType.learningPathClosing:
+            case BitType.learningPathExternalLink:
+            case BitType.learningPathFeedback:
+            case BitType.learningPathLearningGoal:
+            case BitType.learningPathLti:
+            case BitType.learningPathSign:
+            case BitType.learningPathStep:
+            case BitType.learningPathVideoCall:
+                if (bitJson.item == null)
+                    bitJson.item = this.textDefault;
+                if (bitJson.hint == null)
+                    bitJson.hint = this.textDefault;
+                if (bitJson.isExample == null)
+                    bitJson.isExample = false;
+                if (bitJson.example == null)
+                    bitJson.example = this.textDefault;
+                if (bitJson.isTracked == null)
+                    bitJson.isTracked = true;
+                if (bitJson.isInfoOnly == null)
+                    bitJson.isInfoOnly = false;
+                if (bitJson.body == null)
+                    bitJson.body = this.bodyDefault;
+                break;
+            case BitType.articleAi:
+            case BitType.noteAi:
+            case BitType.summaryAi:
+                if (bitJson.AIGenerated == null)
+                    bitJson.AIGenerated = true;
+                if (bitJson.item == null)
+                    bitJson.item = this.textDefault;
+                if (bitJson.hint == null)
+                    bitJson.hint = this.textDefault;
+                if (bitJson.isExample == null)
+                    bitJson.isExample = false;
+                if (bitJson.example == null)
+                    bitJson.example = this.textDefault;
+                if (bitJson.body == null)
+                    bitJson.body = this.bodyDefault;
+                break;
+        }
+        // Remove unwanted properties
+        // Properties
+        if (bitJson.id == null)
+            delete bitJson.id;
+        if (bitJson.externalId == null)
+            delete bitJson.externalId;
+        if (bitJson.spaceId == null)
+            delete bitJson.spaceId;
+        if (bitJson.padletId == null)
+            delete bitJson.padletId;
+        if (bitJson.AIGenerated == null)
+            delete bitJson.AIGenerated;
+        if (bitJson.releaseVersion == null)
+            delete bitJson.releaseVersion;
+        if (bitJson.book == null)
+            delete bitJson.book;
+        if (bitJson.ageRange == null)
+            delete bitJson.ageRange;
+        if (bitJson.language == null)
+            delete bitJson.language;
+        if (bitJson.computerLanguage == null)
+            delete bitJson.computerLanguage;
+        if (bitJson.subtype == null)
+            delete bitJson.subtype;
+        if (bitJson.coverImage == null)
+            delete bitJson.coverImage;
+        if (bitJson.publisher == null)
+            delete bitJson.publisher;
+        if (bitJson.publications == null)
+            delete bitJson.publications;
+        if (bitJson.author == null)
+            delete bitJson.author;
+        if (bitJson.subject == null)
+            delete bitJson.subject;
+        if (bitJson.date == null)
+            delete bitJson.date;
+        if (bitJson.location == null)
+            delete bitJson.location;
+        if (bitJson.theme == null)
+            delete bitJson.theme;
+        if (bitJson.kind == null)
+            delete bitJson.kind;
+        if (bitJson.action == null)
+            delete bitJson.action;
+        if (bitJson.thumbImage == null)
+            delete bitJson.thumbImage;
+        if (bitJson.deeplink == null)
+            delete bitJson.deeplink;
+        if (bitJson.externalLink == null)
+            delete bitJson.externalLink;
+        if (bitJson.externalLinkText == null)
+            delete bitJson.externalLinkText;
+        if (bitJson.videoCallLink == null)
+            delete bitJson.videoCallLink;
+        if (bitJson.duration == null)
+            delete bitJson.duration;
+        if (bitJson.list == null)
+            delete bitJson.list;
+        if (bitJson.textReference == null)
+            delete bitJson.textReference;
+        if (bitJson.isTracked == null)
+            delete bitJson.isTracked;
+        if (bitJson.isInfoOnly == null)
+            delete bitJson.isInfoOnly;
+        if (bitJson.labelTrue == null)
+            delete bitJson.labelTrue;
+        if (bitJson.labelFalse == null)
+            delete bitJson.labelFalse;
+        if (bitJson.quotedPerson == null)
+            delete bitJson.quotedPerson;
+        // Book data
+        if (bitJson.title == null)
+            delete bitJson.title;
+        if (bitJson.subtitle == null)
+            delete bitJson.subtitle;
+        if (bitJson.level == null)
+            delete bitJson.level;
+        if (bitJson.toc == null)
+            delete bitJson.toc;
+        if (bitJson.progress == null)
+            delete bitJson.progress;
+        if (bitJson.anchor == null)
+            delete bitJson.anchor;
+        if (bitJson.reference == null)
+            delete bitJson.reference;
+        if (bitJson.referenceEnd == null)
+            delete bitJson.referenceEnd;
+        // Item, Lead, Hint, Instruction
+        if (bitJson.item == null)
+            delete bitJson.item;
+        if (bitJson.lead == null)
+            delete bitJson.lead;
+        if (bitJson.hint == null)
+            delete bitJson.hint;
+        if (bitJson.instruction == null)
+            delete bitJson.instruction;
+        // Example
+        if (bitJson.example == null)
+            delete bitJson.example;
+        if (bitJson.isExample == null)
+            delete bitJson.isExample;
+        // Extra Properties
+        if (bitJson.extraProperties == null)
+            delete bitJson.extraProperties;
+        // Body
+        if (bitJson.body == null)
+            delete bitJson.body;
+        // Placeholders
+        if (bitJson.placeholders == null || Object.keys(bitJson.placeholders).length === 0)
+            delete bitJson.placeholders;
+        // Resource
+        if (bitJson.resource == null)
+            delete bitJson.resource;
+        // Children
+        if (bitJson.statement == null)
+            delete bitJson.statement;
+        if (bitJson.isCorrect == null)
+            delete bitJson.isCorrect;
+        if (bitJson.sampleSolution == null)
+            delete bitJson.sampleSolution;
+        if (bitJson.partialAnswer == null)
+            delete bitJson.partialAnswer;
+        if (bitJson.elements == null)
+            delete bitJson.elements;
+        if (bitJson.statements == null)
+            delete bitJson.statements;
+        if (bitJson.responses == null)
+            delete bitJson.responses;
+        if (bitJson.quizzes == null)
+            delete bitJson.quizzes;
+        if (bitJson.heading == null)
+            delete bitJson.heading;
+        if (bitJson.pairs == null)
+            delete bitJson.pairs;
+        if (bitJson.matrix == null)
+            delete bitJson.matrix;
+        if (bitJson.choices == null)
+            delete bitJson.choices;
+        if (bitJson.questions == null)
+            delete bitJson.questions;
+        // Placeholders
+        if (!plainText || bitJson.placeholders == null)
+            delete bitJson.placeholders;
+        // Footer
+        if (bitJson.footer == null)
+            delete bitJson.footer;
+        return bitJson;
+    }
+    //
+    // 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