@gmb/bitmark-parser-generator 1.35.0 → 2.1.0

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

@@ -8,19 +8,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Ast } from '../../ast/Ast';
+import { Breakscape } from '../../breakscaping/Breakscape';
 import { Config } from '../../config/Config';
 import { NodeType } from '../../model/ast/NodeType';
 import { BitType } from '../../model/enum/BitType';
 import { BitmarkVersion, DEFAULT_BITMARK_VERSION } from '../../model/enum/BitmarkVersion';
 import { BodyBitType } from '../../model/enum/BodyBitType';
 import { CardSetVersion } from '../../model/enum/CardSetVersion';
-import { PropertyAstKey } from '../../model/enum/PropertyAstKey';
+import { PropertyFormat } from '../../model/enum/PropertyFormat';
 import { PropertyTag } from '../../model/enum/PropertyTag';
 import { ResourceTag } from '../../model/enum/ResourceTag';
 import { TextFormat } from '../../model/enum/TextFormat';
 import { BooleanUtils } from '../../utils/BooleanUtils';
 import { ObjectUtils } from '../../utils/ObjectUtils';
+import { StringUtils } from '../../utils/StringUtils';
 import { AstWalkerGenerator } from '../AstWalkerGenerator';
+import { TextGenerator } from '../text/TextGenerator';
 const DEFAULT_OPTIONS = {
     debugGenerationInline: false,
 };
