@gmb/bitmark-parser-generator 1.0.11

package/dist/cjs/generator/bitmark/BitmarkGenerator.js

@@ -0,0 +1,1202 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitmarkGenerator = void 0;
+const Ast_1 = require("../../ast/Ast");
+const NodeType_1 = require("../../model/ast/NodeType");
+const BitType_1 = require("../../model/enum/BitType");
+const BitmarkVersion_1 = require("../../model/enum/BitmarkVersion");
+const CardSetVersion_1 = require("../../model/enum/CardSetVersion");
+const PropertyKey_1 = require("../../model/enum/PropertyKey");
+const ResourceType_1 = require("../../model/enum/ResourceType");
+const TextFormat_1 = require("../../model/enum/TextFormat");
+const DEFAULT_OPTIONS = {
+    debugGenerationInline: false,
+};
+/**
+ * Generate bitmark markup from a bitmark AST
+ */
+class BitmarkGenerator {
+    /**
+     * Generate bitmark markup from a bitmark AST
+     *
+     * @param writer - destination for the output
+     * @param bitmarkVersion - The version of bitmark to output.
+     * If not specified, the version will default to 3.
+     *
+     * Specifying the version will set defaults for other options.
+     * - Bitmark v2:
+     *   - cardSetVersion: 1
+     * - Bitmark v3:
+     *   - cardSetVersion: 2
+     *
+     * @param options - bitmark generation options
+     */
+    constructor(writer, options) {
+        var _a;
+        this.ast = new Ast_1.Ast();
+        // State
+        this.skipNLBetweenBitsValue = false;
+        // Debug
+        this.printed = false;
+        this.bitmarkVersion = (_a = BitmarkVersion_1.BitmarkVersion.fromValue(options === null || options === void 0 ? void 0 : options.bitmarkVersion)) !== null && _a !== void 0 ? _a : BitmarkVersion_1.DEFAULT_BITMARK_VERSION;
+        this.options = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options === null || options === void 0 ? void 0 : options.bitmarkOptions);
+        // Set defaults according to bitmark version
+        if (this.bitmarkVersion === BitmarkVersion_1.BitmarkVersion.v2) {
+            if (this.options.cardSetVersion === undefined) {
+                this.options.cardSetVersion = CardSetVersion_1.CardSetVersion.v1;
+            }
+        }
+        else {
+            if (this.options.cardSetVersion === undefined) {
+                this.options.cardSetVersion = CardSetVersion_1.CardSetVersion.v2;
+            }
+        }
+        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);
+            // Ensure a blank line at end of file
+            this.writeLine();
+            // 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.skipNLBetweenBitsValue = false;
+        this.printed = false;
+    }
+    walkAndWrite(ast) {
+        // Walk the bitmark AST
+        this.ast.walk(ast, NodeType_1.NodeType.bitmarkAst, this, undefined);
+        // Ensure a blank line at end of file
+        this.writeLine();
+    }
+    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
+    // bitmarkAst -> bits
+    between_bits(_node, _left, _right, _parent, _route) {
+        this.writeNL();
+        this.writeNL();
+        this.writeNL();
+    }
+    // bitmarkAst -> bits -> bitsValue
+    enter_bitsValue(node, _parent, _route) {
+        var _a, _b;
+        const bit = node.value;
+        this.writeOPD();
+        this.writeString(bit.bitType);
+        if (bit.textFormat) {
+            const write = this.isWriteTextFormat(bit.textFormat);
+            if (write) {
+                this.writeColon();
+                this.writeString(bit.textFormat);
+            }
+        }
+        // Write the resource type if there is a resource (unless the bit itself is the resource)
+        const resourceType = (_a = bit.resource) === null || _a === void 0 ? void 0 : _a.type;
+        if (resourceType && resourceType !== bit.bitType) {
+            this.writeAmpersand();
+            this.writeString((_b = bit.resource) === null || _b === void 0 ? void 0 : _b.type);
+        }
+        this.writeCL();
+        this.writeNL();
+    }
+    between_bitsValue(node, left, _right, _parent, _route) {
+        // The following keys are combined with other keys so don't need newlines
+        const noNlKeys = [
+            NodeType_1.NodeType.bitType,
+            NodeType_1.NodeType.textFormat,
+            NodeType_1.NodeType.level,
+            NodeType_1.NodeType.progress,
+            NodeType_1.NodeType.toc,
+            NodeType_1.NodeType.referenceEnd,
+            NodeType_1.NodeType.labelFalse,
+        ];
+        const bit = node.value;
+        if (bit.book) {
+            // If the book node exists, remove the newline caused by reference as it will be bound to book
+            noNlKeys.push(NodeType_1.NodeType.reference);
+        }
+        // Check if a no newline key is to the left in this 'between' callback
+        const noNl = (() => {
+            if (this.skipNLBetweenBitsValue) {
+                this.skipNLBetweenBitsValue = false;
+                return true;
+            }
+            for (const keyType of noNlKeys) {
+                if (left.key === keyType /*|| right.key === keyType*/)
+                    return true;
+            }
+            return false;
+        })();
+        if (!noNl) {
+            this.writeNL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> labelTrue / labelFalse
+    enter_labelTrue(node, parent, _route) {
+        const value = 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_1.NodeType.bitsValue)
+            return;
+        const bit = parent === null || parent === void 0 ? void 0 : parent.value;
+        if (bit) {
+            this.writeProperty(PropertyKey_1.PropertyKey.labelTrue, value, true);
+            this.writeProperty(PropertyKey_1.PropertyKey.labelFalse, bit.labelFalse, true);
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> partner
+    enter_partner(node, parent, _route) {
+        const partner = node.value;
+        // Ignore values that are not at the bit level as they might be handled elsewhere
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType_1.NodeType.bitsValue)
+            return;
+        const { name, avatarImage } = partner;
+        this.writeProperty('partner', name, true);
+        if (avatarImage) {
+            this.writeResource(avatarImage);
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> sampleSolution
+    enter_sampleSolution(node, _parent, _route) {
+        this.writeProperty('sampleSolution', node.value);
+    }
+    // bitmarkAst -> bits -> bitsValue -> itemLead
+    enter_itemLead(node, _parent, _route) {
+        const itemLead = node.value;
+        if (itemLead && (itemLead.item || itemLead.lead)) {
+            // Always write item if item or lead is set
+            this.writeOPC();
+            this.writeString(itemLead.item || '');
+            this.writeCL();
+            if (itemLead.lead) {
+                this.writeOPC();
+                this.writeString(itemLead.lead);
+                this.writeCL();
+            }
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> body
+    enter_body(node, _parent, _route) {
+        // always write a NL before the body content if there is any?
+        const body = node.value;
+        if (body.bodyParts.length > 0) {
+            this.writeNL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> body -> bodyValue -> gap
+    // bitmarkAst -> bits -> bitsValue -> body -> bodyValue -> gap -> solutions
+    enter_solutions(node, _parent, _route) {
+        const solutions = node.value;
+        if (solutions && solutions.length === 0) {
+            // If there are no solutions, we need to write the special cloze gap [_] to indicate this
+            this.writeOPU();
+            this.writeCL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> body -> bodyValue -> gap -> solutions
+    // bitmarkAst -> bits -> bitsValue -> body -> bodyValue -> select
+    // bitmarkAst -> bits -> bitsValue -> body -> bodyValue -> select -> options
+    // bitmarkAst -> bits -> bitsValue -> body -> bodyValue -> select -> options -> optionsValue
+    enter_optionsValue(node, _parent, _route) {
+        const selectOption = node.value;
+        if (selectOption.isCorrect) {
+            this.writeOPP();
+        }
+        else {
+            this.writeOPM();
+        }
+        this.write(selectOption.text);
+        this.writeCL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> body -> bodyValue -> highlight
+    // bitmarkAst -> bits -> bitsValue -> body -> bodyValue -> highlight -> texts
+    // bitmarkAst -> bits -> bitsValue -> body -> bodyValue -> highlight -> texts -> textsValue
+    enter_textsValue(node, _parent, _route) {
+        const highlightText = node.value;
+        if (highlightText.isCorrect) {
+            this.writeOPP();
+        }
+        else {
+            this.writeOPM();
+        }
+        this.write(highlightText.text);
+        this.writeCL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode
+    enter_cardNode(_node, _parent, route) {
+        // Ignore cards for true-false-1
+        const isTrueFalse1 = this.isTrueFalse1(route);
+        if (isTrueFalse1)
+            return;
+        this.writeCardSetStart();
+        this.writeNL();
+    }
+    between_cardNode(_node, _left, _right, _parent, route) {
+        // Ignore cards for true-false-1
+        const isTrueFalse1 = this.isTrueFalse1(route);
+        if (isTrueFalse1)
+            return;
+        this.writeNL();
+        this.writeCardSetCardDivider();
+        this.writeNL();
+    }
+    exit_cardNode(_node, _parent, route) {
+        // Ignore cards for true-false-1
+        const isTrueFalse1 = this.isTrueFalse1(route);
+        if (isTrueFalse1)
+            return;
+        this.writeNL();
+        this.writeCardSetEnd();
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> elements
+    enter_elements(_node, _parent, _route) {
+        //
+    }
+    between_elements(_node, _left, _right, _parent, _route) {
+        this.writeNL();
+        this.writeCardSetVariantDivider();
+        this.writeNL();
+    }
+    exit_elements(_node, _parent, _route) {
+        //
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> statements
+    enter_statements(_node, _parent, _route) {
+        //
+    }
+    between_statements(_node, _left, _right, _parent, route) {
+        const isTrueFalse1 = this.isTrueFalse1(route);
+        if (!isTrueFalse1) {
+            this.writeNL();
+            this.writeCardSetCardDivider();
+        }
+        this.writeNL();
+    }
+    exit_statements(_node, _parent, _route) {
+        //
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> statements -> statementsValue
+    enter_statementsValue(node, _parent, _route) {
+        const statement = node.value;
+        if (statement.isCorrect) {
+            this.writeOPP();
+        }
+        else {
+            this.writeOPM();
+        }
+        this.write(statement.text);
+        this.writeCL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> choices
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> choices
+    between_choices(_node, _left, _right, _parent, _route) {
+        this.writeNL();
+    }
+    exit_choices(_node, _parent, _route) {
+        this.writeNL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> choices -> choicesValue
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> choices -> choicesValue
+    enter_choicesValue(node, _parent, _route) {
+        const choice = node.value;
+        if (choice.isCorrect) {
+            this.writeOPP();
+        }
+        else {
+            this.writeOPM();
+        }
+        this.write(choice.text);
+        this.writeCL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> responses
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> responses
+    between_responses(_node, _left, _right, _parent, _route) {
+        this.writeNL();
+    }
+    exit_responses(_node, _parent, _route) {
+        this.writeNL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> responses -> responsesValue
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> responses -> responsesValue
+    enter_responsesValue(node, _parent, _route) {
+        const response = node.value;
+        if (response.isCorrect) {
+            this.writeOPP();
+        }
+        else {
+            this.writeOPM();
+        }
+        this.write(response.text);
+        this.writeCL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes
+    enter_quizzes(_node, _parent, _route) {
+        //
+    }
+    between_quizzes(_node, _left, _right, _parent, _route) {
+        // this.writeNL();
+        this.writeCardSetCardDivider();
+        this.writeNL();
+    }
+    exit_quizzes(_node, _parent, _route) {
+        //
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue
+    between_quizzesValue(_node, _left, right, _parent, _route) {
+        if (right.key === NodeType_1.NodeType.choices || right.key === NodeType_1.NodeType.responses) {
+            this.writeNL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> heading
+    enter_heading(_node, _parent, _route) {
+        //
+    }
+    between_heading(_node, _left, _right, _parent, _route) {
+        this.writeNL();
+        this.writeCardSetSideDivider();
+        this.writeNL();
+    }
+    exit_heading(_node, _parent, _route) {
+        //
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> heading -> forValues
+    enter_forValues(_node, _parent, _route) {
+        //
+    }
+    between_forValues(_node, _left, _right, _parent, _route) {
+        this.writeNL();
+        this.writeCardSetSideDivider();
+        this.writeNL();
+    }
+    exit_forValues(_node, _parent, _route) {
+        //
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> pairs
+    enter_pairs(_node, _parent, _route) {
+        //
+    }
+    between_pairs(_node, _left, _right, _parent, _route) {
+        this.writeNL();
+        this.writeCardSetCardDivider();
+        this.writeNL();
+    }
+    exit_pairs(_node, _parent, _route) {
+        //
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> pairs -> pairsValue
+    between_pairsValue(_node, _left, _right, _parent, _route) {
+        //
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> pairs -> pairsValue -> keyAudio
+    enter_keyAudio(node, _parent, _route) {
+        const resource = node.value;
+        // This is a resource, so handle it with the common code
+        this.writeResource(resource);
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> pairs -> pairsValue -> keyImage
+    enter_keyImage(node, _parent, _route) {
+        const resource = node.value;
+        // This is a resource, so handle it with the common code
+        this.writeResource(resource);
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> matrix
+    enter_matrix(_node, _parent, _route) {
+        //
+    }
+    between_matrix(_node, _left, _right, _parent, _route) {
+        this.writeNL();
+        this.writeCardSetCardDivider();
+        this.writeNL();
+    }
+    exit_matrix(_node, _parent, _route) {
+        //
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> matrix -> matrixValue
+    between_matrixValue(_node, _left, _right, _parent, _route) {
+        //
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> pairs -> pairsValue -> values
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> matrix -> matrixValue -> cells -> cellsValue -> values
+    enter_values(_node, _parent, _route) {
+        this.writeNL();
+        this.writeCardSetSideDivider();
+        this.writeNL();
+    }
+    between_values(_node, _left, _right, _parent, _route) {
+        this.writeNL();
+        this.writeCardSetVariantDivider();
+        this.writeNL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> questions
+    enter_questions(_node, _parent, _route) {
+        //
+    }
+    between_questions(_node, _left, _right, _parent, _route) {
+        this.writeCardSetCardDivider();
+        this.writeNL();
+    }
+    exit_questions(_node, _parent, _route) {
+        //
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> questions -> questionsValue
+    between_questionsValue(_node, _left, right, _parent, _route) {
+        if (right.key === NodeType_1.NodeType.sampleSolution) {
+            this.writeNL();
+        }
+    }
+    exit_questionsValue(_node, _parent, _route) {
+        this.writeNL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses
+    enter_botResponses(_node, _parent, _route) {
+        //
+    }
+    between_botResponses(_node, _left, _right, _parent, _route) {
+        this.writeCardSetCardDivider();
+        this.writeNL();
+    }
+    exit_botResponses(_node, _parent, _route) {
+        //
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses -> botResponsesValue
+    between_botResponsesValue(_node, _left, _right, _parent, _route) {
+        this.writeNL();
+    }
+    exit_botResponsesValue(_node, _parent, _route) {
+        this.writeNL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses -> botResponsesValue -> response
+    leaf_response(node, _parent, _route) {
+        this.writeOPB();
+        this.writeString(node.value);
+        this.writeCL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses -> botResponsesValue -> reaction
+    leaf_reaction(node, _parent, _route) {
+        this.writeProperty('reaction', node.value, true);
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses -> botResponsesValue -> feedback
+    leaf_feedback(node, _parent, _route) {
+        const feeback = node.value;
+        if (feeback) {
+            this.write(feeback);
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> resource
+    enter_resource(node, _parent, _route) {
+        const resource = node.value;
+        // This is a resource, so handle it with the common code
+        this.writeResource(resource);
+    }
+    // bitmarkAst -> bits -> bitsValue -> resource -> posterImage
+    enter_posterImage(node, _parent, _route) {
+        const posterImage = node.value;
+        if (posterImage && posterImage.value) {
+            this.writeProperty('posterImage', posterImage.value);
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> resource -> thumbnails
+    // [src1x,src2x,src3x,src4x,width,height,alt,caption]
+    enter_thumbnails(node, _parent, _route) {
+        const thumbnails = node.value;
+        if (Array.isArray(thumbnails)) {
+            const thumbnailKeys = ['src1x', 'src2x', 'src3x', 'src4x'];
+            for (let i = 0; i < thumbnails.length; i++) {
+                // Can only handle 4 thumbnails
+                if (i === thumbnailKeys.length)
+                    break;
+                const thumbnail = thumbnails[i];
+                const key = thumbnailKeys[i];
+                this.writeProperty(key, thumbnail.value, true);
+            }
+        }
+    }
+    //
+    // Terminal nodes (leaves)
+    //
+    // bitmarkAst -> bits -> bitsValue -> bitType
+    // bitmarkAst -> bits -> bitsValue -> textFormat
+    //  bitmarkAst -> bits -> title
+    leaf_title(node, parent, _route) {
+        const value = node.value;
+        const title = value;
+        const bit = parent === null || parent === void 0 ? void 0 : parent.value;
+        const level = bit.level || 1;
+        if (level && title) {
+            this.writeOP();
+            for (let i = 0; i < +level; i++)
+                this.writeHash();
+            this.writeString(title);
+            this.writeCL();
+        }
+    }
+    //  bitmarkAst -> bits -> subtitle
+    leaf_subtitle(node, _parent, _route) {
+        const value = node.value;
+        const subtitle = value;
+        const level = 2;
+        if (level && subtitle) {
+            this.writeOP();
+            for (let i = 0; i < level; i++)
+                this.writeHash();
+            this.writeString(subtitle);
+            this.writeCL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> book
+    leaf_book(node, parent, _route) {
+        const bit = parent === null || parent === void 0 ? void 0 : parent.value;
+        if (bit && node.value) {
+            this.writeProperty('book', node.value);
+            if (bit.reference) {
+                this.writeOPRANGLE();
+                this.writeString(bit.reference);
+                this.writeCL();
+                if (bit.referenceEnd) {
+                    this.writeOPRANGLE();
+                    this.writeString(bit.referenceEnd);
+                    this.writeCL();
+                }
+            }
+        }
+    }
+    //  bitmarkAst -> bits -> bitsValue -> anchor
+    leaf_anchor(node, _parent, _route) {
+        if (node.value) {
+            this.writeOPDANGLE();
+            this.writeString(node.value);
+            this.writeCL();
+        }
+    }
+    //  bitmarkAst -> bits -> bitsValue -> reference
+    leaf_reference(node, parent, _route) {
+        const bit = parent === null || parent === void 0 ? void 0 : parent.value;
+        if (bit && node.value) {
+            // Only write reference if it is not chained to 'book'
+            if (!bit.book) {
+                this.writeOPRANGLE();
+                this.writeString(node.value);
+                this.writeCL();
+            }
+        }
+    }
+    //  * -> itemLead --> item
+    //  * -> itemLead --> lead
+    //  * -> hint
+    leaf_hint(node, _parent, _route) {
+        const value = node.value;
+        const text = value;
+        if (text) {
+            this.writeOPQ();
+            this.writeString(text);
+            this.writeCL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue ->  * -> instruction
+    leaf_instruction(node, _parent, _route) {
+        const value = node.value;
+        const text = value;
+        if (text) {
+            this.writeOPB();
+            this.writeString(text);
+            this.writeCL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue ->  * -> example
+    leaf_example(node, _parent, _route) {
+        const value = node.value;
+        if (value === true) {
+            this.writeOPA();
+            this.writeString('example');
+            this.writeCL();
+        }
+        else if (value) {
+            this.writeOPA();
+            this.writeString('example');
+            if (value !== '') {
+                this.writeColon();
+                this.writeString(value);
+            }
+            this.writeCL();
+        }
+    }
+    // bitmarkAst -> bits -> body -> bodyValue -> bodyText
+    leaf_bodyText(node, _parent, _route) {
+        const value = node.value;
+        const text = value;
+        if (text) {
+            this.writeString(text);
+        }
+    }
+    // bitmarkAst -> bits -> footer -> footerText
+    leaf_footerText(node, _parent, _route) {
+        const value = node.value;
+        const text = value;
+        if (text) {
+            this.writeString(text);
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> elements -> elementsValue
+    leaf_elementsValue(node, _parent, _route) {
+        if (node.value) {
+            this.writeString(node.value);
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> body -> bodyValue -> gap -> solutions -> solution
+    // ? -> solutions -> solution
+    leaf_solutionsValue(node, _parent, _route) {
+        if (node.value) {
+            this.writeOPU();
+            this.writeString(node.value);
+            this.writeCL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue-> body -> bodyValue -> select -> options -> prefix
+    // bitmarkAst -> bits -> bitsValue-> body -> bodyValue -> highlight -> options -> prefix
+    leaf_prefix(node, _parent, _route) {
+        if (node.value) {
+            this.writeOPPRE();
+            this.writeString(node.value);
+            this.writeCL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue-> body -> bodyValue -> select -> options -> postfix
+    // bitmarkAst -> bits -> bitsValue-> body -> bodyValue -> highlight -> options -> postfix
+    leaf_postfix(node, _parent, _route) {
+        if (node.value) {
+            this.writeOPPOST();
+            this.writeString(node.value);
+            this.writeCL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue ->  * -> isCaseSensitive
+    // bitmarkAst -> bits -> bitsValue ->  * -> isLongAnswer
+    // bitmarkAst -> bits -> bitsValue ->  * -> isCorrect
+    // bitmarkAst -> bits -> bitsValue -> heading -> forKeys
+    leaf_forKeys(node, _parent, _route) {
+        this.writeOPHASH();
+        this.writeString(node.value);
+        this.writeCL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> heading -> forValuesValue
+    leaf_forValuesValue(node, _parent, _route) {
+        this.writeOPHASH();
+        this.writeString(node.value);
+        this.writeCL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> pairs -> pairsValue -> key
+    // bitmarkAst -> bits -> bitsValue -> matrix -> matrixValue -> key
+    leaf_key(node, _parent, _route) {
+        if (node.value) {
+            this.writeString(node.value);
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> pairs -> pairsValue -> values -> valuesValue
+    // bitmarkAst -> bits -> bitsValue -> matrix -> matrixValue -> cells -> cellsValue -> values -> valuesValue
+    leaf_valuesValue(node, _parent, _route) {
+        if (node.value) {
+            this.writeString(node.value);
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> questions -> questionsValue -> question
+    leaf_question(node, _parent, _route) {
+        if (node.value) {
+            this.writeString(node.value);
+            // this.writeNL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> questions -> questionsValue -> sampleSolution
+    leaf_sampleSolution(node, _parent, _route) {
+        if (node.value) {
+            this.writeOPDOLLAR();
+            this.writeString(node.value);
+            this.writeCL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> questions -> questionsValue -> question -> isShortAnswer
+    leaf_isShortAnswer(node, _parent, _route) {
+        // Generally, shortAnswer is the default.
+        // Write long answer if shortAnswer is specifically false.
+        if (node.value === false) {
+            this.writeOPA();
+            this.writeString('longAnswer');
+            this.writeCL();
+        }
+    }
+    // bitmarkAst -> bits -> bitsValue -> statements -> text
+    // bitmarkAst -> bits -> bitsValue -> resource -> ...
+    // bitmarkAst -> bits -> bitsValue -> resource -> posterImage -> ...
+    // bitmarkAst -> bits -> bitsValue -> resource -> thumbnails -> thumbnailsValue -> ...
+    // [src1x,src2x,src3x,src4x,width,height,alt,caption]
+    leaf_src1x(node, _parent, _route) {
+        this.writeProperty('src1x', node.value);
+    }
+    leaf_src2x(node, _parent, _route) {
+        this.writeProperty('src2x', node.value);
+    }
+    leaf_src3x(node, _parent, _route) {
+        this.writeProperty('src3x', node.value);
+    }
+    leaf_src4x(node, _parent, _route) {
+        this.writeProperty('src4x', node.value);
+    }
+    leaf_width(node, _parent, _route) {
+        this.writeProperty('width', node.value);
+    }
+    leaf_height(node, _parent, _route) {
+        this.writeProperty('height', node.value);
+    }
+    leaf_alt(node, _parent, _route) {
+        this.writeProperty('alt', node.value);
+    }
+    leaf_license(node, _parent, _route) {
+        this.writeProperty('license', node.value);
+    }
+    leaf_copyright(node, _parent, _route) {
+        this.writeProperty('copyright', node.value);
+    }
+    leaf_provider(_node, _parent, _route) {
+        // provider is included in the url (it is the domain) and should not be written as a property
+        // this.writeProperty('provider', node.value);
+    }
+    leaf_showInIndex(node, _parent, _route) {
+        this.writeProperty('showInIndex', node.value);
+    }
+    leaf_caption(node, _parent, _route) {
+        const value = node.value;
+        this.writeProperty('caption', value);
+    }
+    // bitmarkAst -> bits -> bitsValue -> resource -> ...
+    // bitmarkAst -> bits -> bitsValue -> resource -> posterImage -> ...
+    // bitmarkAst -> bits -> bitsValue -> resource -> thumbnails -> thumbnailsValue -> ...
+    // [duration,mute,autoplay,allowSubtitles,showSubtitles]
+    leaf_duration(node, parent, _route) {
+        // Ignore duration that IS at the bit level as there is a key clash with resource...duration / bit.duration
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) === NodeType_1.NodeType.bitsValue)
+            return;
+        this.writeProperty('duration', node.value);
+    }
+    leaf_mute(node, _parent, _route) {
+        this.writeProperty('mute', node.value);
+    }
+    leaf_autoplay(node, _parent, _route) {
+        this.writeProperty('autoplay', node.value);
+    }
+    leaf_allowSubtitles(node, _parent, _route) {
+        this.writeProperty('allowSubtitles', node.value);
+    }
+    leaf_showSubtitles(node, _parent, _route) {
+        this.writeProperty('showSubtitles', node.value);
+    }
+    //
+    // Generated Node Handlers
+    //
+    /**
+     * Generate the handlers for properties, as they are mostly the same, but not quite
+     */
+    // protected enter_labelTrue(node: NodeInfo, parent: NodeInfo | undefined, _route: NodeInfo[],
+    // ): void {
+    //   const bit = parent?.value as Bit;
+    //   if (bit) {
+    //     this.writeProperty('labelTrue', node.value ?? '', true);
+    //     this.writeProperty('labelFalse', bit.labelFalse ?? '', true);
+    //   }
+    // }
+    generatePropertyHandlers() {
+        var _a;
+        for (const key of PropertyKey_1.PropertyKey.values()) {
+            const meta = (_a = PropertyKey_1.PropertyKey.getMetadata(PropertyKey_1.PropertyKey.fromValue(key))) !== 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_1.PropertyKey.example)
+                continue;
+            if (astKey === PropertyKey_1.PropertyKey.labelTrue)
+                continue;
+            if (astKey === PropertyKey_1.PropertyKey.labelFalse)
+                continue;
+            if (astKey === PropertyKey_1.PropertyKey.posterImage)
+                continue;
+            if (astKey === PropertyKey_1.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_1.NodeType.bitsValue)
+                    return;
+                // Write the property
+                this.writeProperty(key, node.value, meta.isSingle, meta.ignoreFalse, meta.ignoreTrue);
+            };
+            // Bind this
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this[funcName] = this[funcName].bind(this);
+        }
+    }
+    // END NODE HANDLERS
+    //
+    // WRITE FUNCTIONS
+    //
+    writeString(s) {
+        if (s != null)
+            this.write(`${s}`);
+    }
+    writeOPBUL() {
+        this.write('[•');
+    }
+    writeOPESC() {
+        this.write('[^');
+    }
+    writeOPRANGLE() {
+        this.write('[►');
+    }
+    writeOPDANGLE() {
+        this.write('[▼');
+    }
+    writeOPD() {
+        this.write('[.');
+    }
+    writeOPU() {
+        this.write('[_');
+    }
+    writeOPB() {
+        this.write('[!');
+    }
+    writeOPQ() {
+        this.write('[?');
+    }
+    writeOPA() {
+        this.write('[@');
+    }
+    writeOPP() {
+        this.write('[+');
+    }
+    writeOPM() {
+        this.write('[-');
+    }
+    writeOPS() {
+        this.write('[\\');
+    }
+    writeOPR() {
+        this.write('[*');
+    }
+    writeOPC() {
+        this.write('[%');
+    }
+    writeOPAMP() {
+        this.write('[&');
+    }
+    writeOPDOLLAR() {
+        this.write('[$');
+    }
+    writeOPHASH() {
+        this.write('[#');
+    }
+    writeOPPRE() {
+        this.write("['");
+    }
+    writeOPPOST() {
+        this.write('['); // TODO - not sure what symbol is for postfix
+    }
+    writeOP() {
+        this.write('[');
+    }
+    writeCL() {
+        this.write(']');
+    }
+    writeAmpersand() {
+        this.write('&');
+    }
+    writeColon() {
+        this.write(':');
+    }
+    // protected writeDoubleColon(): void {
+    //   this.write('::');
+    // }
+    writeHash() {
+        this.write('#');
+    }
+    writeCardSetStart() {
+        if (this.options.cardSetVersion === CardSetVersion_1.CardSetVersion.v1) {
+            this.write('===');
+        }
+        else {
+            this.write('++\n====');
+        }
+    }
+    writeCardSetEnd() {
+        if (this.options.cardSetVersion === CardSetVersion_1.CardSetVersion.v1) {
+            this.write('===');
+        }
+        else {
+            this.write('====\n++');
+        }
+    }
+    writeCardSetCardDivider() {
+        if (this.options.cardSetVersion === CardSetVersion_1.CardSetVersion.v1) {
+            this.write('===');
+        }
+        else {
+            this.write('====');
+        }
+    }
+    writeCardSetSideDivider() {
+        if (this.options.cardSetVersion === CardSetVersion_1.CardSetVersion.v1) {
+            this.write('==');
+        }
+        else {
+            this.write('--');
+        }
+    }
+    writeCardSetVariantDivider() {
+        if (this.options.cardSetVersion === CardSetVersion_1.CardSetVersion.v1) {
+            this.write('--');
+        }
+        else {
+            this.write('~~');
+        }
+    }
+    writeNL() {
+        if (this.options.debugGenerationInline) {
+            this.write('\\n');
+            return;
+        }
+        this.write('\n');
+    }
+    writeResource(resource) {
+        const resourceAsArticle = resource;
+        if (resource) {
+            // 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, cancel walking it's tree.
+            // if (!valid) return false;
+            // Special case for embedded resources
+            if (resource.type === ResourceType_1.ResourceType.stillImageFilm) {
+                const r = resource;
+                this.writeResource(r.image);
+                this.writeNL();
+                this.writeResource(r.audio);
+            }
+            else {
+                // Standard case
+                this.writeOPAMP();
+                this.writeString(resource.type);
+                if (resource.type === ResourceType_1.ResourceType.article && resourceAsArticle.value) {
+                    this.writeColon();
+                    // this.writeNL();
+                    this.writeString(resourceAsArticle.value);
+                    this.writeNL();
+                }
+                else if (resource.value) {
+                    this.writeColon();
+                    this.writeString(resource.value);
+                }
+                this.writeCL();
+            }
+        }
+    }
+    writeProperty(name, values, singleOnly, ignoreFalse, ignoreTrue) {
+        let valuesArray;
+        let wroteSomething = false;
+        if (values !== undefined) {
+            if (!Array.isArray(values)) {
+                valuesArray = [values];
+            }
+            else {
+                valuesArray = values;
+            }
+            if (valuesArray.length > 0) {
+                if (singleOnly)
+                    valuesArray = valuesArray.slice(valuesArray.length - 1);
+                for (const val of valuesArray) {
+                    if (val !== undefined) {
+                        if (ignoreFalse && val === false)
+                            continue;
+                        if (ignoreTrue && val === true)
+                            continue;
+                        this.writeOPA();
+                        this.writeString(name);
+                        this.writeColon();
+                        this.writeString(`${val}`);
+                        this.writeCL();
+                        wroteSomething = true;
+                    }
+                }
+            }
+        }
+        if (!wroteSomething) {
+            this.skipNLBetweenBitsValue = true;
+        }
+    }
+    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);
+    }
+    isWriteTextFormat(bitsValue) {
+        const isMinusMinus = TextFormat_1.TextFormat.fromValue(bitsValue) === TextFormat_1.TextFormat.bitmarkMinusMinus;
+        const writeFormat = !isMinusMinus || this.options.explicitTextFormat;
+        return !!writeFormat;
+    }
+    isTrueFalse1(route) {
+        const bitType = this.getBitType(route);
+        return bitType === BitType_1.BitType.trueFalse1;
+    }
+    getBitType(route) {
+        for (const node of route) {
+            if (node.key === NodeType_1.NodeType.bitsValue) {
+                const n = node.value;
+                return n === null || n === void 0 ? void 0 : n.bitType;
+            }
+        }
+        return undefined;
+    }
+    //
+    // 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;
+    }
+}
+exports.BitmarkGenerator = BitmarkGenerator;
+//# sourceMappingURL=BitmarkGenerator.js.map