@gmb/bitmark-parser-generator 1.5.12 → 1.5.13

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

@@ -22,13 +22,14 @@ const PropertyTag_1 = require("../../model/enum/PropertyTag");
 const ResourceTag_1 = require("../../model/enum/ResourceTag");
 const TextFormat_1 = require("../../model/enum/TextFormat");
 const BooleanUtils_1 = require("../../utils/BooleanUtils");
+const AstWalkerGenerator_1 = require("../AstWalkerGenerator");
 const DEFAULT_OPTIONS = {
     debugGenerationInline: false,
 };
 /**
  * Generate bitmark markup from a bitmark AST
  */
-class BitmarkGenerator {
+class BitmarkGenerator extends AstWalkerGenerator_1.AstWalkerGenerator {
     /**
      * Generate bitmark markup from a bitmark AST
      *
@@ -45,14 +46,14 @@ class BitmarkGenerator {
      * @param options - bitmark generation options
      */
     constructor(writer, options) {
-        var _a;
+        var _a, _b;
+        super();
         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);
+        this.debugGenerationInline = (_b = this.options.debugGenerationInline) !== null && _b !== void 0 ? _b : false;
         // Set defaults according to bitmark version
         if (this.bitmarkVersion === BitmarkVersion_1.BitmarkVersion.v2) {
             if (this.options.cardSetVersion === undefined) {
@@ -115,55 +116,6 @@ class BitmarkGenerator {
         // 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
     //
@@ -172,13 +124,13 @@ class BitmarkGenerator {
     //
     // bitmark
     // bitmarkAst -> bits
-    between_bits(_node, _left, _right, _parent, _route) {
+    between_bits(_node, _left, _right, _route) {
         this.writeNL();
         this.writeNL();
         this.writeNL();
     }
     // bitmarkAst -> bits -> bitsValue
-    enter_bitsValue(node, _parent, _route) {
+    enter_bitsValue(node, _route) {
         const bit = node.value;
         const bitConfig = Config_1.Config.getBitConfig(bit.bitType);
         const bitResourcesConfig = Config_1.Config.getBitResourcesConfig(bit.bitType, bit.resourceType);
@@ -216,7 +168,7 @@ class BitmarkGenerator {
         this.writeCL();
         this.writeNL();
     }
-    between_bitsValue(node, left, _right, _parent, _route) {
+    between_bitsValue(node, left, _right, _route) {
         // The following keys are combined with other keys so don't need newlines
         const noNlKeys = [
             NodeType_1.NodeType.bitType,
@@ -249,9 +201,10 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> internalComment
-    enter_internalComment(node, parent, _route) {
+    enter_internalComment(node, route) {
         const internalComment = node.value;
         // Ignore values that are not at the bit level as they might be handled elsewhere
+        const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType_1.NodeType.bitsValue)
             return;
         for (let i = 0; i < internalComment.length; i++) {
@@ -263,9 +216,10 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> labelTrue / labelFalse
-    enter_labelTrue(node, parent, _route) {
+    enter_labelTrue(node, route) {
         const value = node.value;
         // Ignore example that is not at the bit level as it are handled elsewhere
+        const parent = this.getParentNode(route);
         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;
@@ -277,9 +231,10 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> imageSource
-    enter_imageSource(node, parent, _route) {
+    enter_imageSource(node, route) {
         const imageSource = node.value;
         // Ignore values that are not at the bit level as they might be handled elsewhere
+        const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType_1.NodeType.bitsValue)
             return;
         const { url, mockupId, size, format, trim } = imageSource;
@@ -296,9 +251,10 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> partner
-    enter_partner(node, parent, _route) {
+    enter_partner(node, route) {
         const partner = node.value;
         // Ignore values that are not at the bit level as they might be handled elsewhere
+        const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType_1.NodeType.bitsValue)
             return;
         const { name, avatarImage } = partner;
@@ -308,9 +264,10 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> markConfigValue
-    enter_markConfigValue(node, parent, _route) {
+    enter_markConfigValue(node, route) {
         const markConfig = node.value;
         // Ignore values that are not at the correct level as they might be handled elsewhere
+        const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType_1.NodeType.markConfig)
             return;
         const { mark, color, emphasis } = markConfig;
@@ -325,16 +282,16 @@ class BitmarkGenerator {
     }
     // bitmarkAst -> bits -> bitsValue -> sampleSolution
     // bitmarkAst -> bits -> bitsValue -> questions -> questionsValue -> sampleSolution
-    leaf_sampleSolution(node, _parent, _route) {
+    leaf_sampleSolution(node, _route) {
         this.writeProperty('sampleSolution', node.value);
     }
     // bitmarkAst -> bits -> bitsValue -> reasonableNumOfChars
     // bitmarkAst -> bits -> bitsValue -> questions -> questionsValue -> reasonableNumOfChars
-    leaf_reasonableNumOfChars(node, _parent, _route) {
+    leaf_reasonableNumOfChars(node, _route) {
         this.writeProperty('reasonableNumOfChars', node.value);
     }
     // bitmarkAst -> bits -> bitsValue -> itemLead
-    enter_itemLead(node, _parent, _route) {
+    enter_itemLead(node, _route) {
         const itemLead = node.value;
         if (itemLead && (itemLead.item || itemLead.lead || itemLead.pageNumber || itemLead.marginNumber)) {
             // Always write item if item or lead is set
@@ -359,7 +316,7 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> body
-    enter_body(node, _parent, _route) {
+    enter_body(node, _route) {
         // always write a NL before the body content if there is any?
         const body = node.value;
         if (body.bodyParts.length > 0) {
@@ -367,7 +324,7 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> body -> bodyParts -> bodyPartsValue -> data -> solutions
-    enter_solutions(node, _parent, _route) {
+    enter_solutions(node, _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
@@ -376,7 +333,7 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> body -> bodyParts -> bodyPartsValue -> data -> solution
-    leaf_solution(node, _parent, route) {
+    leaf_solution(node, route) {
         var _a;
         const solution = node.value;
         // Ignore values that are not at the correct level as they might be handled elsewhere
@@ -390,7 +347,7 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> body -> bodyParts -> bodyPartsValue -> data -> mark
-    leaf_mark(node, _parent, route) {
+    leaf_mark(node, route) {
         var _a;
         const mark = node.value;
         // Ignore values that are not at the correct level as they might be handled elsewhere
@@ -402,7 +359,7 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> body -> bodyParts -> bodyPartsValue -> data -> options -> optionsValue
-    enter_optionsValue(node, _parent, _route) {
+    enter_optionsValue(node, _route) {
         const selectOption = node.value;
         if (selectOption.isCorrect) {
             this.writeOPP();
@@ -414,7 +371,7 @@ class BitmarkGenerator {
         this.writeCL();
     }
     // bitmarkAst -> bits -> bitsValue -> body -> bodyParts -> bodyPartsValue -> data -> texts -> textsValue
-    enter_textsValue(node, _parent, _route) {
+    enter_textsValue(node, _route) {
         const highlightText = node.value;
         if (highlightText.isCorrect) {
             this.writeOPP();
@@ -426,7 +383,7 @@ class BitmarkGenerator {
         this.writeCL();
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode
-    enter_cardNode(_node, _parent, route) {
+    enter_cardNode(_node, route) {
         // Ignore cards for xxx-1
         const isBitType1 = this.isOfBitType1(route);
         if (isBitType1)
@@ -434,7 +391,7 @@ class BitmarkGenerator {
         this.writeCardSetStart();
         this.writeNL();
     }
-    between_cardNode(_node, _left, _right, _parent, route) {
+    between_cardNode(_node, _left, _right, route) {
         // Ignore cards for xxx-1
         const isBitType1 = this.isOfBitType1(route);
         if (isBitType1)
@@ -443,7 +400,7 @@ class BitmarkGenerator {
         this.writeCardSetCardDivider();
         this.writeNL();
     }
-    exit_cardNode(_node, _parent, route) {
+    exit_cardNode(_node, route) {
         // Ignore cards for xxx-1
         const isBitType1 = this.isOfBitType1(route);
         if (isBitType1)
@@ -453,25 +410,25 @@ class BitmarkGenerator {
         this.writeNL();
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> elements
-    enter_elements(_node, _parent, _route) {
+    enter_elements(_node, _route) {
         //
     }
-    between_elements(_node, _left, _right, _parent, _route) {
+    between_elements(_node, _left, _right, _route) {
         this.writeNL();
         this.writeCardSetVariantDivider();
         this.writeNL();
     }
-    exit_elements(_node, _parent, _route) {
+    exit_elements(_node, _route) {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> flashcards
-    between_flashcards(_node, _left, _right, _parent, _route) {
+    between_flashcards(_node, _left, _right, _route) {
         this.writeNL();
         this.writeCardSetCardDivider();
         this.writeNL();
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> flashcards -> flashcardsValue
-    between_flashcardsValue(_node, _left, right, _parent, _route) {
+    between_flashcardsValue(_node, _left, right, _route) {
         if (right.key === NodeType_1.NodeType.answer) {
             this.writeNL();
             this.writeCardSetSideDivider();
@@ -484,8 +441,9 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> flashcards -> flashcardsValue -> answer
-    leaf_answer(node, parent, _route) {
+    leaf_answer(node, route) {
         // Ignore responses that are not at the flashcardsValue level as they are handled elsewhere
+        const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType_1.NodeType.flashcardsValue)
             return;
         if (node.value) {
@@ -493,14 +451,15 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> flashcards -> flashcardsValue -> alternativeAnswers
-    between_alternativeAnswers(_node, _parent, _route) {
+    between_alternativeAnswers(_node, _route) {
         this.writeNL();
         this.writeCardSetVariantDivider();
         this.writeNL();
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> flashcards -> flashcardsValue -> alternativeAnswers -> alternativeAnswersValue
-    leaf_alternativeAnswersValue(node, parent, _route) {
+    leaf_alternativeAnswersValue(node, route) {
         // Ignore responses that are not at the alternativeAnswers level as they are handled elsewhere
+        const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType_1.NodeType.alternativeAnswers)
             return;
         if (node.value) {
@@ -508,10 +467,10 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> statements
-    enter_statements(_node, _parent, _route) {
+    enter_statements(_node, _route) {
         //
     }
-    between_statements(_node, _left, _right, _parent, route) {
+    between_statements(_node, _left, _right, route) {
         const isTrueFalse1 = this.isOfBitType(route, BitType_1.BitType.trueFalse1);
         if (!isTrueFalse1) {
             this.writeNL();
@@ -519,11 +478,11 @@ class BitmarkGenerator {
         }
         this.writeNL();
     }
-    exit_statements(_node, _parent, _route) {
+    exit_statements(_node, _route) {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> statements -> statementsValue
-    enter_statementsValue(node, _parent, _route) {
+    enter_statementsValue(node, _route) {
         const statement = node.value;
         if (statement.isCorrect) {
             this.writeOPP();
@@ -536,15 +495,15 @@ class BitmarkGenerator {
     }
     // bitmarkAst -> bits -> bitsValue -> choices
     // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> choices
-    between_choices(_node, _left, _right, _parent, _route) {
+    between_choices(_node, _left, _right, _route) {
         this.writeNL();
     }
-    exit_choices(_node, _parent, _route) {
+    exit_choices(_node, _route) {
         this.writeNL();
     }
     // bitmarkAst -> bits -> bitsValue -> choices -> choicesValue
     // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> choices -> choicesValue
-    enter_choicesValue(node, _parent, _route) {
+    enter_choicesValue(node, _route) {
         const choice = node.value;
         if (choice.isCorrect) {
             this.writeOPP();
@@ -557,15 +516,15 @@ class BitmarkGenerator {
     }
     // bitmarkAst -> bits -> bitsValue -> responses
     // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> responses
-    between_responses(_node, _left, _right, _parent, _route) {
+    between_responses(_node, _left, _right, _route) {
         this.writeNL();
     }
-    exit_responses(_node, _parent, _route) {
+    exit_responses(_node, _route) {
         this.writeNL();
     }
     // bitmarkAst -> bits -> bitsValue -> responses -> responsesValue
     // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> responses -> responsesValue
-    enter_responsesValue(node, _parent, _route) {
+    enter_responsesValue(node, _route) {
         const response = node.value;
         if (response.isCorrect) {
             this.writeOPP();
@@ -577,183 +536,184 @@ class BitmarkGenerator {
         this.writeCL();
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes
-    enter_quizzes(_node, _parent, _route) {
+    enter_quizzes(_node, _route) {
         //
     }
-    between_quizzes(_node, _left, _right, _parent, _route) {
+    between_quizzes(_node, _left, _right, _route) {
         // this.writeNL();
         this.writeCardSetCardDivider();
         this.writeNL();
     }
-    exit_quizzes(_node, _parent, _route) {
+    exit_quizzes(_node, _route) {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue
-    between_quizzesValue(_node, _left, right, _parent, _route) {
+    between_quizzesValue(_node, _left, right, _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) {
+    enter_heading(_node, _route) {
         //
     }
-    between_heading(_node, _left, _right, _parent, _route) {
+    between_heading(_node, _left, _right, _route) {
         this.writeNL();
         this.writeCardSetSideDivider();
         this.writeNL();
     }
-    exit_heading(_node, _parent, _route) {
+    exit_heading(_node, _route) {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> heading -> forValues
-    enter_forValues(_node, _parent, _route) {
+    enter_forValues(_node, _route) {
         //
     }
-    between_forValues(_node, _left, _right, _parent, _route) {
+    between_forValues(_node, _left, _right, _route) {
         this.writeNL();
         this.writeCardSetSideDivider();
         this.writeNL();
     }
-    exit_forValues(_node, _parent, _route) {
+    exit_forValues(_node, _route) {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> pairs
-    enter_pairs(_node, _parent, _route) {
+    enter_pairs(_node, _route) {
         //
     }
-    between_pairs(_node, _left, _right, _parent, _route) {
+    between_pairs(_node, _left, _right, _route) {
         this.writeNL();
         this.writeCardSetCardDivider();
         this.writeNL();
     }
-    exit_pairs(_node, _parent, _route) {
+    exit_pairs(_node, _route) {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> pairs -> pairsValue
-    between_pairsValue(_node, _left, _right, _parent, _route) {
+    between_pairsValue(_node, _left, _right, _route) {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> pairs -> pairsValue -> keyAudio
-    enter_keyAudio(node, _parent, _route) {
+    enter_keyAudio(node, _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) {
+    enter_keyImage(node, _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) {
+    enter_matrix(_node, _route) {
         //
     }
-    between_matrix(_node, _left, _right, _parent, _route) {
+    between_matrix(_node, _left, _right, _route) {
         this.writeNL();
         this.writeCardSetCardDivider();
         this.writeNL();
     }
-    exit_matrix(_node, _parent, _route) {
+    exit_matrix(_node, _route) {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> matrix -> matrixValue
-    between_matrixValue(_node, _left, _right, _parent, _route) {
+    between_matrixValue(_node, _left, _right, _route) {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> pairs -> pairsValue -> values
     // bitmarkAst -> bits -> bitsValue -> cardNode -> matrix -> matrixValue -> cells -> cellsValue -> values
-    enter_values(_node, _parent, _route) {
+    enter_values(_node, _route) {
         this.writeNL();
         this.writeCardSetSideDivider();
         this.writeNL();
     }
-    between_values(_node, _left, _right, _parent, _route) {
+    between_values(_node, _left, _right, _route) {
         this.writeNL();
         this.writeCardSetVariantDivider();
         this.writeNL();
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> questions
-    enter_questions(_node, _parent, _route) {
+    enter_questions(_node, _route) {
         //
     }
-    between_questions(_node, _left, _right, _parent, _route) {
+    between_questions(_node, _left, _right, _route) {
         this.writeCardSetCardDivider();
         this.writeNL();
     }
-    exit_questions(_node, _parent, _route) {
+    exit_questions(_node, _route) {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> questions -> questionsValue
-    between_questionsValue(_node, _left, right, _parent, _route) {
+    between_questionsValue(_node, _left, right, _route) {
         if (right.key === NodeType_1.NodeType.sampleSolution) {
             this.writeNL();
         }
     }
-    exit_questionsValue(_node, _parent, _route) {
+    exit_questionsValue(_node, _route) {
         this.writeNL();
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses
-    enter_botResponses(_node, _parent, _route) {
+    enter_botResponses(_node, _route) {
         //
     }
-    between_botResponses(_node, _left, _right, _parent, _route) {
+    between_botResponses(_node, _left, _right, _route) {
         this.writeCardSetCardDivider();
         this.writeNL();
     }
-    exit_botResponses(_node, _parent, _route) {
+    exit_botResponses(_node, _route) {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses -> botResponsesValue
-    between_botResponsesValue(_node, _left, _right, _parent, _route) {
+    between_botResponsesValue(_node, _left, _right, _route) {
         this.writeNL();
     }
-    exit_botResponsesValue(_node, _parent, _route) {
+    exit_botResponsesValue(_node, _route) {
         this.writeNL();
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> cardBits
-    enter_cardBits(_node, _parent, _route) {
+    enter_cardBits(_node, _route) {
         //
     }
-    between_cardBits(_node, _left, _right, _parent, _route) {
+    between_cardBits(_node, _left, _right, _route) {
         this.writeNL();
         this.writeCardSetCardDivider();
         this.writeNL();
     }
-    exit_cardBits(_node, _parent, _route) {
+    exit_cardBits(_node, _route) {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses -> botResponsesValue -> response
-    leaf_response(node, _parent, _route) {
+    leaf_response(node, _route) {
         this.writeOPB();
         this.writeString(node.value);
         this.writeCL();
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses -> botResponsesValue -> reaction
-    leaf_reaction(node, _parent, _route) {
+    leaf_reaction(node, _route) {
         this.writeProperty('reaction', node.value, true);
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses -> botResponsesValue -> feedback
-    leaf_feedback(node, _parent, _route) {
+    leaf_feedback(node, _route) {
         const feeback = node.value;
         if (feeback) {
             this.write(feeback);
         }
     }
     // bitmarkAst -> bits -> bitsValue -> resources
-    between_resources(_node, _left, _right, _parent, _route) {
+    between_resources(_node, _left, _right, _route) {
         this.writeNL();
     }
     // bitmarkAst -> bits -> bitsValue -> resourcesValue
-    enter_resourcesValue(node, _parent, _route) {
+    enter_resourcesValue(node, _route) {
         const resource = node.value;
         // This is a resource, so handle it with the common code
         this.writeResource(resource);
     }
     // bitmarkAst -> bits -> bitsValue -> posterImage
     // bitmarkAst -> bits -> bitsValue -> resource -> posterImage
-    enter_posterImage(node, parent, _route) {
+    enter_posterImage(node, route) {
+        const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) === NodeType_1.NodeType.bitsValue) {
             // Bit poster image
             const posterImage = node.value;
@@ -771,7 +731,7 @@ class BitmarkGenerator {
     }
     // bitmarkAst -> bits -> bitsValue -> resource -> thumbnails
     // [src1x,src2x,src3x,src4x,width,height,alt,zoomDisabled,caption]
-    enter_thumbnails(node, _parent, _route) {
+    enter_thumbnails(node, _route) {
         const thumbnails = node.value;
         if (Array.isArray(thumbnails)) {
             const thumbnailKeys = ['src1x', 'src2x', 'src3x', 'src4x'];
@@ -791,7 +751,8 @@ class BitmarkGenerator {
     // bitmarkAst -> bits -> bitsValue -> bitType
     // bitmarkAst -> bits -> bitsValue -> textFormat
     //  bitmarkAst -> bits -> title
-    leaf_title(node, parent, _route) {
+    leaf_title(node, route) {
+        const parent = this.getParentNode(route);
         const value = node.value;
         const title = value;
         const bit = parent === null || parent === void 0 ? void 0 : parent.value;
@@ -805,7 +766,7 @@ class BitmarkGenerator {
         }
     }
     //  bitmarkAst -> bits -> subtitle
-    leaf_subtitle(node, _parent, _route) {
+    leaf_subtitle(node, _route) {
         const value = node.value;
         const subtitle = value;
         const level = 2;
@@ -818,7 +779,8 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> book
-    leaf_book(node, parent, _route) {
+    leaf_book(node, route) {
+        const parent = this.getParentNode(route);
         const bit = parent === null || parent === void 0 ? void 0 : parent.value;
         if (bit && node.value) {
             this.writeProperty('book', node.value);
@@ -835,7 +797,7 @@ class BitmarkGenerator {
         }
     }
     //  bitmarkAst -> bits -> bitsValue -> anchor
-    leaf_anchor(node, _parent, _route) {
+    leaf_anchor(node, _route) {
         if (node.value) {
             this.writeOPDANGLE();
             this.writeString(node.value);
@@ -843,7 +805,8 @@ class BitmarkGenerator {
         }
     }
     //  bitmarkAst -> bits -> bitsValue -> reference
-    leaf_reference(node, parent, _route) {
+    leaf_reference(node, route) {
+        const parent = this.getParentNode(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'
@@ -857,7 +820,7 @@ class BitmarkGenerator {
     //  * -> itemLead --> item
     //  * -> itemLead --> lead
     //  * -> hint
-    leaf_hint(node, _parent, _route) {
+    leaf_hint(node, _route) {
         const value = node.value;
         const text = value;
         if (text) {
@@ -867,7 +830,7 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue ->  * -> instruction
-    leaf_instruction(node, _parent, _route) {
+    leaf_instruction(node, _route) {
         const value = node.value;
         const text = value;
         if (text) {
@@ -877,9 +840,10 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue ->  * -> example
-    leaf_example(node, parent, _route) {
+    leaf_example(node, route) {
         var _a, _b;
         const value = node.value;
+        const parent = this.getParentNode(route);
         const isExample = (_a = parent === null || parent === void 0 ? void 0 : parent.value.isExample) !== null && _a !== void 0 ? _a : false;
         const isDefaultExample = (_b = parent === null || parent === void 0 ? void 0 : parent.value.isDefaultExample) !== null && _b !== void 0 ? _b : false;
         if (!isExample)
@@ -907,7 +871,7 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> body -> bodyValue -> bodyText
-    leaf_bodyText(node, _parent, _route) {
+    leaf_bodyText(node, _route) {
         const value = node.value;
         const text = value;
         if (text) {
@@ -915,7 +879,7 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> footer -> footerText
-    leaf_footerText(node, _parent, _route) {
+    leaf_footerText(node, _route) {
         const value = node.value;
         const text = value;
         if (text) {
@@ -923,14 +887,14 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue -> elements -> elementsValue
-    leaf_elementsValue(node, _parent, _route) {
+    leaf_elementsValue(node, _route) {
         if (node.value) {
             this.writeString(node.value);
         }
     }
     // bitmarkAst -> bits -> bitsValue -> body -> bodyValue -> gap -> solutions -> solution
     // ? -> solutions -> solution
-    leaf_solutionsValue(node, _parent, _route) {
+    leaf_solutionsValue(node, _route) {
         if (node.value) {
             this.writeOPU();
             this.writeString(node.value);
@@ -939,7 +903,7 @@ class BitmarkGenerator {
     }
     // bitmarkAst -> bits -> bitsValue-> body -> bodyValue -> select -> options -> prefix
     // bitmarkAst -> bits -> bitsValue-> body -> bodyValue -> highlight -> options -> prefix
-    leaf_prefix(node, _parent, _route) {
+    leaf_prefix(node, _route) {
         if (node.value) {
             this.writeOPPRE();
             this.writeString(node.value);
@@ -948,7 +912,7 @@ class BitmarkGenerator {
     }
     // bitmarkAst -> bits -> bitsValue-> body -> bodyValue -> select -> options -> postfix
     // bitmarkAst -> bits -> bitsValue-> body -> bodyValue -> highlight -> options -> postfix
-    leaf_postfix(node, _parent, _route) {
+    leaf_postfix(node, _route) {
         if (node.value) {
             this.writeOPPOST();
             this.writeString(node.value);
@@ -956,40 +920,41 @@ class BitmarkGenerator {
         }
     }
     // bitmarkAst -> bits -> bitsValue ->  * -> isCaseSensitive
-    leaf_isCaseSensitive(node, _parent, _route) {
+    leaf_isCaseSensitive(node, _route) {
         this.writeProperty('isCaseSensitive', node.value, true, false, true);
     }
     // bitmarkAst -> bits -> bitsValue ->  * -> isCorrect
     // bitmarkAst -> bits -> bitsValue -> heading -> forKeys
-    leaf_forKeys(node, _parent, _route) {
+    leaf_forKeys(node, _route) {
         this.writeOPHASH();
         this.writeString(node.value);
         this.writeCL();
     }
     // bitmarkAst -> bits -> bitsValue -> heading -> forValuesValue
-    leaf_forValuesValue(node, _parent, _route) {
+    leaf_forValuesValue(node, _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) {
+    leaf_key(node, _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) {
+    leaf_valuesValue(node, _route) {
         if (node.value) {
             this.writeString(node.value);
         }
     }
     // bitmarkAst -> bits -> bitsValue -> questions -> questionsValue -> question
     // bitmarkAst -> bits -> bitsValue -> cardNode -> flashcards -> flashcardsValue -> question
-    leaf_question(node, parent, _route) {
+    leaf_question(node, route) {
         // Ignore responses that are not at the questionsValue level as they are handled elsewhere
+        const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType_1.NodeType.questionsValue && (parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType_1.NodeType.flashcardsValue)
             return;
         if (node.value) {
@@ -1002,29 +967,29 @@ class BitmarkGenerator {
     // bitmarkAst -> bits -> bitsValue -> resource -> posterImage -> ...
     // bitmarkAst -> bits -> bitsValue -> resource -> thumbnails -> thumbnailsValue -> ...
     // [src1x,src2x,src3x,src4x,width,height,alt,zoomDisabled,caption]
-    leaf_src1x(node, _parent, _route) {
+    leaf_src1x(node, _route) {
         this.writeProperty('src1x', node.value);
     }
-    leaf_src2x(node, _parent, _route) {
+    leaf_src2x(node, _route) {
         this.writeProperty('src2x', node.value);
     }
-    leaf_src3x(node, _parent, _route) {
+    leaf_src3x(node, _route) {
         this.writeProperty('src3x', node.value);
     }
-    leaf_src4x(node, _parent, _route) {
+    leaf_src4x(node, _route) {
         this.writeProperty('src4x', node.value);
     }
-    leaf_width(node, _parent, _route) {
+    leaf_width(node, _route) {
         this.writeProperty('width', node.value);
     }
-    leaf_height(node, _parent, _route) {
+    leaf_height(node, _route) {
         this.writeProperty('height', node.value);
     }
-    leaf_alt(node, _parent, _route) {
+    leaf_alt(node, _route) {
         this.writeProperty('alt', node.value);
     }
-    leaf_zoomDisabled(node, _parent, _route) {
-        const bitType = this.getBitType(_route);
+    leaf_zoomDisabled(node, route) {
+        const bitType = this.getBitType(route);
         if (Config_1.Config.isOfBitType(bitType, [BitType_1.BitType.imageSeparator, BitType_1.BitType.pageBanner])) {
             this.writeProperty('zoomDisabled', node.value, undefined, false, true);
         }
@@ -1032,20 +997,20 @@ class BitmarkGenerator {
             this.writeProperty('zoomDisabled', node.value, undefined, true, false);
         }
     }
-    leaf_license(node, _parent, _route) {
+    leaf_license(node, _route) {
         this.writeProperty('license', node.value);
     }
-    leaf_copyright(node, _parent, _route) {
+    leaf_copyright(node, _route) {
         this.writeProperty('copyright', node.value);
     }
-    leaf_provider(_node, _parent, _route) {
+    leaf_provider(_node, _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) {
+    leaf_showInIndex(node, _route) {
         this.writeProperty('showInIndex', node.value);
     }
-    leaf_caption(node, _parent, _route) {
+    leaf_caption(node, _route) {
         const value = node.value;
         this.writeProperty('caption', value);
     }
@@ -1053,22 +1018,23 @@ class BitmarkGenerator {
     // bitmarkAst -> bits -> bitsValue -> resource -> posterImage -> ...
     // bitmarkAst -> bits -> bitsValue -> resource -> thumbnails -> thumbnailsValue -> ...
     // [duration,mute,autoplay,allowSubtitles,showSubtitles]
-    leaf_duration(node, parent, _route) {
+    leaf_duration(node, route) {
         // Ignore duration that IS at the bit level as there is a key clash with resource...duration / bit.duration
+        const parent = this.getParentNode(route);
         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) {
+    leaf_mute(node, _route) {
         this.writeProperty('mute', node.value);
     }
-    leaf_autoplay(node, _parent, _route) {
+    leaf_autoplay(node, _route) {
         this.writeProperty('autoplay', node.value);
     }
-    leaf_allowSubtitles(node, _parent, _route) {
+    leaf_allowSubtitles(node, _route) {
         this.writeProperty('allowSubtitles', node.value);
     }
-    leaf_showSubtitles(node, _parent, _route) {
+    leaf_showSubtitles(node, _route) {
         this.writeProperty('showSubtitles', node.value);
     }
     //
@@ -1077,7 +1043,7 @@ class BitmarkGenerator {
     /**
      * Generate the handlers for properties, as they are mostly the same, but not quite
      */
-    // protected enter_labelTrue(node: NodeInfo, parent: NodeInfo | undefined, _route: NodeInfo[],
+    // protected enter_labelTrue(node: NodeInfo, _route: NodeInfo[],
     // ): void {
     //   const bit = parent?.value as Bit;
     //   if (bit) {
@@ -1109,12 +1075,13 @@ class BitmarkGenerator {
                 continue;
             const funcName = `enter_${astKey}`;
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this[funcName] = (node, parent, _route) => {
+            this[funcName] = (node, route) => {
                 const value = node.value;
                 if (value == null)
                     return;
                 // if (propertyConfig.tag === 'progress') debugger;
                 // Ignore any property that is not at the bit level as that will be handled by a different handler
+                const parent = this.getParentNode(route);
                 if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType_1.NodeType.bitsValue)
                     return;
                 // Write the property
@@ -1333,6 +1300,9 @@ class BitmarkGenerator {
         }
         this.writeString(tag);
     }
+    //
+    // Helper functions
+    //
     isWriteTextFormat(bitsValue, textFormatDefault) {
         const isDefault = TextFormat_1.TextFormat.fromValue(bitsValue) === textFormatDefault;
         const writeFormat = !isDefault || this.options.explicitTextFormat;
@@ -1354,12 +1324,6 @@ class BitmarkGenerator {
         }
         return undefined;
     }
-    getParentNode(route, nodesBack = 1) {
-        if (route.length > nodesBack + 1) {
-            return route[route.length - nodesBack - 1];
-        }
-        return undefined;
-    }
     //
     // Writer interface
     //