@@ -50,6 +53,17 @@ class BitmarkGenerator extends AstWalkerGenerator {
         // State
         this.skipNLBetweenBitsValue = false;
         this.wroteSomething = false;
+        this.inTag = true;
+        // Keep TS happy
+        this.inTag;
+        // Bind callbacks
+        this.enter = this.enter.bind(this);
+        this.between = this.between.bind(this);
+        this.exit = this.exit.bind(this);
+        this.leaf = this.leaf.bind(this);
+        this.write = this.write.bind(this);
+        this.bodyBitCallback = this.bodyBitCallback.bind(this);
+        // Set options
         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;
@@ -66,11 +80,14 @@ class BitmarkGenerator extends AstWalkerGenerator {
         }
         // Calculate the prettify space
         this.prettifySpace = this.options.prettifyJson === true ? 2 : this.options.prettifyJson || undefined;
+        // Create the text generator
+        this.textGenerator = new TextGenerator(this.bitmarkVersion, {
+            writeCallback: this.write,
+            bodyBitCallback: this.bodyBitCallback,
+            debugGenerationInline: this.debugGenerationInline,
+        });
         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.generateResourceHandlers();
         this.generatePropertyHandlers();
     }
     /**
@@ -110,6 +127,7 @@ class BitmarkGenerator extends AstWalkerGenerator {
     resetState() {
         this.skipNLBetweenBitsValue = false;
         this.wroteSomething = false;
+        this.inTag = true;
         this.printed = false;
     }
     walkAndWrite(ast) {
@@ -140,12 +158,12 @@ class BitmarkGenerator extends AstWalkerGenerator {
         this.writeOPD(bit.bitLevel);
         if (bit.isCommented)
             this.writeString('|');
-        this.writeString(bit.bitType);
+        this.writeBreakscapedTagString(bit.bitType);
         if (bit.textFormat) {
             const write = this.isWriteTextFormat(bit.textFormat, bitConfig.textFormatDefault);
             if (write) {
                 this.writeColon();
-                this.writeString(bit.textFormat);
+                this.writeBreakscapedTagString(bit.textFormat);
             }
         }
         // Use the bitConfig to see if we need to write the resourceType attachment
@@ -168,10 +186,12 @@ class BitmarkGenerator extends AstWalkerGenerator {
         }
         if (resourceType) {
             this.writeAmpersand();
-            this.writeString(resourceType);
+            this.writeBreakscapedTagString(resourceType);
         }
         this.writeCL();
         this.writeNL();
+        // Continue traversal
+        return true;
     }
     between_bitsValue(node, left, right, route) {
         // The following keys are combined with other keys so don't need newlines
@@ -192,14 +212,20 @@ class BitmarkGenerator extends AstWalkerGenerator {
         // 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;
+            return true;
         for (let i = 0; i < internalComment.length; i++) {
             const comment = internalComment[i];
             const last = i === internalComment.length - 1;
-            this.writeProperty('internalComment', comment);
+            this.writeProperty('internalComment', comment, {
+                format: PropertyFormat.trimmedString,
+                single: false,
+                ignoreEmpty: true,
+            });
             if (!last)
                 this.writeNL();
         }
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> labelTrue / labelFalse
     enter_labelTrue(node, route) {
@@ -207,14 +233,24 @@ class BitmarkGenerator extends AstWalkerGenerator {
         // 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;
+            return true;
         const bit = parent === null || parent === void 0 ? void 0 : parent.value;
         if (bit) {
             if (value != '')
-                this.writeProperty(PropertyTag.labelTrue, value, true);
+                this.writeProperty(PropertyTag.labelTrue, value, {
+                    format: PropertyFormat.trimmedString,
+                    single: true,
+                    ignoreEmpty: true,
+                });
             if (bit.labelFalse && bit.labelFalse[0] != '')
-                this.writeProperty(PropertyTag.labelFalse, bit.labelFalse, true);
+                this.writeProperty(PropertyTag.labelFalse, bit.labelFalse, {
+                    format: PropertyFormat.trimmedString,
+                    single: true,
+                    ignoreEmpty: true,
+                });
         }
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> imageSource
     enter_imageSource(node, route) {
@@ -222,19 +258,41 @@ class BitmarkGenerator extends AstWalkerGenerator {
         // 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;
+            return true;
         const { url, mockupId, size, format, trim } = imageSource;
-        this.writeProperty('imageSource', url, true);
+        this.writeProperty('imageSource', url, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
         if (url) {
             if (mockupId)
-                this.writeProperty('mockupId', mockupId, true);
+                this.writeProperty('mockupId', mockupId, {
+                    format: PropertyFormat.trimmedString,
+                    single: true,
+                    ignoreEmpty: true,
+                });
             if (size)
-                this.writeProperty('size', size, true);
+                this.writeProperty('size', size, {
+                    format: PropertyFormat.trimmedString,
+                    single: true,
+                    ignoreEmpty: true,
+                });
             if (format)
-                this.writeProperty('format', format, true);
+                this.writeProperty('format', format, {
+                    format: PropertyFormat.trimmedString,
+                    single: true,
+                    ignoreEmpty: true,
+                });
             if (BooleanUtils.isBoolean(trim))
-                this.writeProperty('trim', trim, true);
+                this.writeProperty('trim', trim, {
+                    format: PropertyFormat.trimmedString,
+                    single: true,
+                    ignoreEmpty: true,
+                });
         }
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> technicalTerm
     enter_technicalTerm(node, route) {
@@ -242,11 +300,22 @@ class BitmarkGenerator extends AstWalkerGenerator {
         // 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;
+            return true;
         const { technicalTerm, lang } = nodeValue;
-        this.writeProperty('technicalTerm', technicalTerm, true);
-        if (lang != null)
-            this.writeProperty('lang', lang);
+        this.writeProperty('technicalTerm', technicalTerm, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
+        if (lang != null) {
+            this.writeProperty('lang', lang, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: true,
+            });
+        }
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> servings
     enter_servings(node, route) {
@@ -254,17 +323,52 @@ class BitmarkGenerator extends AstWalkerGenerator {
         // 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 { servings, unit, unitAbbr, decimalPlaces, disableCalculation } = nodeValue;
-        this.writeProperty('servings', servings, true);
-        if (unit != null)
-            this.writeProperty('unit', unit);
-        if (unitAbbr != null)
-            this.writeProperty('unitAbbr', unitAbbr);
-        if (decimalPlaces != null)
-            this.writeProperty('decimalPlaces', decimalPlaces);
-        if (disableCalculation != null)
-            this.writeProperty('disableCalculation', disableCalculation);
+            return true;
+        const { servings, unit, unitAbbr, decimalPlaces, disableCalculation, hint } = nodeValue;
+        this.writeProperty('servings', servings, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
+        if (unit != null) {
+            this.writeProperty('unit', unit, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: true,
+            });
+        }
+        if (unitAbbr != null) {
+            this.writeProperty('unitAbbr', unitAbbr, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: true,
+            });
+        }
+        if (decimalPlaces != null) {
+            this.writeProperty('decimalPlaces', decimalPlaces, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: true,
+            });
+        }
+        if (disableCalculation != null) {
+            this.writeProperty('disableCalculation', disableCalculation, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: true,
+            });
+        }
+        if (hint != null) {
+            this.writeOPQ();
+            this.writeBreakscapedTagString(hint);
+            this.writeCL();
+            // this.writeProperty('hint', hint, {
+            //   format: PropertyFormat.trimmedString,
+            //   single: true,
+            //   ignoreEmpty: true,
+            // });
+        }
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> person
     enter_person(node, route) {
@@ -272,15 +376,25 @@ class BitmarkGenerator extends AstWalkerGenerator {
         // 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;
+            return true;
         const { name, title, avatarImage } = person;
-        this.writeProperty('person', name, true);
+        this.writeProperty('person', name, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
         if (title) {
-            this.writeProperty('title', title, true);
+            this.writeProperty('title', title, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: true,
+            });
         }
         if (avatarImage) {
-            this.writeResource(avatarImage);
+            this.writeResource(ResourceTag.image, avatarImage.src);
         }
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> ratingLevelStart
     enter_ratingLevelStart(node, route) {
@@ -300,45 +414,110 @@ class BitmarkGenerator extends AstWalkerGenerator {
         // 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;
+            return true;
         const { level, label } = n;
         const levelKey = node.key === NodeType.ratingLevelStart ? PropertyTag.ratingLevelStart : PropertyTag.ratingLevelEnd;
-        this.writeProperty(levelKey, level, true);
+        this.writeProperty(levelKey, level, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
         if (label) {
-            this.writeProperty('label', label, true);
+            this.writeProperty('label', label, {
+                format: PropertyFormat.bitmarkMinusMinus,
+                single: true,
+                ignoreEmpty: true,
+            });
         }
+        return false;
+    }
+    // bitmarkAst -> bits -> bitsValue -> markConfig
+    enter_markConfig(_node, _route) {
+        // Handler so markConfig is not processed by the default property handler
+        // Continue traversal
+        return true;
     }
-    // bitmarkAst -> bits -> bitsValue -> markConfigValue
+    // bitmarkAst -> bits -> bitsValue -> markConfig -> markConfigValue
     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;
+            return true;
         const { mark, color, emphasis } = markConfig;
         if (mark) {
-            this.writeProperty('mark', mark, true);
-            if (color)
-                this.writeProperty('color', color, true);
-            if (emphasis)
-                this.writeProperty('emphasis', emphasis, true);
+            this.writeProperty('mark', mark, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: true,
+            });
+            if (color) {
+                this.writeProperty('color', color, {
+                    format: PropertyFormat.trimmedString,
+                    single: true,
+                    ignoreEmpty: true,
+                });
+            }
+            if (emphasis) {
+                this.writeProperty('emphasis', emphasis, {
+                    format: PropertyFormat.trimmedString,
+                    single: true,
+                    ignoreEmpty: true,
+                });
+            }
             this.writeNL();
         }
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> partialAnswer
+    enter_partialAnswer(node, _route) {
+        this.writeProperty('partialAnswer', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
+        // Stop traversal of this branch
+        return false;
+    }
     // bitmarkAst -> bits -> bitsValue -> questions -> questionsValue -> partialAnswer
     leaf_partialAnswer(node, _route) {
-        this.writeProperty('partialAnswer', node.value);
+        this.writeProperty('partialAnswer', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> sampleSolution
     // bitmarkAst -> bits -> bitsValue -> questions -> questionsValue -> sampleSolution
+    enter_sampleSolution(node, _route) {
+        this.writeProperty('sampleSolution', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
+        // Stop traversal of this branch
+        return false;
+    }
     leaf_sampleSolution(node, _route) {
-        this.writeProperty('sampleSolution', node.value);
+        this.writeProperty('sampleSolution', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> reasonableNumOfChars
     // bitmarkAst -> bits -> bitsValue -> questions -> questionsValue -> reasonableNumOfChars
     leaf_reasonableNumOfChars(node, _route) {
-        this.writeProperty('reasonableNumOfChars', node.value);
+        this.writeProperty('reasonableNumOfChars', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     // bitmarkAst -> bits -> bitsValue -> questions -> questionsValue -> additionalSolutions
     between_additionalSolutions(_node, _left, _right, route) {
@@ -354,60 +533,244 @@ class BitmarkGenerator extends AstWalkerGenerator {
         const parent = this.getParentNode(route, 2);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.questionsValue)
             return;
-        this.writeProperty('additionalSolutions', node.value);
-    }
-    // bitmarkAst -> bits -> bitsValue -> itemLead
-    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
-            this.writeOPC();
-            this.writeString(itemLead.item || '');
-            this.writeCL();
-            if (itemLead.lead || itemLead.pageNumber || itemLead.marginNumber) {
-                this.writeOPC();
-                this.writeString(itemLead.lead || '');
-                this.writeCL();
-            }
-            if (itemLead.pageNumber || itemLead.marginNumber) {
-                this.writeOPC();
-                this.writeString(itemLead.pageNumber || '');
-                this.writeCL();
-            }
-            if (itemLead.marginNumber) {
-                this.writeOPC();
-                this.writeString(itemLead.marginNumber || '');
-                this.writeCL();
-            }
-        }
+        this.writeProperty('additionalSolutions', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: false,
+        });
+    }
+    // bitmarkAst -> bits -> bitsValue -> item
+    enter_item(node, route) {
+        var _a, _b, _c;
+        const item = node.value;
+        const parent = this.getParentNode(route);
+        if (this.isEmptyText(item))
+            return false; // Ignore empty
+        if (!this.isEmptyText((_a = parent === null || parent === void 0 ? void 0 : parent.value) === null || _a === void 0 ? void 0 : _a.lead))
+            return true; // Will be handled by lead
+        if (!this.isEmptyText((_b = parent === null || parent === void 0 ? void 0 : parent.value) === null || _b === void 0 ? void 0 : _b.pageNumber))
+            return true; // Will be handled by pageNumber
+        if (!this.isEmptyText((_c = parent === null || parent === void 0 ? void 0 : parent.value) === null || _c === void 0 ? void 0 : _c.marginNumber))
+            return true; // Will be handled by marginNumber
+        this.writeOPC();
+        this.textGenerator.generateSync(item, TextFormat.bitmarkMinusMinus);
+        this.writeCL();
+        return true;
+    }
+    // bitmarkAst -> bits -> bitsValue -> lead
+    enter_lead(node, route) {
+        var _a, _b, _c, _d;
+        const lead = node.value;
+        const parent = this.getParentNode(route);
+        if (this.isEmptyText(lead))
+            return false; // Ignore empty
+        if (!this.isEmptyText((_a = parent === null || parent === void 0 ? void 0 : parent.value) === null || _a === void 0 ? void 0 : _a.pageNumber))
+            return true; // Will be handled by pageNumber
+        if (!this.isEmptyText((_b = parent === null || parent === void 0 ? void 0 : parent.value) === null || _b === void 0 ? void 0 : _b.marginNumber))
+            return true; // Will be handled by marginNumber
+        this.writeOPC();
+        this.textGenerator.generateSync((_d = (_c = parent === null || parent === void 0 ? void 0 : parent.value) === null || _c === void 0 ? void 0 : _c.item) !== null && _d !== void 0 ? _d : '', TextFormat.bitmarkMinusMinus);
+        this.writeCL();
+        this.writeOPC();
+        this.textGenerator.generateSync(lead, TextFormat.bitmarkMinusMinus);
+        this.writeCL();
+        return true;
+    }
+    // bitmarkAst -> bits -> bitsValue -> pageNumber
+    enter_pageNumber(node, route) {
+        var _a, _b, _c, _d, _e;
+        const pageNumber = node.value;
+        const parent = this.getParentNode(route);
+        if (this.isEmptyText(pageNumber))
+            return false; // Ignore empty
+        if (!this.isEmptyText((_a = parent === null || parent === void 0 ? void 0 : parent.value) === null || _a === void 0 ? void 0 : _a.marginNumber))
+            return true; // Will be handled by marginNumber
+        this.writeOPC();
+        this.textGenerator.generateSync((_c = (_b = parent === null || parent === void 0 ? void 0 : parent.value) === null || _b === void 0 ? void 0 : _b.item) !== null && _c !== void 0 ? _c : '', TextFormat.bitmarkMinusMinus);
+        this.writeCL();
+        this.writeOPC();
+        this.textGenerator.generateSync((_e = (_d = parent === null || parent === void 0 ? void 0 : parent.value) === null || _d === void 0 ? void 0 : _d.lead) !== null && _e !== void 0 ? _e : '', TextFormat.bitmarkMinusMinus);
+        this.writeCL();
+        this.writeOPC();
+        this.textGenerator.generateSync(pageNumber !== null && pageNumber !== void 0 ? pageNumber : '', TextFormat.bitmarkMinusMinus);
+        this.writeCL();
+        return true;
+    }
+    // bitmarkAst -> bits -> bitsValue -> marginNumber
+    enter_marginNumber(node, route) {
+        var _a, _b, _c, _d, _e, _f;
+        const marginNumber = node.value;
+        const parent = this.getParentNode(route);
+        if (this.isEmptyText(marginNumber))
+            return false; // Ignore empty
+        this.writeOPC();
+        this.textGenerator.generateSync((_b = (_a = parent === null || parent === void 0 ? void 0 : parent.value) === null || _a === void 0 ? void 0 : _a.item) !== null && _b !== void 0 ? _b : '', TextFormat.bitmarkMinusMinus);
+        this.writeCL();
+        this.writeOPC();
+        this.textGenerator.generateSync((_d = (_c = parent === null || parent === void 0 ? void 0 : parent.value) === null || _c === void 0 ? void 0 : _c.lead) !== null && _d !== void 0 ? _d : '', TextFormat.bitmarkMinusMinus);
+        this.writeCL();
+        this.writeOPC();
+        this.textGenerator.generateSync((_f = (_e = parent === null || parent === void 0 ? void 0 : parent.value) === null || _e === void 0 ? void 0 : _e.pageNumber) !== null && _f !== void 0 ? _f : '', TextFormat.bitmarkMinusMinus);
+        this.writeCL();
+        this.writeOPC();
+        this.textGenerator.generateSync(marginNumber, TextFormat.bitmarkMinusMinus);
+        this.writeCL();
+        return true;
     }
     // bitmarkAst -> bits -> bitsValue -> body
     enter_body(node, route) {
+        var _a;
+        // 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 && (parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.cardBitsValue)
+            return true;
+        this.inTag = false;
         // always write a NL before the body content if there is any?
         const body = node.value;
-        if ((body.bodyParts && body.bodyParts.length > 0) || body.bodyJson) {
+        const textFormat = this.getTextFormat(route);
+        const isBitmarkText = textFormat === TextFormat.bitmarkPlusPlus || textFormat === TextFormat.bitmarkMinusMinus;
+        // Handle body
+        if (textFormat === TextFormat.json) {
+            const json = (_a = body.body) !== null && _a !== void 0 ? _a : null;
+            if (Array.isArray(json) || ObjectUtils.isObject(json)) {
+                const text = JSON.stringify(json, null, this.prettifySpace);
+                if (text) {
+                    this.writeNL();
+                    this.writePlainTextDivider();
+                    this.writeNL();
+                    this.write(Breakscape.breakscape(text, {
+                        textFormat: TextFormat.text,
+                    }));
+                }
+            }
+        }
+        else if (isBitmarkText) {
+            // handle bitmark text
             this.writeNL();
-            // Write the plain text divider if not bitmark++/-- format
-            const textFormat = this.getTextFormat(route);
+            // The text generator will write to the writer
+            const b = (Array.isArray(body.body) ? body.body : []);
+            this.textGenerator.generateSync(b, textFormat);
+        }
+        else {
+            // handle plain text
+            this.writeNL();
+            this.writePlainTextDivider();
+            this.writeNL();
+            const s = (StringUtils.isString(body.body) ? body.body : '');
+            this.write(Breakscape.breakscape(`${s}`, {
+                textFormat: TextFormat.text,
+            }));
+            this.writeNL();
+        }
+        // Stop traversal of this branch
+        return false;
+        // if ((body.body && body.body.length > 0) || body.bodyJson) {
+        //   this.writeNL();
+        //   // Write the plain text divider if not bitmark++/-- format
+        //   const textFormat = this.getTextFormat(route);
+        //   const isBitmarkText = textFormat === TextFormat.bitmarkPlusPlus || textFormat === TextFormat.bitmarkMinusMinus;
+        //   if (!isBitmarkText) {
+        //     this.writePlainTextDivider();
+        //     this.writeNL();
+        //   }
+        // }
+    }
+    exit_body(_node, _route) {
+        this.inTag = true;
+    }
+    bodyBitCallback(bodyBit, _index, _route) {
+        // console.log('bodyBitCallback', bodyBit, index, route);
+        var _a;
+        // Walk the body bit AST
+        const nodeType = (_a = NodeType.fromValue(bodyBit.type)) !== null && _a !== void 0 ? _a : NodeType.bodyBit;
+        this.ast.walk(bodyBit, nodeType, this, undefined);
+        return ''; // Return empty string as we are writing to the writer
+    }
+    // bodyBit -> gap
+    enter_gap(node, _route) {
+        const gap = node.value;
+        if (gap.solutions && gap.solutions.length === 0) {
+            // If there are no solutions, we need to write the special cloze gap [_] to indicate this
+            this.writeOPU();
+            this.writeCL();
+        }
+        else {
+            for (const solution of gap.solutions) {
+                this.writeOPU();
+                this.writeBreakscapedTagString(solution);
+                this.writeCL();
+            }
+        }
+        // Continue traversal
+        return true;
+    }
+    // bodyBit -> mark
+    enter_mark(node, _route) {
+        const mark = node.value;
+        this.writeOPE();
+        this.writeBreakscapedTagString(mark.solution);
+        this.writeCL();
+        // Continue traversal
+        return true;
+    }
+    // bodyBit -> select
+    enter_select(_node, _route) {
+        // Continue traversal
+        return true;
+    }
+    // bodyBit -> highlight
+    enter_highlight(_node, _route) {
+        // Continue traversal
+        return true;
+    }
+    // bitmarkAst -> bits -> footer
+    enter_footer(node, route) {
+        const parent = this.getParentNode(route);
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return true;
+        const footer = node.value;
+        const textFormat = this.getTextFormat(route);
+        // Handle footer
+        if (textFormat === TextFormat.json) {
+            // Json footer?!
+            // Not valid, ignore
+        }
+        else if (footer.footer && footer.footer.length > 0) {
             const isBitmarkText = textFormat === TextFormat.bitmarkPlusPlus || textFormat === TextFormat.bitmarkMinusMinus;
-            if (!isBitmarkText) {
-                this.writePlainTextDivider();
+            if (isBitmarkText) {
+                // handle bitmark text
+                this.write('~~~~');
                 this.writeNL();
+                // The text generator will write to the writer
+                this.textGenerator.generateSync(footer.footer, TextFormat.text);
+            }
+            else {
+                // Plain text footer?!
+                // Not valid, ignore (plain text cannot have a card set / footer marker, so cannot have a footer!
             }
         }
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> body -> bodyParts -> bodyPartsValue -> data -> solutions
-    enter_solutions(node, _route) {
+    enter_solutions(node, route) {
+        const parent = this.getParentNode(route);
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return true;
         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();
         }
+        // Continue traversal
+        return true;
     }
     // bitmarkAst -> bits -> bitsValue -> body -> bodyParts -> bodyPartsValue -> data -> solution
     leaf_solution(node, route) {
         var _a;
+        const parent = this.getParentNode(route);
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return;
         const solution = node.value;
         // Ignore values that are not at the correct level as they might be handled elsewhere
         const bodyPartsValue = (_a = this.getParentNode(route, 2)) === null || _a === void 0 ? void 0 : _a.value;
@@ -415,20 +778,22 @@ class BitmarkGenerator extends AstWalkerGenerator {
             return;
         if (solution) {
             this.writeOPE();
-            this.writeString(solution);
+            this.writeBreakscapedTagString(solution);
             this.writeCL();
         }
     }
-    // bitmarkAst -> bits -> bitsValue -> body -> bodyParts -> bodyPartsValue -> data -> mark
+    // bitmarkAst -> bits -> bitsValue -> body -> bodyBit -> mark -> mark
     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
-        const bodyPartsValue = (_a = this.getParentNode(route, 2)) === null || _a === void 0 ? void 0 : _a.value;
-        if ((bodyPartsValue === null || bodyPartsValue === void 0 ? void 0 : bodyPartsValue.type) !== BodyBitType.mark)
+        const root = route[0];
+        if ((root === null || root === void 0 ? void 0 : root.key) !== NodeType.mark)
             return;
+        const mark = node.value;
         if (mark) {
-            this.writeProperty('mark', mark, true);
+            this.writeProperty('mark', mark, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: true,
+            });
         }
     }
     // bitmarkAst -> bits -> bitsValue -> body -> bodyParts -> bodyPartsValue -> data -> options -> optionsValue
@@ -442,6 +807,8 @@ class BitmarkGenerator extends AstWalkerGenerator {
         }
         this.write(selectOption.text);
         this.writeCL();
+        // Continue traversal
+        return true;
     }
     // bitmarkAst -> bits -> bitsValue -> body -> bodyParts -> bodyPartsValue -> data -> texts -> textsValue
     enter_textsValue(node, _route) {
@@ -454,15 +821,19 @@ class BitmarkGenerator extends AstWalkerGenerator {
         }
         this.write(highlightText.text);
         this.writeCL();
+        // Continue traversal
+        return true;
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode
     enter_cardNode(_node, route) {
         // Ignore cards for xxx-1
         const isBitType1 = this.isOfBitType1(route);
         if (isBitType1)
-            return;
+            return true;
         this.writeCardSetStart();
         this.writeNL();
+        // Continue traversal
+        return true;
     }
     between_cardNode(_node, _left, _right, route) {
         // Ignore cards for xxx-1
@@ -504,26 +875,29 @@ class BitmarkGenerator extends AstWalkerGenerator {
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> flashcards -> flashcardsValue
     between_flashcardsValue(_node, _left, right, _route) {
+        var _a;
         if (right.key === NodeType.answer) {
             this.writeNL();
             this.writeCardSetSideDivider();
             this.writeNL();
         }
-        else if (right.key === NodeType.alternativeAnswers) {
+        else if (right.key === NodeType.alternativeAnswers && ((_a = right.value) === null || _a === void 0 ? void 0 : _a.length) !== 0) {
             this.writeNL();
             this.writeCardSetVariantDivider();
             this.writeNL();
         }
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> flashcards -> flashcardsValue -> answer
-    leaf_answer(node, route) {
+    enter_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;
+            return true;
         if (node.value) {
-            this.writeString(node.value);
+            this.textGenerator.generateSync(node.value, TextFormat.bitmarkMinusMinus);
         }
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> flashcards -> flashcardsValue -> alternativeAnswers
     between_alternativeAnswers(_node, _route) {
@@ -532,30 +906,38 @@ class BitmarkGenerator extends AstWalkerGenerator {
         this.writeNL();
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> flashcards -> flashcardsValue -> alternativeAnswers -> alternativeAnswersValue
-    leaf_alternativeAnswersValue(node, route) {
+    enter_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;
+            return true;
         if (node.value) {
-            this.writeString(node.value);
+            // this.writeBreakscapedTagString(node.value);
+            this.textGenerator.generateSync(node.value, TextFormat.bitmarkMinusMinus);
         }
+        // Stop traversal of this branch
+        return false;
     }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> definitions -> definitionsValue -> alternativeDefinitions
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> definitions -> definitionsValue -> alternativeDefintions
     between_alternativeDefinitions(_node, _route) {
         this.writeNL();
         this.writeCardSetVariantDivider();
         this.writeNL();
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> definitions -> definitionsValue -> alternativeDefinitions -> alternativeDefinitionsValue
-    leaf_alternativeDefinitionsValue(node, route) {
-        // Ignore responses that are not at the alternativeDefinitions level as they are handled elsewhere
+    enter_alternativeDefinitionsValue(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.alternativeDefinitions)
-            return;
+            return true;
         if (node.value) {
-            this.writeString(node.value);
+            // this.writeNL();
+            // this.writeCardSetVariantDivider();
+            // this.writeNL();
+            this.textGenerator.generateSync(node.value, TextFormat.bitmarkMinusMinus);
         }
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> statements
     enter_statements(_node, _route) {
@@ -581,8 +963,10 @@ class BitmarkGenerator extends AstWalkerGenerator {
         else {
             this.writeOPM();
         }
-        this.write(statement.text);
+        this.write(statement.statement);
         this.writeCL();
+        // Continue traversal
+        return true;
     }
     // bitmarkAst -> bits -> bitsValue -> choices
     // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> choices
@@ -602,8 +986,10 @@ class BitmarkGenerator extends AstWalkerGenerator {
         else {
             this.writeOPM();
         }
-        this.write(choice.text);
+        this.write(choice.choice);
         this.writeCL();
+        // Continue traversal
+        return true;
     }
     // bitmarkAst -> bits -> bitsValue -> responses
     // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes -> quizzesValue -> responses
@@ -623,8 +1009,10 @@ class BitmarkGenerator extends AstWalkerGenerator {
         else {
             this.writeOPM();
         }
-        this.write(response.text);
+        this.write(response.response);
         this.writeCL();
+        // Continue traversal
+        return true;
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> quizzes
     enter_quizzes(_node, _route) {
@@ -688,13 +1076,17 @@ class BitmarkGenerator extends AstWalkerGenerator {
     enter_keyAudio(node, _route) {
         const resource = node.value;
         // This is a resource, so handle it with the common code
-        this.writeResource(resource);
+        this.writeResource(ResourceTag.audio, resource.src);
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> pairs -> pairsValue -> keyImage
     enter_keyImage(node, _route) {
         const resource = node.value;
         // This is a resource, so handle it with the common code
-        this.writeResource(resource);
+        this.writeResource(ResourceTag.image, resource.src);
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> matrix
     enter_matrix(_node, _route) {
@@ -733,8 +1125,8 @@ class BitmarkGenerator extends AstWalkerGenerator {
         this.writeCardSetCardDivider();
         this.writeNL();
     }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> table -> rows
-    between_rows(_node, _left, _right, route) {
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> table -> data
+    between_data(_node, _left, _right, route) {
         const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.table)
             return;
@@ -758,20 +1150,23 @@ class BitmarkGenerator extends AstWalkerGenerator {
     leaf_columnsValue(node, _route) {
         this.writeOPHASH();
         if (node.value)
-            this.writeString(node.value);
+            this.writeBreakscapedTagString(node.value);
         this.writeCL();
     }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> table -> rows -> rowsValue
-    between_rowsValue(_node, _left, _right, route) {
-        const parent = this.getParentNode(route);
-        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.rows)
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> table -> data -> dataValue
+    between_dataValue(_node, _left, _right, route) {
+        const parent = this.getParentNode(route, 2);
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.table)
             return;
         this.writeNL();
         this.writeCardSetSideDivider();
         this.writeNL();
     }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> table -> rows -> rowsValue -> rowsValueValue
-    leaf_rowsValueValue(node, _route) {
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> table -> data -> dataValue -> dataValueValue
+    leaf_dataValueValue(node, route) {
+        const parent = this.getParentNode(route, 3);
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.table)
+            return;
         if (node.value)
             this.write(node.value);
     }
@@ -800,23 +1195,49 @@ class BitmarkGenerator extends AstWalkerGenerator {
     //   this.writeCardSetSideDivider();
     //   this.writeNL();
     // }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> captionDefinitionList -> definitions -> definitionsValue -> term
     // bitmarkAst -> bits -> bitsValue -> cardNode -> definitions -> definitionsValue -> term
+    enter_term(node, route) {
+        const parent = this.getParentNode(route);
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.definitionsValue)
+            return true;
+        if (node.value) {
+            this.textGenerator.generateSync(node.value, TextFormat.bitmarkMinusMinus);
+        }
+        // Stop traversal of this branch
+        return false;
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> captionDefinitionList -> definitions -> definitionsValue -> term
     leaf_term(node, route) {
         const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.definitionsValue)
-            return;
-        if (node.value)
+            return true;
+        if (node.value) {
             this.write(node.value);
+        }
+        // Stop traversal of this branch
+        return false;
     }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> captionDefinitionList -> definitions -> definitionsValue -> description
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> definitions -> definitionsValue -> description
-    leaf_description(node, route) {
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> definitions -> definitionsValue -> definition
+    enter_definition(node, route) {
         const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.definitionsValue)
-            return;
-        if (node.value)
+            return true;
+        if (node.value) {
+            this.textGenerator.generateSync(node.value, TextFormat.bitmarkMinusMinus);
+        }
+        // Stop traversal of this branch
+        return false;
+    }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> captionDefinitionList -> definitions -> definitionsValue -> definition
+    leaf_definition(node, route) {
+        const parent = this.getParentNode(route);
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.definitionsValue)
+            return true;
+        if (node.value) {
             this.write(node.value);
+        }
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> captionDefinitionList -> definitions
     // bitmarkAst -> bits -> bitsValue -> cardNode -> definitions
@@ -828,23 +1249,37 @@ class BitmarkGenerator extends AstWalkerGenerator {
         this.writeCardSetCardDivider();
         this.writeNL();
     }
-    // bitmarkAst -> bits -> bitsValue -> cardNode -> captionDefinitionList -> definitions -> definitionsValue
     // bitmarkAst -> bits -> bitsValue -> cardNode -> definitions -> definitionsValue
     between_definitionsValue(_node, _left, right, route) {
+        var _a;
         const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.definitions)
             return;
-        if (right.key === NodeType.description) {
+        if (right.key === NodeType.definition) {
             this.writeNL();
             this.writeCardSetSideDivider();
             this.writeNL();
         }
-        else if (right.key === NodeType.alternativeDefinitions) {
+        else if (right.key === NodeType.alternativeDefinitions && ((_a = right.value) === null || _a === void 0 ? void 0 : _a.length) > 0) {
             this.writeNL();
             this.writeCardSetVariantDivider();
             this.writeNL();
         }
     }
+    // bitmarkAst -> bits -> bitsValue -> cardNode -> captionDefinitionList -> definitions -> definitionsValue
+    // protected between_definitionsValue(_node: NodeInfo, _left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void {
+    //   const parent = this.getParentNode(route);
+    //   if (parent?.key !== NodeType.definitions) return;
+    //   if (right.key === NodeType.definition) {
+    //     this.writeNL();
+    //     this.writeCardSetSideDivider();
+    //     this.writeNL();
+    //   } else if (right.key === NodeType.alternativeDefinitions && right.value?.length > 0) {
+    //     this.writeNL();
+    //     this.writeCardSetVariantDivider();
+    //     this.writeNL();
+    //   }
+    // }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> questions
     enter_questions(_node, _route) {
         //
@@ -884,7 +1319,7 @@ class BitmarkGenerator extends AstWalkerGenerator {
         const ingredient = node.value;
         if (ingredient.title != null) {
             this.writeOPHASH();
-            this.writeString(ingredient.title);
+            this.writeBreakscapedTagString(ingredient.title);
             this.writeCL();
             this.writeNL();
         }
@@ -899,24 +1334,42 @@ class BitmarkGenerator extends AstWalkerGenerator {
         // [!43]
         if (ingredient.quantity != null) {
             this.writeOPB();
-            this.writeString(`${ingredient.quantity}`);
+            this.writeBreakscapedTagString(`${ingredient.quantity}`);
             this.writeCL();
         }
         // [@unit:kilograms]
         if (ingredient.unit != null)
-            this.writeProperty('unit', ingredient.unit, true);
+            this.writeProperty('unit', ingredient.unit, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: true,
+            });
         // [@unitAbbr:kg]
         if (ingredient.unitAbbr != null)
-            this.writeProperty('unitAbbr', ingredient.unitAbbr, true);
+            this.writeProperty('unitAbbr', ingredient.unitAbbr, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: true,
+            });
         // [@decimalPlaces:1]
         if (ingredient.decimalPlaces != null)
-            this.writeProperty('decimalPlaces', ingredient.decimalPlaces, true);
+            this.writeProperty('decimalPlaces', ingredient.decimalPlaces, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: true,
+            });
         // [@disableCalculation]
         if (ingredient.disableCalculation)
-            this.writeProperty('disableCalculation', true, true);
+            this.writeProperty('disableCalculation', true, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: true,
+            });
         // item
         if (ingredient.item != null)
             this.write(ingredient.item);
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses
     enter_botResponses(_node, _route) {
@@ -949,37 +1402,42 @@ class BitmarkGenerator extends AstWalkerGenerator {
         //
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses -> botResponsesValue -> response
-    leaf_response(node, _route) {
+    leaf_response(node, route) {
+        const parent = this.getParentNode(route);
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.botResponsesValue)
+            return;
         this.writeOPB();
-        this.writeString(node.value);
+        this.writeBreakscapedTagString(node.value);
         this.writeCL();
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses -> botResponsesValue -> reaction
-    leaf_reaction(node, _route) {
-        this.writeProperty('reaction', node.value, true);
+    leaf_reaction(node, route) {
+        const parent = this.getParentNode(route);
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.botResponsesValue)
+            return;
+        this.writeProperty('reaction', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     // bitmarkAst -> bits -> bitsValue -> cardNode -> botResponses -> botResponsesValue -> feedback
-    leaf_feedback(node, _route) {
+    leaf_feedback(node, route) {
+        const parent = this.getParentNode(route);
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.botResponsesValue)
+            return;
         const feeback = node.value;
         if (feeback) {
             this.write(feeback);
         }
     }
-    // bitmarkAst -> bits -> bitsValue -> resources
-    between_resources(_node, _left, _right, _route) {
-        this.writeNL();
-    }
-    // bitmarkAst -> bits -> bitsValue -> resourcesValue
-    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 -> imagePlaceholder
     enter_imagePlaceholder(node, _route) {
         const resource = node.value;
         // This is a resource, so handle it with the common code
         this.writePropertyStyleResource(node.key, resource);
+        // Continue traversal
+        return true;
     }
     exit_imagePlaceholder(_node, _route) {
         this.writeNL();
@@ -992,16 +1450,26 @@ class BitmarkGenerator extends AstWalkerGenerator {
             // Bit poster image
             const posterImage = node.value;
             if (posterImage) {
-                this.writeProperty('posterImage', posterImage);
+                this.writeProperty('posterImage', posterImage, {
+                    format: PropertyFormat.trimmedString,
+                    single: true,
+                    ignoreEmpty: true,
+                });
             }
         }
         else {
             // Resource poster image
             const posterImage = node.value;
-            if (posterImage && posterImage.value) {
-                this.writeProperty('posterImage', posterImage.value);
+            if (posterImage && posterImage.src) {
+                this.writeProperty('posterImage', posterImage.src, {
+                    format: PropertyFormat.trimmedString,
+                    single: true,
+                    ignoreEmpty: true,
+                });
             }
         }
+        // Continue traversal
+        return true;
     }
     // bitmarkAst -> bits -> bitsValue -> resource -> thumbnails
     // [src1x,src2x,src3x,src4x,width,height,alt,zoomDisabled,caption]
@@ -1015,21 +1483,24 @@ class BitmarkGenerator extends AstWalkerGenerator {
                     break;
                 const thumbnail = thumbnails[i];
                 const key = thumbnailKeys[i];
-                this.writeProperty(key, thumbnail.value, true);
+                this.writeProperty(key, thumbnail.src, {
+                    format: PropertyFormat.trimmedString,
+                    single: true,
+                    ignoreEmpty: true,
+                });
             }
         }
+        // Stop traversal of this branch
+        return false;
     }
-    //
-    // Terminal nodes (leaves)
-    //
     // bitmarkAst -> bits -> bitsValue -> bitType
     // bitmarkAst -> bits -> bitsValue -> textFormat
     //  bitmarkAst -> bits -> title
-    leaf_title(node, route) {
-        const parent = this.getParentNode(route);
+    enter_title(node, route) {
         // Ensure this is at the bit level
+        const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
-            return;
+            return true;
         const value = node.value;
         const title = value;
         const bit = parent === null || parent === void 0 ? void 0 : parent.value;
@@ -1038,12 +1509,18 @@ class BitmarkGenerator extends AstWalkerGenerator {
             this.writeOP();
             for (let i = 0; i < +level; i++)
                 this.writeHash();
-            this.writeString(title);
+            this.textGenerator.generateSync(title, TextFormat.bitmarkMinusMinus);
             this.writeCL();
         }
+        // Stop traversal of this branch
+        return false;
     }
     //  bitmarkAst -> bits -> subtitle
-    leaf_subtitle(node, _route) {
+    enter_subtitle(node, route) {
+        // Ensure this is at the bit level
+        const parent = this.getParentNode(route);
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return true;
         const value = node.value;
         const subtitle = value;
         const level = 2;
@@ -1051,23 +1528,61 @@ class BitmarkGenerator extends AstWalkerGenerator {
             this.writeOP();
             for (let i = 0; i < level; i++)
                 this.writeHash();
-            this.writeString(subtitle);
+            this.textGenerator.generateSync(subtitle, TextFormat.bitmarkMinusMinus);
             this.writeCL();
         }
+        // Stop traversal of this branch
+        return false;
+    }
+    // bitmarkAst -> bits -> bitsValue -> book (array)
+    // bitmarkAst -> bits -> bitsValue -> book (array) -> bookValue
+    enter_book(_node, _route) {
+        // Block standard property handling
+    }
+    between_book(_node, _route) {
+        this.writeNL();
+    }
+    enter_bookValue(node, _route) {
+        const book = node.value;
+        // const parent = this.getParentNode(route);
+        // const bit = parent?.value as Bit;
+        if (book) {
+            this.writeProperty('book', book.book, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: false,
+            });
+            if (book.reference) {
+                this.writeOPRANGLE();
+                this.writeBreakscapedTagString(book.reference);
+                this.writeCL();
+                if (book.referenceEnd) {
+                    this.writeOPRANGLE();
+                    this.writeBreakscapedTagString(book.referenceEnd);
+                    this.writeCL();
+                }
+            }
+        }
+        // Stop traversal of this branch
+        return false;
     }
-    // bitmarkAst -> bits -> bitsValue -> book
+    // bitmarkAst -> bits -> bitsValue -> book (single)
     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);
+            this.writeProperty('book', node.value, {
+                format: PropertyFormat.trimmedString,
+                single: true,
+                ignoreEmpty: false,
+            });
             if (bit.reference) {
                 this.writeOPRANGLE();
-                this.writeString(bit.reference);
+                this.writeBreakscapedTagString(bit.reference);
                 this.writeCL();
                 if (bit.referenceEnd) {
                     this.writeOPRANGLE();
-                    this.writeString(bit.referenceEnd);
+                    this.writeBreakscapedTagString(bit.referenceEnd);
                     this.writeCL();
                 }
             }
@@ -1077,7 +1592,7 @@ class BitmarkGenerator extends AstWalkerGenerator {
     leaf_anchor(node, _route) {
         if (node.value) {
             this.writeOPDANGLE();
-            this.writeString(node.value);
+            this.writeBreakscapedTagString(node.value);
             this.writeCL();
         }
     }
@@ -1089,7 +1604,7 @@ class BitmarkGenerator extends AstWalkerGenerator {
             // Only write reference if it is not chained to 'book'
             if (!bit.book) {
                 this.writeOPRANGLE();
-                this.writeString(node.value);
+                this.writeBreakscapedTagString(node.value);
                 this.writeCL();
             }
         }
@@ -1097,101 +1612,80 @@ class BitmarkGenerator extends AstWalkerGenerator {
     //  * -> itemLead --> item
     //  * -> itemLead --> lead
     //  * -> hint
-    leaf_hint(node, _route) {
+    enter_hint(node, _route) {
         const value = node.value;
         const text = value;
-        if (text) {
+        if (!this.isEmptyText(text)) {
             this.writeOPQ();
-            this.writeString(text);
+            this.textGenerator.generateSync(text, TextFormat.bitmarkMinusMinus);
             this.writeCL();
         }
+        // Stop traversal of this branch
+        return false;
     }
     // bitmarkAst -> bits -> bitsValue ->  * -> instruction
-    leaf_instruction(node, _route) {
+    enter_instruction(node, _route) {
         const value = node.value;
         const text = value;
-        if (text) {
+        if (!this.isEmptyText(text)) {
             this.writeOPB();
-            this.writeString(text);
+            this.textGenerator.generateSync(text, TextFormat.bitmarkMinusMinus);
             this.writeCL();
         }
+        // Stop traversal of this branch
+        return false;
     }
-    // bitmarkAst -> bits -> bitsValue ->  * -> example
-    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;
+    // bitmarkAst -> bits -> bitsValue ->  * -> isExample / example
+    leaf_isExample(node, route) {
+        var _a;
+        const isExample = node.value;
         if (!isExample)
             return;
-        if (isDefaultExample) {
-            this.writeOPA();
-            this.writeString('example');
-            this.writeCL();
-        }
-        else if (value != null) {
+        const parent = this.getParentNode(route);
+        const example = (_a = parent === null || parent === void 0 ? void 0 : parent.value.example) !== null && _a !== void 0 ? _a : null;
+        // const __isDefaultExample = parent?.value.__isDefaultExample ?? false;
+        if (example != null && example !== '') {
             this.writeOPA();
             this.writeString('example');
             this.writeColon();
-            if (value === true) {
+            if (example === true) {
                 this.writeString('true');
             }
-            else if (value === false) {
+            else if (example === false) {
                 this.writeString('false');
             }
+            else if (Array.isArray(example)) {
+                // TextAst
+                this.textGenerator.generateSync(example, TextFormat.bitmarkMinusMinus);
+            }
             else {
                 // String
-                this.writeString(value);
+                this.writeBreakscapedTagString(example);
             }
             this.writeCL();
         }
-    }
-    // bitmarkAst -> bits -> body -> bodyValue -> bodyText
-    leaf_bodyText(node, _route) {
-        const value = node.value;
-        const text = value;
-        if (text) {
-            this.writeString(text);
-        }
-    }
-    // bitmarkAst -> bits -> body -> bodyValue -> bodyJson
-    enter_bodyJson(node, _route) {
-        const value = node.value;
-        if (Array.isArray(value) || ObjectUtils.isObject(value)) {
-            const text = JSON.stringify(value, null, this.prettifySpace);
-            if (text) {
-                this.writeString(text);
-            }
-        }
-        // Stop traversal of this branch to avoid processing the bodyJson
-        return false;
-    }
-    // bitmarkAst -> bits -> footer
-    enter_footer(_node, _route) {
-        this.write('~~~~');
-        this.writeNL();
-    }
-    // bitmarkAst -> bits -> footer -> footerText
-    leaf_footerText(node, _route) {
-        const value = node.value;
-        const text = value;
-        if (text) {
-            this.writeString(text);
+        else {
+            // Don't write example if it is null.
+            // this.writeOPA();
+            // this.writeString('example');
+            // this.writeCL();
         }
     }
     // bitmarkAst -> bits -> bitsValue -> elements -> elementsValue
     leaf_elementsValue(node, _route) {
         if (node.value) {
-            this.writeString(node.value);
+            this.writeBreakscapedTagString(node.value);
         }
     }
     // bitmarkAst -> bits -> bitsValue -> body -> bodyValue -> gap -> solutions -> solution
     // ? -> solutions -> solution
-    leaf_solutionsValue(node, _route) {
+    leaf_solutionsValue(node, route) {
+        const parent = this.getParentNode(route, 2);
+        if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
+            return;
         if (node.value != null) {
             this.writeOPU();
-            this.writeString(node.value);
+            this.writeBreakscapedTagString(node.value);
             this.writeCL();
         }
     }
@@ -1200,7 +1694,7 @@ class BitmarkGenerator extends AstWalkerGenerator {
     leaf_prefix(node, _route) {
         if (node.value) {
             this.writeOPPRE();
-            this.writeString(node.value);
+            this.writeBreakscapedTagString(node.value);
             this.writeCL();
         }
     }
@@ -1209,39 +1703,50 @@ class BitmarkGenerator extends AstWalkerGenerator {
     leaf_postfix(node, _route) {
         if (node.value) {
             this.writeOPPOST();
-            this.writeString(node.value);
+            this.writeBreakscapedTagString(node.value);
             this.writeCL();
         }
     }
     // bitmarkAst -> bits -> bitsValue ->  * -> isCaseSensitive
     leaf_isCaseSensitive(node, _route) {
-        this.writeProperty('isCaseSensitive', node.value, true, false, true);
+        this.writeProperty('isCaseSensitive', node.value, {
+            format: PropertyFormat.boolean,
+            single: true,
+            ignoreFalse: false,
+            ignoreTrue: true,
+        });
     }
     // bitmarkAst -> bits -> bitsValue ->  * -> isCorrect
     // bitmarkAst -> bits -> bitsValue -> heading -> forKeys
     leaf_forKeys(node, _route) {
         this.writeOPHASH();
-        this.writeString(node.value);
+        this.writeBreakscapedTagString(node.value);
+        this.writeCL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> heading -> forValues
+    leaf_forValues(node, _route) {
+        this.writeOPHASH();
+        this.writeBreakscapedTagString(node.value);
         this.writeCL();
     }
     // bitmarkAst -> bits -> bitsValue -> heading -> forValuesValue
     leaf_forValuesValue(node, _route) {
         this.writeOPHASH();
-        this.writeString(node.value);
+        this.writeBreakscapedTagString(node.value);
         this.writeCL();
     }
     // bitmarkAst -> bits -> bitsValue -> pairs -> pairsValue -> key
     // bitmarkAst -> bits -> bitsValue -> matrix -> matrixValue -> key
     leaf_key(node, _route) {
         if (node.value) {
-            this.writeString(node.value);
+            this.writeBreakscapedTagString(node.value);
         }
     }
     // bitmarkAst -> bits -> bitsValue -> pairs -> pairsValue -> values -> valuesValue
     // bitmarkAst -> bits -> bitsValue -> matrix -> matrixValue -> cells -> cellsValue -> values -> valuesValue
     leaf_valuesValue(node, _route) {
         if (node.value) {
-            this.writeString(node.value);
+            this.writeBreakscapedTagString(node.value);
         }
     }
     // bitmarkAst -> bits -> bitsValue -> questions -> questionsValue -> question
@@ -1252,35 +1757,76 @@ class BitmarkGenerator extends AstWalkerGenerator {
         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) {
-            this.writeString(node.value);
+            this.writeBreakscapedTagString(node.value);
             // this.writeNL();
         }
     }
+    enter_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 true;
+        if (node.value) {
+            this.textGenerator.generateSync(node.value, TextFormat.bitmarkMinusMinus);
+            // this.writeString(node.value);
+            // this.writeNL();
+        }
+        // Stop traversal of this branch
+        return false;
+    }
     // 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,zoomDisabled,caption]
     leaf_src1x(node, _route) {
-        this.writeProperty('src1x', node.value);
+        this.writeProperty('src1x', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     leaf_src2x(node, _route) {
-        this.writeProperty('src2x', node.value);
+        this.writeProperty('src2x', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     leaf_src3x(node, _route) {
-        this.writeProperty('src3x', node.value);
+        this.writeProperty('src3x', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     leaf_src4x(node, _route) {
-        this.writeProperty('src4x', node.value);
+        this.writeProperty('src4x', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     leaf_width(node, _route) {
-        this.writeProperty('width', node.value);
+        this.writeProperty('width', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     leaf_height(node, _route) {
-        this.writeProperty('height', node.value);
+        this.writeProperty('height', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     leaf_alt(node, _route) {
-        this.writeProperty('alt', node.value);
+        this.writeProperty('alt', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     leaf_zoomDisabled(node, route) {
         const bitType = this.getBitType(route);
@@ -1290,32 +1836,65 @@ class BitmarkGenerator extends AstWalkerGenerator {
             BitType.imagesLogoGrave,
             BitType.prototypeImages,
         ])) {
-            this.writeProperty('zoomDisabled', node.value, undefined, false, true);
+            this.writeProperty('zoomDisabled', node.value, {
+                format: PropertyFormat.boolean,
+                single: true,
+                ignoreFalse: false,
+                ignoreTrue: true,
+            });
         }
         else {
-            this.writeProperty('zoomDisabled', node.value, undefined, true, false);
+            this.writeProperty('zoomDisabled', node.value, {
+                format: PropertyFormat.boolean,
+                single: true,
+                ignoreFalse: true,
+                ignoreTrue: false,
+            });
         }
     }
     leaf_license(node, _route) {
-        this.writeProperty('license', node.value);
+        this.writeProperty('license', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     leaf_copyright(node, _route) {
-        this.writeProperty('copyright', node.value);
+        this.writeProperty('copyright', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     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, _route) {
-        this.writeProperty('showInIndex', node.value);
+        this.writeProperty('showInIndex', node.value, {
+            format: PropertyFormat.boolean,
+            single: true,
+            ignoreEmpty: true,
+            ignoreFalse: true,
+        });
     }
-    leaf_caption(node, _route) {
+    enter_caption(node, _route) {
         const value = node.value;
-        this.writeProperty('caption', value);
+        this.writeProperty('caption', value, {
+            format: PropertyFormat.bitmarkMinusMinus,
+            single: true, // ??
+            ignoreEmpty: true,
+        });
+        // Stop traversal of this branch
+        return false;
     }
     leaf_search(node, _route) {
         const value = node.value;
-        this.writeProperty('search', value);
+        this.writeProperty('search', value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     // bitmarkAst -> bits -> bitsValue -> resource -> ...
     // bitmarkAst -> bits -> bitsValue -> resource -> posterImage -> ...
@@ -1326,23 +1905,97 @@ class BitmarkGenerator extends AstWalkerGenerator {
         const parent = this.getParentNode(route);
         if ((parent === null || parent === void 0 ? void 0 : parent.key) === NodeType.bitsValue)
             return;
-        this.writeProperty('duration', node.value);
+        this.writeProperty('duration', node.value, {
+            format: PropertyFormat.trimmedString,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     leaf_mute(node, _route) {
-        this.writeProperty('mute', node.value);
+        this.writeProperty('mute', node.value, {
+            format: PropertyFormat.boolean,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     leaf_autoplay(node, _route) {
-        this.writeProperty('autoplay', node.value);
+        this.writeProperty('autoplay', node.value, {
+            format: PropertyFormat.boolean,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     leaf_allowSubtitles(node, _route) {
-        this.writeProperty('allowSubtitles', node.value);
+        this.writeProperty('allowSubtitles', node.value, {
+            format: PropertyFormat.boolean,
+            single: true,
+            ignoreEmpty: true,
+        });
     }
     leaf_showSubtitles(node, _route) {
-        this.writeProperty('showSubtitles', node.value);
+        this.writeProperty('showSubtitles', node.value, {
+            format: PropertyFormat.boolean,
+            single: true,
+            ignoreEmpty: true,
+        });
+    }
+    //
+    // Resources
+    //
+    // bitmarkAst -> bits -> bitsValue -> resources
+    between_resources(_node, _left, _right, _route) {
+        this.writeNL();
+    }
+    exit_resources(_node, _left, _right, _route) {
+        this.writeNL();
+    }
+    // bitmarkAst -> bits -> bitsValue -> resourcesValue
+    between_resourcesValue(_node, _left, _right, _route) {
+        this.writeNL();
     }
     //
     // Generated Node Handlers
     //
+    /**
+     * Generate the handlers for resources, as they are mostly the same, but not quite
+     */
+    generateResourceHandlers() {
+        for (const tag of ResourceTag.keys()) {
+            // skip unknown
+            if (tag === ResourceTag.keyFromValue(ResourceTag.unknown))
+                continue;
+            const enterFuncName = `enter_${tag}`;
+            // Skip if the function already exists, allows for custom handlers
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (typeof this[enterFuncName] === 'function') {
+                continue;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this[enterFuncName] = (node, route) => {
+                const resource = node.value;
+                if (resource == null)
+                    return false;
+                // 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.resourcesValue)
+                    return true;
+                // Get the resource alias
+                const alias = ResourceTag.fromValue(parent.value.__typeAlias);
+                const type = alias !== null && alias !== void 0 ? alias : ResourceTag.fromValue(parent.value.type);
+                if (!type)
+                    return false;
+                // url / src / href / app
+                const url = resource.url || resource.src || resource.body || '';
+                // Write the resource
+                this.writeResource(type, url);
+                // Continue traversal
+                return true;
+            };
+            // Bind this
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this[enterFuncName] = this[enterFuncName].bind(this);
+        }
+    }
     /**
      * Generate the handlers for properties, as they are mostly the same, but not quite
      */
@@ -1359,36 +2012,15 @@ class BitmarkGenerator extends AstWalkerGenerator {
         const propertiesConfig = Config.getRawPropertiesConfig();
         for (const propertyConfig of Object.values(propertiesConfig)) {
             const astKey = (_a = propertyConfig.astKey) !== null && _a !== void 0 ? _a : propertyConfig.tag;
-            // Special cases (handled outside of the automatically generated handlers)
-            if (astKey === PropertyTag.internalComment)
-                continue;
-            if (astKey === PropertyTag.example)
-                continue;
-            if (astKey === PropertyTag.labelTrue)
-                continue;
-            if (astKey === PropertyTag.labelFalse)
-                continue;
-            if (astKey === PropertyTag.posterImage)
-                continue;
-            if (astKey === PropertyTag.imageSource)
-                continue;
-            if (astKey === PropertyTag.imagePlaceholder)
-                continue;
-            if (astKey === PropertyTag.technicalTerm)
-                continue;
-            if (astKey === PropertyTag.servings)
-                continue;
-            if (astKey === PropertyTag.person)
-                continue;
-            if (astKey === PropertyAstKey.ast_markConfig)
-                continue;
-            if (astKey === PropertyTag.ratingLevelStart)
-                continue;
-            if (astKey === PropertyTag.ratingLevelEnd)
-                continue;
             const enterFuncName = `enter_${astKey}`;
+            // Skip if the function already exists, allows for custom handlers
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (typeof this[enterFuncName] === 'function') {
+                continue;
+            }
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             this[enterFuncName] = (node, route) => {
+                var _a, _b;
                 const value = node.value;
                 if (value == null)
                     return;
@@ -1398,7 +2030,12 @@ class BitmarkGenerator extends AstWalkerGenerator {
                 if ((parent === null || parent === void 0 ? void 0 : parent.key) !== NodeType.bitsValue)
                     return;
                 // Write the property
-                this.writeProperty(propertyConfig.tag, node.value, propertyConfig.single, propertyConfig.defaultValue === 'false', propertyConfig.defaultValue === 'true');
+                this.writeProperty(propertyConfig.tag, node.value, {
+                    format: (_a = propertyConfig.format) !== null && _a !== void 0 ? _a : PropertyFormat.trimmedString,
+                    single: (_b = propertyConfig.single) !== null && _b !== void 0 ? _b : false,
+                    ignoreFalse: propertyConfig.defaultValue === 'false',
+                    ignoreTrue: propertyConfig.defaultValue === 'true',
+                });
             };
             // Bind this
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1434,6 +2071,13 @@ class BitmarkGenerator extends AstWalkerGenerator {
     //
     // WRITE FUNCTIONS
     //
+    writeBreakscapedTagString(s) {
+        if (s != null) {
+            this.write(Breakscape.breakscape(`${s}`, {
+                textFormat: TextFormat.bitmarkMinusMinus,
+            }));
+        }
+    }
     writeString(s) {
         if (s != null)
             this.write(`${s}`);
@@ -1568,84 +2212,86 @@ class BitmarkGenerator extends AstWalkerGenerator {
         this.write('\n');
     }
     writePropertyStyleResource(key, resource) {
-        const resourceAsArticle = resource;
+        var _a;
         if (key && resource) {
+            const resourceTag = (_a = ResourceTag.keyFromValue(resource.type)) !== null && _a !== void 0 ? _a : '';
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const resourceData = resource[resourceTag];
+            const src = resourceData ? resourceData.src || resourceData.url || resourceData.body || '' : '';
             this.writeOPA();
-            this.writeString(key);
-            if (resource.type === ResourceTag.article && resourceAsArticle.value) {
-                this.writeColon();
-                // this.writeNL();
-                this.writeString(resourceAsArticle.value);
+            this.writeBreakscapedTagString(key);
+            this.writeColon();
+            this.writeBreakscapedTagString(src);
+            if (resource.type === ResourceTag.article) {
                 this.writeNL();
             }
-            else if (resource.value) {
-                this.writeColon();
-                this.writeString(resource.value);
-            }
             this.writeCL();
         }
     }
-    writeResource(resource) {
-        var _a;
-        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;
+    writeResource(type, value) {
+        // const resourceAsArticle = resource as ArticleResource;
+        if (type) {
             // Standard case
             this.writeOPAMP();
-            this.writeString((_a = resource.typeAlias) !== null && _a !== void 0 ? _a : resource.type);
-            if (resource.type === ResourceTag.article && resourceAsArticle.value) {
-                this.writeColon();
-                // this.writeNL();
-                this.writeString(resourceAsArticle.value);
+            this.writeBreakscapedTagString(type);
+            this.writeColon();
+            this.writeBreakscapedTagString(value);
+            if (type === ResourceTag.article) {
                 this.writeNL();
             }
-            else if (resource.value) {
-                this.writeColon();
-                this.writeString(resource.value);
-            }
             this.writeCL();
         }
     }
-    writeProperty(name, values, singleOnly, ignoreFalse, ignoreTrue) {
+    writeProperty(name, values, options) {
+        var _a;
         let valuesArray;
         let wroteSomething = false;
         if (values !== undefined) {
-            if (!Array.isArray(values)) {
-                valuesArray = [values];
+            const isBitmarkText = options.format === PropertyFormat.bitmarkMinusMinus || options.format === PropertyFormat.bitmarkPlusPlus;
+            if (isBitmarkText) {
+                // Write bitmark text
+                if (options.ignoreEmpty && isBitmarkText && this.isEmptyText(values))
+                    return;
+                this.writeOPA();
+                this.writeBreakscapedTagString(name);
+                this.writeColon();
+                this.textGenerator.generateSync(values, (_a = TextFormat.fromValue(options.format)) !== null && _a !== void 0 ? _a : TextFormat.bitmarkMinusMinus);
+                this.writeCL();
+                wroteSomething = true;
             }
             else {
-                valuesArray = values;
-            }
-            if (valuesArray.length > 0) {
-                if (singleOnly)
-                    valuesArray = valuesArray.slice(valuesArray.length - 1);
-                let propertyIndex = 0;
-                for (const val of valuesArray) {
-                    if (val !== undefined) {
-                        if (ignoreFalse && val === false)
-                            continue;
-                        if (ignoreTrue && val === true)
-                            continue;
-                        if (propertyIndex > 0)
-                            this.writeNL();
-                        this.writeOPA();
-                        this.writeString(name);
-                        this.writeColon();
-                        this.writeString(`${val}`);
-                        this.writeCL();
-                        wroteSomething = true;
-                        propertyIndex++;
+                // Write any other property type
+                if (!Array.isArray(values)) {
+                    valuesArray = [values];
+                }
+                else {
+                    valuesArray = values;
+                }
+                if (valuesArray.length > 0) {
+                    if (options.single)
+                        valuesArray = valuesArray.slice(valuesArray.length - 1);
+                    let propertyIndex = 0;
+                    for (const val of valuesArray) {
+                        if (val !== undefined) {
+                            if (options.ignoreFalse && val === false)
+                                continue;
+                            if (options.ignoreTrue && val === true)
+                                continue;
+                            if (options.ignoreEmpty && val === '')
+                                continue;
+                            if (propertyIndex > 0)
+                                this.writeNL();
+                            this.writeOPA();
+                            this.writeBreakscapedTagString(name);
+                            this.writeColon();
+                            this.writeBreakscapedTagString(`${val}`);
+                            this.writeCL();
+                            wroteSomething = true;
+                            propertyIndex++;
+                        }
                     }
                 }
-            }
+            } // isBitmarkText
         }
         if (!wroteSomething) {
             this.skipNLBetweenBitsValue = true;
@@ -1667,6 +2313,13 @@ class BitmarkGenerator extends AstWalkerGenerator {
     //
     // Helper functions
     //
+    isEmptyText(text) {
+        if (!text)
+            return true;
+        if (Array.isArray(text))
+            return text.length === 0;
+        return true; // true as not valid TextAst?
+    }
     isWriteTextFormat(bitsValue, textFormatDefault) {
         const isDefault = TextFormat.fromValue(bitsValue) === textFormatDefault;
         const writeFormat = !isDefault || this.options.explicitTextFormat;