@gmb/bitmark-parser-generator 1.5.12 → 1.5.13

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

@@ -19,13 +19,14 @@ import { PropertyTag } from '../../model/enum/PropertyTag';
 import { ResourceTag } from '../../model/enum/ResourceTag';
 import { TextFormat } from '../../model/enum/TextFormat';
 import { BooleanUtils } from '../../utils/BooleanUtils';
+import { AstWalkerGenerator } from '../AstWalkerGenerator';
 const DEFAULT_OPTIONS = {
     debugGenerationInline: false,
 };
 /**
  * Generate bitmark markup from a bitmark AST
  */
-class BitmarkGenerator {
+class BitmarkGenerator extends AstWalkerGenerator {
     /**
      * Generate bitmark markup from a bitmark AST
      *
@@ -42,14 +43,14 @@ class BitmarkGenerator {
      * @param options - bitmark generation options
      */
     constructor(writer, options) {
-        var _a;
+        var _a, _b;
+        super();
         this.ast = new Ast();
         // State
         this.skipNLBetweenBitsValue = false;
-        // 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.bitmarkOptions);
+        this.debugGenerationInline = (_b = this.options.debugGenerationInline) !== null && _b !== void 0 ? _b : false;
         // Set defaults according to bitmark version
         if (this.bitmarkVersion === BitmarkVersion.v2) {
             if (this.options.cardSetVersion === undefined) {
@@ -112,55 +113,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
     //
@@ -169,13 +121,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.getBitConfig(bit.bitType);
         const bitResourcesConfig = Config.getBitResourcesConfig(bit.bitType, bit.resourceType);
@@ -213,7 +165,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.bitType,
@@ -246,9 +198,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.bitsValue)
             return;
         for (let i = 0; i < internalComment.length; i++) {
@@ -260,9 +213,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.bitsValue)
             return;
         const bit = parent === null || parent === void 0 ? void 0 : parent.value;
@@ -274,9 +228,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.bitsValue)
             return;
         const { url, mockupId, size, format, trim } = imageSource;
@@ -293,9 +248,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.bitsValue)
             return;
         const { name, avatarImage } = partner;
@@ -305,9 +261,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.markConfig)
             return;
         const { mark, color, emphasis } = markConfig;
@@ -322,16 +279,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
@@ -356,7 +313,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) {
@@ -364,7 +321,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
@@ -373,7 +330,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
@@ -387,7 +344,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
@@ -399,7 +356,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();
@@ -411,7 +368,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();
@@ -423,7 +380,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)
@@ -431,7 +388,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)
@@ -440,7 +397,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)
@@ -450,25 +407,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.answer) {
             this.writeNL();
             this.writeCardSetSideDivider();
@@ -481,8 +438,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.flashcardsValue)
             return;
         if (node.value) {
@@ -490,14 +448,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.alternativeAnswers)
             return;
         if (node.value) {
@@ -505,10 +464,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.trueFalse1);
         if (!isTrueFalse1) {
             this.writeNL();
@@ -516,11 +475,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();
@@ -533,15 +492,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();
@@ -554,15 +513,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();
@@ -574,183 +533,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.choices || right.key === 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.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.bitsValue) {
             // Bit poster image
             const posterImage = node.value;
@@ -768,7 +728,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'];
@@ -788,7 +748,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;
@@ -802,7 +763,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;
@@ -815,7 +776,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);
@@ -832,7 +794,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);
@@ -840,7 +802,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'
@@ -854,7 +817,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) {
@@ -864,7 +827,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) {
@@ -874,9 +837,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)
@@ -904,7 +868,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) {
@@ -912,7 +876,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) {
@@ -920,14 +884,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);
@@ -936,7 +900,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);
@@ -945,7 +909,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);
@@ -953,40 +917,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.questionsValue && (parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.flashcardsValue)
             return;
         if (node.value) {
@@ -999,29 +964,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.isOfBitType(bitType, [BitType.imageSeparator, BitType.pageBanner])) {
             this.writeProperty('zoomDisabled', node.value, undefined, false, true);
         }
@@ -1029,20 +994,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);
     }
@@ -1050,22 +1015,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.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);
     }
     //
@@ -1074,7 +1040,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) {
@@ -1106,12 +1072,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.bitsValue)
                     return;
                 // Write the property
@@ -1330,6 +1297,9 @@ class BitmarkGenerator {
         }
         this.writeString(tag);
     }
+    //
+    // Helper functions
+    //
     isWriteTextFormat(bitsValue, textFormatDefault) {
         const isDefault = TextFormat.fromValue(bitsValue) === textFormatDefault;
         const writeFormat = !isDefault || this.options.explicitTextFormat;
@@ -1351,12 +1321,6 @@ class BitmarkGenerator {
         }
         return undefined;
     }
-    getParentNode(route, nodesBack = 1) {
-        if (route.length > nodesBack + 1) {
-            return route[route.length - nodesBack - 1];
-        }
-        return undefined;
-    }
     //
     // Writer interface
     //