easy-template-x 6.2.2 → 7.0.0

package/dist/cjs/easy-template-x.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var JSZip = require('jszip');
 var xmldom = require('@xmldom/xmldom');
+var JSZip = require('jszip');
 var getProp = require('lodash.get');
 var JSON5 = require('json5');
 
@@ -19,9 +19,8 @@ class InternalArgumentMissingError extends InternalError {
 }
 
 class MalformedFileError extends Error {
-  constructor(expectedFileType) {
-    super(`Malformed file detected. Make sure the file is a valid ${expectedFileType} file.`);
-    this.expectedFileType = expectedFileType;
+  constructor(message) {
+    super(message);
   }
 }
 
@@ -202,8 +201,16 @@ function isNumber(value) {
 class Path {
   static getFilename(path) {
     const lastSlashIndex = path.lastIndexOf('/');
-    return path.substr(lastSlashIndex + 1);
+    return path.substring(lastSlashIndex + 1);
   }
+
+  /**
+   * Get the directory of a path. 
+   * Exclude the last slash.
+   * 
+   * Example:
+   * /folder/subfolder/file.txt -> /folder/subfolder
+   */
   static getDirectory(path) {
     const lastSlashIndex = path.lastIndexOf('/');
     return path.substring(0, lastSlashIndex);
@@ -409,84 +416,6 @@ function countOccurrences(text, substring) {
   return (text.match(new RegExp(substring, 'g')) || []).length;
 }
 
-class JsZipHelper {
-  static toJsZipOutputType(binaryOrType) {
-    if (!binaryOrType) throw new InternalArgumentMissingError("binaryOrType");
-    let binaryType;
-    if (typeof binaryOrType === 'function') {
-      binaryType = binaryOrType;
-    } else {
-      binaryType = binaryOrType.constructor;
-    }
-    if (Binary.isBlobConstructor(binaryType)) return 'blob';
-    if (Binary.isArrayBufferConstructor(binaryType)) return 'arraybuffer';
-    if (Binary.isBufferConstructor(binaryType)) return 'nodebuffer';
-    throw new Error(`Binary type '${binaryType.name}' is not supported.`);
-  }
-}
-
-class ZipObject {
-  get name() {
-    return this.zipObject.name;
-  }
-  set name(value) {
-    this.zipObject.name = value;
-  }
-  get isDirectory() {
-    return this.zipObject.dir;
-  }
-  constructor(zipObject, binaryFormat) {
-    this.zipObject = zipObject;
-    this.binaryFormat = binaryFormat;
-  }
-  getContentText() {
-    return this.zipObject.async('text');
-  }
-  getContentBase64() {
-    return this.zipObject.async('binarystring');
-  }
-  getContentBinary(outputType) {
-    const zipOutputType = JsZipHelper.toJsZipOutputType(outputType ?? this.binaryFormat);
-    return this.zipObject.async(zipOutputType);
-  }
-}
-
-class Zip {
-  static async load(file) {
-    const zip = await JSZip.loadAsync(file);
-    return new Zip(zip, file.constructor);
-  }
-  constructor(zip, binaryFormat) {
-    this.zip = zip;
-    this.binaryFormat = binaryFormat;
-  }
-  getFile(path) {
-    const internalZipObject = this.zip.files[path];
-    if (!internalZipObject) return null;
-    return new ZipObject(internalZipObject, this.binaryFormat);
-  }
-  setFile(path, content) {
-    this.zip.file(path, content);
-  }
-  isFileExist(path) {
-    return !!this.zip.files[path];
-  }
-  listFiles() {
-    return Object.keys(this.zip.files);
-  }
-  async export(outputType) {
-    const zipOutputType = JsZipHelper.toJsZipOutputType(outputType ?? this.binaryFormat);
-    const output = await this.zip.generateAsync({
-      type: zipOutputType,
-      compression: "DEFLATE",
-      compressionOptions: {
-        level: 6 // between 1 (best speed) and 9 (best compression)
-      }
-    });
-    return output;
-  }
-}
-
 const XmlNodeType = Object.freeze({
   Text: "Text",
   General: "General",
@@ -830,8 +759,28 @@ let Query$1 = class Query {
     if (!node) return null;
     return (node.childNodes || []).find(child => predicate(child));
   }
-  findChildByName(node, childName) {
-    return xml.query.findChild(node, n => n.nodeName === childName);
+  findByPath(root, nodeType, ...path) {
+    if (!root) {
+      return null;
+    }
+    let curNode = root;
+    for (let i = 0; i < path.length; i++) {
+      const curIndex = path[i];
+      if (typeof curIndex === 'string') {
+        curNode = xml.query.findChild(curNode, n => n.nodeName === curIndex);
+      }
+      if (typeof curIndex === 'number') {
+        const curNodeType = i == path.length - 1 ? nodeType : XmlNodeType.General;
+        curNode = curNode.childNodes.filter(c => c.nodeType === curNodeType)[curIndex];
+      }
+      if (!curNode) {
+        return null;
+      }
+    }
+    if (curNode.nodeType !== nodeType) {
+      return null;
+    }
+    return curNode;
   }
 
   /**
@@ -872,7 +821,7 @@ let Modify$1 = class Modify {
   insertBefore(newNode, referenceNode) {
     if (!newNode) throw new InternalArgumentMissingError("newNode");
     if (!referenceNode) throw new InternalArgumentMissingError("referenceNode");
-    if (!referenceNode.parentNode) throw new Error(`'${"referenceNode"}' has no parent`);
+    if (!referenceNode.parentNode) throw new Error(`'referenceNode' has no parent`);
     const childNodes = referenceNode.parentNode.childNodes;
     const beforeNodeIndex = childNodes.indexOf(referenceNode);
     xml.modify.insertChild(referenceNode.parentNode, newNode, beforeNodeIndex);
@@ -887,7 +836,7 @@ let Modify$1 = class Modify {
   insertAfter(newNode, referenceNode) {
     if (!newNode) throw new InternalArgumentMissingError("newNode");
     if (!referenceNode) throw new InternalArgumentMissingError("referenceNode");
-    if (!referenceNode.parentNode) throw new Error(`'${"referenceNode"}' has no parent`);
+    if (!referenceNode.parentNode) throw new Error(`'referenceNode' has no parent`);
     const childNodes = referenceNode.parentNode.childNodes;
     const referenceNodeIndex = childNodes.indexOf(referenceNode);
     xml.modify.insertChild(referenceNode.parentNode, newNode, referenceNodeIndex + 1);
@@ -1024,7 +973,7 @@ let Modify$1 = class Modify {
    * `false` then the original child node is the first child of `right`.
    */
   splitByChild(parent, child, removeChild) {
-    if (child.parentNode != parent) throw new Error(`Node '${"child"}' is not a direct child of '${"parent"}'.`);
+    if (child.parentNode != parent) throw new Error(`Node 'child' is not a direct child of 'parent'.`);
 
     // create childless clone 'left'
     const left = xml.create.cloneNode(parent, false);
@@ -1113,6 +1062,104 @@ function recursiveRemoveEmptyTextNodes(node) {
 }
 const xml = new XmlUtils();
 
+const TagDisposition = Object.freeze({
+  Open: "Open",
+  Close: "Close",
+  SelfClosed: "SelfClosed"
+});
+const TagPlacement = Object.freeze({
+  TextNode: "TextNode",
+  Attribute: "Attribute"
+});
+
+function tagRegex(delimiters, global = false) {
+  const tagOptionsPattern = `${Regex.escape(delimiters.tagOptionsStart)}(?<tagOptions>.*?)${Regex.escape(delimiters.tagOptionsEnd)}`;
+  const tagPattern = `${Regex.escape(delimiters.tagStart)}(?<tagName>.*?)(${tagOptionsPattern})?${Regex.escape(delimiters.tagEnd)}`;
+  const flags = global ? 'gm' : 'm';
+  return new RegExp(tagPattern, flags);
+}
+
+class JsZipHelper {
+  static toJsZipOutputType(binaryOrType) {
+    if (!binaryOrType) throw new InternalArgumentMissingError("binaryOrType");
+    let binaryType;
+    if (typeof binaryOrType === 'function') {
+      binaryType = binaryOrType;
+    } else {
+      binaryType = binaryOrType.constructor;
+    }
+    if (Binary.isBlobConstructor(binaryType)) return 'blob';
+    if (Binary.isArrayBufferConstructor(binaryType)) return 'arraybuffer';
+    if (Binary.isBufferConstructor(binaryType)) return 'nodebuffer';
+    throw new Error(`Binary type '${binaryType.name}' is not supported.`);
+  }
+}
+
+class ZipObject {
+  get name() {
+    return this.zipObject.name;
+  }
+  set name(value) {
+    this.zipObject.name = value;
+  }
+  get isDirectory() {
+    return this.zipObject.dir;
+  }
+  constructor(zipObject, binaryFormat) {
+    this.zipObject = zipObject;
+    this.binaryFormat = binaryFormat;
+  }
+  getContentText() {
+    return this.zipObject.async('text');
+  }
+  getContentBase64() {
+    return this.zipObject.async('binarystring');
+  }
+  getContentBinary(outputType) {
+    const zipOutputType = JsZipHelper.toJsZipOutputType(outputType ?? this.binaryFormat);
+    return this.zipObject.async(zipOutputType);
+  }
+}
+
+class Zip {
+  static async load(file) {
+    const zip = await JSZip.loadAsync(file);
+    return new Zip(zip, file.constructor);
+  }
+  constructor(zip, binaryFormat) {
+    this.zip = zip;
+    this.binaryFormat = binaryFormat;
+  }
+  getFile(path) {
+    if (path && path.startsWith('/')) {
+      path = path.substring(1);
+    }
+    const internalZipObject = this.zip.files[path];
+    if (!internalZipObject) return null;
+    return new ZipObject(internalZipObject, this.binaryFormat);
+  }
+  setFile(path, content) {
+    this.zip.file(path, content);
+  }
+  isFileExist(path) {
+    return !!this.zip.files[path];
+  }
+  listFiles() {
+    return Object.keys(this.zip.files);
+  }
+  async export(outputType) {
+    const zipOutputType = JsZipHelper.toJsZipOutputType(outputType ?? this.binaryFormat);
+    const output = await this.zip.generateAsync({
+      type: zipOutputType,
+      compression: "DEFLATE",
+      compressionOptions: {
+        level: 6 // between 1 (best speed) and 9 (best compression)
+      }
+    });
+    return output;
+  }
+}
+
 /**
  * The types of relationships that can be created in a docx file.
  * A non-comprehensive list.
@@ -1132,20 +1179,35 @@ const RelType = Object.freeze({
   Table: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table'
 });
 class Relationship {
-  static fromXml(xml) {
+  static fromXml(partDir, xml) {
     return new Relationship({
       id: xml.attributes?.['Id'],
       type: xml.attributes?.['Type'],
-      target: Relationship.normalizeRelTarget(xml.attributes?.['Target']),
+      target: Relationship.normalizeRelTarget(partDir, xml.attributes?.['Target']),
       targetMode: xml.attributes?.['TargetMode']
     });
   }
-  static normalizeRelTarget(target) {
+  static normalizeRelTarget(partDir, target) {
     if (!target) {
       return target;
     }
+
+    // Remove leading slashes from input
+    if (partDir.startsWith('/')) {
+      partDir = partDir.substring(1);
+    }
+    if (target.startsWith('/')) {
+      target = target.substring(1);
+    }
+
+    // Convert target to relative path
+    if (target.startsWith(partDir)) {
+      target = target.substring(partDir.length);
+    }
+
+    // Remove leading slashes from output
     if (target.startsWith('/')) {
-      return target.substring(1);
+      target = target.substring(1);
     }
     return target;
   }
@@ -1156,11 +1218,11 @@ class Relationship {
     const node = xml.create.generalNode('Relationship');
     node.attributes = {};
 
-    // set only non-empty attributes
+    // Set only non-empty attributes
     for (const propKey of Object.keys(this)) {
       const value = this[propKey];
       if (value && typeof value === 'string') {
-        const attrName = propKey[0].toUpperCase() + propKey.substr(1);
+        const attrName = propKey[0].toUpperCase() + propKey.substring(1);
         node.attributes[attrName] = value;
       }
     }
@@ -1365,20 +1427,20 @@ class RelsFile {
    * Returns the rel ID.
    */
   async add(relTarget, relType, relTargetMode) {
-    // if relTarget is an internal file it should be relative to the part dir
+    // If relTarget is an internal file it should be relative to the part dir
     if (this.partDir && relTarget.startsWith(this.partDir)) {
-      relTarget = relTarget.substr(this.partDir.length + 1);
+      relTarget = relTarget.substring(this.partDir.length + 1);
     }
 
-    // parse rels file
+    // Parse rels file
     await this.parseRelsFile();
 
-    // already exists?
+    // Already exists?
     const relTargetKey = this.getRelTargetKey(relType, relTarget);
     let relId = this.relTargets[relTargetKey];
     if (relId) return relId;
 
-    // create rel node
+    // Create rel node
     relId = this.getNextRelId();
     const rel = new Relationship({
       id: relId,
@@ -1387,11 +1449,11 @@ class RelsFile {
       targetMode: relTargetMode
     });
 
-    // update lookups
+    // Update lookups
     this.rels[relId] = rel;
     this.relTargets[relTargetKey] = relId;
 
-    // return
+    // Return
     return relId;
   }
   async list() {
@@ -1410,20 +1472,20 @@ class RelsFile {
    * Called automatically by the holding `Docx` before exporting.
    */
   async save() {
-    // not change - no need to save
+    // Not change - no need to save
     if (!this.rels) return;
 
-    // create rels xml
+    // Create rels xml
     const root = this.createRootNode();
     root.childNodes = Object.values(this.rels).map(rel => rel.toXml());
 
-    // serialize and save
+    // Serialize and save
     const xmlContent = xml.parser.serializeFile(root);
     this.zip.setFile(this.relsFilePath, xmlContent);
   }
 
   //
-  // private methods
+  // Private methods
   //
 
   getNextRelId() {
@@ -1435,10 +1497,10 @@ class RelsFile {
     return relId;
   }
   async parseRelsFile() {
-    // already parsed
+    // Already parsed
     if (this.rels) return;
 
-    // parse xml
+    // Parse xml
     let root;
     const relsFile = this.zip.getFile(this.relsFilePath);
     if (relsFile) {
@@ -1448,24 +1510,23 @@ class RelsFile {
       root = this.createRootNode();
     }
 
-    // parse relationship nodes
+    // Parse relationship nodes
     this.rels = {};
     this.relTargets = {};
     for (const relNode of root.childNodes) {
-      const attributes = relNode.attributes;
+      const genRelNode = relNode;
+      const attributes = genRelNode.attributes;
       if (!attributes) continue;
       const idAttr = attributes['Id'];
       if (!idAttr) continue;
 
-      // store rel
-      const rel = Relationship.fromXml(relNode);
+      // Store rel
+      const rel = Relationship.fromXml(this.partDir, genRelNode);
       this.rels[idAttr] = rel;
 
-      // create rel target lookup
-      const typeAttr = attributes['Type'];
-      const targetAttr = Relationship.normalizeRelTarget(attributes['Target']);
-      if (typeAttr && targetAttr) {
-        const relTargetKey = this.getRelTargetKey(typeAttr, targetAttr);
+      // Create rel target lookup
+      if (rel.type && rel.target) {
+        const relTargetKey = this.getRelTargetKey(rel.type, rel.target);
         this.relTargets[relTargetKey] = idAttr;
       }
     }
@@ -1521,7 +1582,7 @@ class OpenXmlPart {
   async getText() {
     const xmlDocument = await this.xmlRoot();
 
-    // ugly but good enough...
+    // Ugly but good enough...
     const xmlString = xml.parser.serializeFile(xmlDocument);
     const domDocument = xml.parser.domParse(xmlString);
     return domDocument.documentElement.textContent;
@@ -1625,7 +1686,7 @@ class Docx {
     try {
       zip = await Zip.load(file);
     } catch {
-      throw new MalformedFileError('docx');
+      throw new MalformedFileError("Failed to load zip file.");
     }
 
     // Load the docx file
@@ -1638,7 +1699,7 @@ class Docx {
    */
   static async open(zip) {
     const mainDocumentPath = await Docx.getMainDocumentPath(zip);
-    if (!mainDocumentPath) throw new MalformedFileError('docx');
+    if (!mainDocumentPath) throw new MalformedFileError("Cannot find main document path.");
     return new Docx(mainDocumentPath, zip);
   }
   static async getMainDocumentPath(zip) {
@@ -1705,11 +1766,12 @@ class W {
   Table = 'w:tbl';
   TableRow = 'w:tr';
   TableCell = 'w:tc';
+  Drawing = 'w:drawing';
   NumberProperties = 'w:numPr';
 }
 
 /**
- * Drawing Markup Language node names.
+ * Drawing Markup Language main namespace node names.
  *
  * These elements are part of the main drawingML namespace:
  * xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main".
@@ -1720,6 +1782,68 @@ class A {
   Run = 'a:r';
   RunProperties = 'a:rPr';
   Text = 'a:t';
+  Graphic = 'a:graphic';
+  GraphicData = 'a:graphicData';
+  /**
+   * Binary large image (or) picture.
+   */
+  Blip = 'a:blip';
+  AlphaModFix = 'a:alphaModFix';
+}
+
+/**
+ * Drawing Markup Language "wordprocessing drawing" namespace node names.
+ * 
+ * These elements are part of the wordprocessingDrawing namespace:
+ * xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing".
+ */
+class Wp {
+  /**
+   * docPr stands for "Drawing Object Non-Visual Properties", which isn't
+   * exactly a good acronym but that's how it's called nevertheless.
+   */
+  DocPr = 'wp:docPr';
+  /**
+   * Inline DrawingML Object.
+   *
+   * see: http://officeopenxml.com/drwPicInline.php
+   */
+  Inline = 'wp:inline';
+  /**
+   * Anchor for Floating DrawingML Object.
+   * 
+   * see: http://officeopenxml.com/drwPicFloating.php
+   */
+  FloatingAnchor = 'wp:anchor';
+  /**
+   * Drawing extent.
+   */
+  Extent = 'wp:extent';
+}
+
+/**
+ * Drawing Markup Language "picture" namespace node names.
+ * 
+ * These elements are part of the picture namespace:
+ * xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture".
+ */
+class Pic {
+  Pic = 'pic:pic';
+  /**
+   * Non-visual picture properties.
+   */
+  NvPicPr = 'pic:nvPicPr';
+  CnVPr = 'pic:cNvPr';
+  /**
+   * Binary large image (or) picture fill.
+   */
+  BlipFill = 'pic:blipFill';
+  /**
+   * Shape properties.
+   */
+  SpPr = 'pic:spPr';
+  Xfrm = 'a:xfrm';
+  Ext = 'a:ext';
 }
 
 /**
@@ -1737,9 +1861,19 @@ class OmlNode {
   static W = new W();
 
   /**
-   * Drawing Markup Language node names.
+   * Drawing Markup Language main namespace node names.
    */
   static A = new A();
+
+  /**
+   * Drawing Markup Language "wordprocessing drawing" namespace node names.
+   */
+  static Wp = new Wp();
+
+  /**
+   * Drawing Markup Language "picture" namespace node names.
+   */
+  static Pic = new Pic();
 }
 class OmlAttribute {
   static SpacePreserve = 'xml:space';
@@ -1810,9 +1944,12 @@ class Query {
   }
   isListParagraph(paragraphNode) {
     const paragraphProperties = officeMarkup.query.findParagraphPropertiesNode(paragraphNode);
-    const listNumberProperties = xml.query.findChildByName(paragraphProperties, OmlNode.W.NumberProperties);
+    const listNumberProperties = xml.query.findByPath(paragraphProperties, XmlNodeType.General, OmlNode.W.NumberProperties);
     return !!listNumberProperties;
   }
+  isInlineDrawingNode(node) {
+    return node.nodeName === OmlNode.Wp.Inline && node.parentNode?.nodeName === OmlNode.W.Drawing;
+  }
   findParagraphPropertiesNode(paragraphNode) {
     if (!officeMarkup.query.isParagraphNode(paragraphNode)) throw new Error(`Expected paragraph node but received a '${paragraphNode.nodeName}' node.`);
     return xml.query.findChild(paragraphNode, officeMarkup.query.isParagraphPropertiesNode);
@@ -1836,7 +1973,7 @@ class Query {
    */
   containingTextNode(node) {
     if (!node) return null;
-    if (!xml.query.isTextNode(node)) throw new Error(`'Invalid argument ${"node"}. Expected a XmlTextNode.`);
+    if (!xml.query.isTextNode(node)) throw new Error(`'Invalid argument node. Expected a XmlTextNode.`);
     return xml.query.findParent(node, officeMarkup.query.isTextNode);
   }
 
@@ -1953,7 +2090,7 @@ class Modify {
   splitParagraphByTextNode(paragraph, textNode, removeTextNode) {
     // input validation
     const containingParagraph = officeMarkup.query.containingParagraphNode(textNode);
-    if (containingParagraph != paragraph) throw new Error(`Node '${"textNode"}' is not a descendant of '${"paragraph"}'.`);
+    if (containingParagraph != paragraph) throw new Error(`Node 'textNode' is not a contained in the specified paragraph.`);
     const runNode = officeMarkup.query.containingRunNode(textNode);
     const wordTextNode = officeMarkup.query.containingTextNode(textNode);
 
@@ -2102,17 +2239,36 @@ class Modify {
       node.attributes[OmlAttribute.SpacePreserve] = 'preserve';
     }
   }
-  removeTag(textNode) {
-    const wordTextNode = officeMarkup.query.containingTextNode(textNode);
-    const runNode = officeMarkup.query.containingRunNode(textNode);
+  removeTag(tag) {
+    if (tag.placement === TagPlacement.TextNode) {
+      const wordTextNode = officeMarkup.query.containingTextNode(tag.xmlTextNode);
+      const runNode = officeMarkup.query.containingRunNode(tag.xmlTextNode);
+
+      // Remove the word text node
+      xml.modify.remove(wordTextNode);
 
-    // Remove the word text node
-    xml.modify.remove(wordTextNode);
+      // Remove the run node if it's empty
+      if (officeMarkup.query.isEmptyRun(runNode)) {
+        xml.modify.remove(runNode);
+      }
+      return;
+    }
+    if (tag.placement === TagPlacement.Attribute) {
+      if (!tag.xmlNode.attributes || !(tag.attributeName in tag.xmlNode.attributes)) {
+        return;
+      }
+
+      // Remove the tag from the attribute value
+      tag.xmlNode.attributes[tag.attributeName] = tag.xmlNode.attributes[tag.attributeName].replace(tag.rawText, "");
 
-    // Remove the run node if it's empty
-    if (officeMarkup.query.isEmptyRun(runNode)) {
-      xml.modify.remove(runNode);
+      // Remove the attribute if it's empty
+      if (tag.xmlNode.attributes[tag.attributeName] === "") {
+        delete tag.xmlNode.attributes[tag.attributeName];
+      }
+      return;
     }
+    const anyTag = tag;
+    throw new Error(`Unexpected tag placement "${anyTag.placement}" for tag "${anyTag.rawText}".`);
   }
 }
 
@@ -2134,7 +2290,7 @@ class Xlsx {
     try {
       zip = await Zip.load(file);
     } catch {
-      throw new MalformedFileError('xlsx');
+      throw new MalformedFileError("Failed to load zip file.");
     }
 
     // Load the xlsx file
@@ -2147,7 +2303,7 @@ class Xlsx {
    */
   static async open(zip) {
     const mainDocumentPath = await Xlsx.getMainDocumentPath(zip);
-    if (!mainDocumentPath) throw new MalformedFileError('xlsx');
+    if (!mainDocumentPath) throw new MalformedFileError("Cannot find main document path.");
     return new Xlsx(mainDocumentPath, zip);
   }
   static async getMainDocumentPath(zip) {
@@ -2200,7 +2356,86 @@ class Xlsx {
   }
 }
 
-class MatchState {
+const drawingDescriptionAttributeName = "descr";
+class AttributesDelimiterSearcher {
+  visitedNodes = new Set();
+  constructor(delimiters) {
+    if (!delimiters) throw new InternalArgumentMissingError("delimiters");
+    this.delimiters = delimiters;
+    this.tagRegex = tagRegex(delimiters, true);
+  }
+  processNode(it, delimiters) {
+    // Ignore irrelevant nodes
+    if (!this.shouldSearchNode(it)) {
+      return;
+    }
+
+    // Search delimiters in attributes
+    this.findDelimiters(it, delimiters);
+  }
+  shouldSearchNode(it) {
+    if (this.visitedNodes.has(it.node)) {
+      return false;
+    }
+    this.visitedNodes.add(it.node);
+    if (!xml.query.isGeneralNode(it.node)) return false;
+    if (Object.keys(it.node.attributes || {}).length === 0) return false;
+
+    // Currently we only support description attributes of drawing objects
+    if (!this.isDrawingPropertiesNode(it.node)) {
+      return false;
+    }
+    if (!it.node.attributes[drawingDescriptionAttributeName]) {
+      return false;
+    }
+    return true;
+  }
+  isDrawingPropertiesNode(node) {
+    // Node is drawing properties
+    if (node.nodeName !== OmlNode.Wp.DocPr) {
+      return false;
+    }
+
+    // Parent is drawing
+    if (!node.parentNode) {
+      return false;
+    }
+    const parent = xml.query.findParentByName(node, OmlNode.W.Drawing);
+    return !!parent;
+  }
+  findDelimiters(it, delimiters) {
+    // Currently we only support description attributes of drawing objects
+    this.findDelimitersInAttribute(it.node, drawingDescriptionAttributeName, delimiters);
+  }
+  findDelimitersInAttribute(node, attributeName, delimiters) {
+    const attrValue = node.attributes?.[attributeName];
+    if (!attrValue) {
+      return;
+    }
+    const matches = attrValue.matchAll(this.tagRegex);
+    for (const match of matches) {
+      const tag = match[0];
+      const openDelimiterIndex = match.index;
+      const closeDelimiterIndex = openDelimiterIndex + tag.length - this.delimiters.tagEnd.length;
+      const openDelimiter = this.createCurrentDelimiterMark(openDelimiterIndex, true, node, attributeName);
+      const closeDelimiter = this.createCurrentDelimiterMark(closeDelimiterIndex, false, node, attributeName);
+      delimiters.push(openDelimiter);
+      delimiters.push(closeDelimiter);
+    }
+  }
+  createCurrentDelimiterMark(index, isOpen, xmlNode, attributeName) {
+    return {
+      placement: TagPlacement.Attribute,
+      isOpen: isOpen,
+      index: index,
+      attributeName: attributeName,
+      xmlNode: xmlNode
+    };
+  }
+}
+
+class TextNodesDelimiterSearcher {
+  lookForOpenDelimiter = true;
   /**
    * The index of the current delimiter character being matched.
    *
@@ -2208,30 +2443,55 @@ class MatchState {
    * are now looking for the character `{`. If it is 1, then we are looking
    * for `!`.
    */
-  delimiterIndex = 0;
+  lookForDelimiterIndex = 0;
   /**
-   * The list of text nodes containing the delimiter characters.
+   * The list of text nodes containing the delimiter characters of the current match.
    */
-  openNodes = [];
+  matchOpenNodes = [];
   /**
-   * The index of the first character of the delimiter, in the text node it
+   * The index of the first character of the current delimiter match, in the text node it
    * was found at.
    *
    * Example: If the delimiter is `{!`, and the text node content is `abc{!xyz`,
    * then the firstMatchIndex is 3.
    */
   firstMatchIndex = -1;
-  reset() {
-    this.delimiterIndex = 0;
-    this.openNodes = [];
+  constructor(startDelimiter, endDelimiter) {
+    this.startDelimiter = startDelimiter;
+    this.endDelimiter = endDelimiter;
+  }
+  processNode(it, delimiters) {
+    // Reset match state on paragraph transition
+    if (officeMarkup.query.isParagraphNode(it.node)) {
+      this.resetMatch();
+    }
+
+    // Reset match state on inline drawing
+    if (officeMarkup.query.isInlineDrawingNode(it.node)) {
+      this.resetMatch();
+    }
+
+    // Ignore non-text nodes
+    if (!this.shouldSearchNode(it)) {
+      return;
+    }
+
+    // Search delimiters in text nodes
+    this.findDelimiters(it, delimiters);
+  }
+  resetMatch() {
+    this.lookForDelimiterIndex = 0;
+    this.matchOpenNodes = [];
     this.firstMatchIndex = -1;
   }
-}
-class DelimiterSearcher {
-  maxXmlDepth = 20;
-  startDelimiter = "{";
-  endDelimiter = "}";
-  findDelimiters(node) {
+  shouldSearchNode(it) {
+    if (!xml.query.isTextNode(it.node)) return false;
+    if (!it.node.textContent) return false;
+    if (!it.node.parentNode) return false;
+    if (!officeMarkup.query.isTextNode(it.node.parentNode)) return false;
+    return true;
+  }
+  findDelimiters(it, delimiters) {
     //
     // Performance note:
     //
@@ -2243,57 +2503,38 @@ class DelimiterSearcher {
     // complexity and effort.
     //
 
-    const delimiters = [];
-    const match = new MatchState();
-    const it = new XmlTreeIterator(node, this.maxXmlDepth);
-    let lookForOpenDelimiter = true;
-    while (it.node) {
-      // Reset state on paragraph transition
-      if (officeMarkup.query.isParagraphNode(it.node)) {
-        match.reset();
-      }
+    // Search delimiters in text nodes
+    this.matchOpenNodes.push(it.node);
+    let textIndex = 0;
+    while (textIndex < it.node.textContent.length) {
+      const delimiterPattern = this.lookForOpenDelimiter ? this.startDelimiter : this.endDelimiter;
+      const char = it.node.textContent[textIndex];
 
-      // Skip irrelevant nodes
-      if (!this.shouldSearchNode(it)) {
-        it.next();
+      // No match
+      if (char !== delimiterPattern[this.lookForDelimiterIndex]) {
+        textIndex = this.noMatch(it, textIndex);
+        textIndex++;
         continue;
       }
 
-      // Search delimiters in text nodes
-      match.openNodes.push(it.node);
-      let textIndex = 0;
-      while (textIndex < it.node.textContent.length) {
-        const delimiterPattern = lookForOpenDelimiter ? this.startDelimiter : this.endDelimiter;
-        const char = it.node.textContent[textIndex];
-
-        // No match
-        if (char !== delimiterPattern[match.delimiterIndex]) {
-          textIndex = this.noMatch(it, textIndex, match);
-          textIndex++;
-          continue;
-        }
-
-        // First match
-        if (match.firstMatchIndex === -1) {
-          match.firstMatchIndex = textIndex;
-        }
-
-        // Partial match
-        if (match.delimiterIndex !== delimiterPattern.length - 1) {
-          match.delimiterIndex++;
-          textIndex++;
-          continue;
-        }
+      // First match
+      if (this.firstMatchIndex === -1) {
+        this.firstMatchIndex = textIndex;
+      }
 
-        // Full delimiter match
-        [textIndex, lookForOpenDelimiter] = this.fullMatch(it, textIndex, lookForOpenDelimiter, match, delimiters);
+      // Partial match
+      if (this.lookForDelimiterIndex !== delimiterPattern.length - 1) {
+        this.lookForDelimiterIndex++;
         textIndex++;
+        continue;
       }
-      it.next();
+
+      // Full delimiter match
+      textIndex = this.fullMatch(it, textIndex, delimiters);
+      textIndex++;
     }
-    return delimiters;
   }
-  noMatch(it, textIndex, match) {
+  noMatch(it, textIndex) {
     //
     // Go back to first open node
     //
@@ -2302,57 +2543,76 @@ class DelimiterSearcher {
     // For instance:
     // Delimiter is '{!' and template text contains the string '{{!'
     //
-    if (match.firstMatchIndex !== -1) {
-      const node = first(match.openNodes);
+    if (this.firstMatchIndex !== -1) {
+      const node = first(this.matchOpenNodes);
       it.setCurrent(node);
-      textIndex = match.firstMatchIndex;
+      textIndex = this.firstMatchIndex;
     }
 
     // Update state
-    match.reset();
+    this.resetMatch();
     if (textIndex < it.node.textContent.length - 1) {
-      match.openNodes.push(it.node);
+      this.matchOpenNodes.push(it.node);
     }
     return textIndex;
   }
-  fullMatch(it, textIndex, lookForOpenDelimiter, match, delimiters) {
+  fullMatch(it, textIndex, delimiters) {
     // Move all delimiters characters to the same text node
-    if (match.openNodes.length > 1) {
-      const firstNode = first(match.openNodes);
-      const lastNode = last(match.openNodes);
+    if (this.matchOpenNodes.length > 1) {
+      const firstNode = first(this.matchOpenNodes);
+      const lastNode = last(this.matchOpenNodes);
       officeMarkup.modify.joinTextNodesRange(firstNode, lastNode);
       textIndex += firstNode.textContent.length - it.node.textContent.length;
       it.setCurrent(firstNode);
     }
 
     // Store delimiter
-    const delimiterMark = this.createDelimiterMark(match, lookForOpenDelimiter);
+    const delimiterMark = this.createCurrentDelimiterMark();
     delimiters.push(delimiterMark);
 
     // Update state
-    lookForOpenDelimiter = !lookForOpenDelimiter;
-    match.reset();
+    this.lookForOpenDelimiter = !this.lookForOpenDelimiter;
+    this.resetMatch();
     if (textIndex < it.node.textContent.length - 1) {
-      match.openNodes.push(it.node);
+      this.matchOpenNodes.push(it.node);
     }
-    return [textIndex, lookForOpenDelimiter];
-  }
-  shouldSearchNode(it) {
-    if (!xml.query.isTextNode(it.node)) return false;
-    if (!it.node.textContent) return false;
-    if (!it.node.parentNode) return false;
-    if (!officeMarkup.query.isTextNode(it.node.parentNode)) return false;
-    return true;
+    return textIndex;
   }
-  createDelimiterMark(match, isOpenDelimiter) {
+  createCurrentDelimiterMark() {
     return {
-      index: match.firstMatchIndex,
-      isOpen: isOpenDelimiter,
-      xmlTextNode: match.openNodes[0]
+      placement: TagPlacement.TextNode,
+      isOpen: this.lookForOpenDelimiter,
+      index: this.firstMatchIndex,
+      xmlTextNode: this.matchOpenNodes[0]
     };
   }
 }
 
+class DelimiterSearcher {
+  constructor(delimiters, maxXmlDepth) {
+    if (!delimiters) {
+      throw new InternalArgumentMissingError("delimiters");
+    }
+    if (!maxXmlDepth) {
+      throw new InternalArgumentMissingError("maxXmlDepth");
+    }
+    this.delimiters = delimiters;
+    this.maxXmlDepth = maxXmlDepth;
+  }
+  findDelimiters(node) {
+    const delimiters = [];
+    const it = new XmlTreeIterator(node, this.maxXmlDepth);
+    const attributeSearcher = new AttributesDelimiterSearcher(this.delimiters);
+    const textSearcher = new TextNodesDelimiterSearcher(this.delimiters.tagStart, this.delimiters.tagEnd);
+    while (it.node) {
+      attributeSearcher.processNode(it, delimiters);
+      textSearcher.processNode(it, delimiters);
+      it.next();
+    }
+    return delimiters;
+  }
+}
+
 class ScopeData {
   static defaultResolver(args) {
     let result;
@@ -2394,59 +2654,141 @@ class ScopeData {
   }
 }
 
-const TagDisposition = Object.freeze({
-  Open: "Open",
-  Close: "Close",
-  SelfClosed: "SelfClosed"
-});
-
 class TagParser {
   constructor(delimiters) {
     if (!delimiters) throw new InternalArgumentMissingError("delimiters");
     this.delimiters = delimiters;
-    const tagOptionsRegex = `${Regex.escape(delimiters.tagOptionsStart)}(?<tagOptions>.*?)${Regex.escape(delimiters.tagOptionsEnd)}`;
-    this.tagRegex = new RegExp(`^${Regex.escape(delimiters.tagStart)}(?<tagName>.*?)(${tagOptionsRegex})?${Regex.escape(delimiters.tagEnd)}`, 'm');
+    this.tagRegex = tagRegex(delimiters);
   }
   parse(delimiters) {
     const tags = [];
-    let openedTag;
-    let openedDelimiter;
+    let openedTextDelimiter;
+    let openedAttributeDelimiter;
     for (let i = 0; i < delimiters.length; i++) {
-      const delimiter = delimiters[i];
-
-      // close before open
-      if (!openedTag && !delimiter.isOpen) {
-        const closeTagText = delimiter.xmlTextNode.textContent;
-        throw new MissingStartDelimiterError(closeTagText);
+      if (delimiters[i].placement === TagPlacement.TextNode) {
+        openedTextDelimiter = this.processDelimiter(delimiters, i, openedTextDelimiter, tags);
+        continue;
       }
-
-      // open before close
-      if (openedTag && delimiter.isOpen) {
-        const openTagText = openedDelimiter.xmlTextNode.textContent;
-        throw new MissingCloseDelimiterError(openTagText);
+      if (delimiters[i].placement === TagPlacement.Attribute) {
+        openedAttributeDelimiter = this.processDelimiter(delimiters, i, openedAttributeDelimiter, tags);
+        continue;
       }
+      throw new Error(`Unexpected delimiter placement value "${delimiters[i].placement}"`);
+    }
+    return tags;
+  }
+  processDelimiter(delimiters, i, openedDelimiter, tags) {
+    const delimiter = delimiters[i];
+
+    // Close before open
+    if (!openedDelimiter && !delimiter.isOpen) {
+      const closeTagText = this.getPartialTagText(delimiter);
+      throw new MissingStartDelimiterError(closeTagText);
+    }
+
+    // Open before close
+    if (openedDelimiter && delimiter.isOpen) {
+      const openTagText = this.getPartialTagText(openedDelimiter);
+      throw new MissingCloseDelimiterError(openTagText);
+    }
+
+    // Valid open
+    if (!openedDelimiter && delimiter.isOpen) {
+      openedDelimiter = delimiter;
+    }
 
-      // valid open
-      if (!openedTag && delimiter.isOpen) {
-        openedTag = {};
-        openedDelimiter = delimiter;
+    // Valid close
+    if (openedDelimiter && !delimiter.isOpen) {
+      // Create the tag
+      const partialTag = this.processDelimiterPair(openedDelimiter, delimiter, i, delimiters);
+      const tag = this.populateTagFields(partialTag);
+      tags.push(tag);
+      openedDelimiter = null;
+    }
+    return openedDelimiter;
+  }
+  getPartialTagText(delimiter) {
+    if (delimiter.placement === TagPlacement.TextNode) {
+      return delimiter.xmlTextNode.textContent;
+    }
+    if (delimiter.placement === TagPlacement.Attribute) {
+      return delimiter.xmlNode.attributes[delimiter.attributeName];
+    }
+    throw new Error(`Unexpected delimiter placement value "${delimiter.placement}"`);
+  }
+  processDelimiterPair(openDelimiter, closeDelimiter, closeDelimiterIndex, allDelimiters) {
+    if (openDelimiter.placement === TagPlacement.TextNode && closeDelimiter.placement === TagPlacement.TextNode) {
+      return this.processTextNodeDelimiterPair(openDelimiter, closeDelimiter, closeDelimiterIndex, allDelimiters);
+    }
+    if (openDelimiter.placement === TagPlacement.Attribute && closeDelimiter.placement === TagPlacement.Attribute) {
+      return this.processAttributeDelimiterPair(openDelimiter, closeDelimiter);
+    }
+    throw new Error(`Unexpected delimiter placement values. Open delimiter: "${openDelimiter.placement}", Close delimiter: "${closeDelimiter.placement}"`);
+  }
+  processTextNodeDelimiterPair(openDelimiter, closeDelimiter, closeDelimiterIndex, allDelimiters) {
+    // Verify tag delimiters are in the same paragraph
+    const openTextNode = openDelimiter.xmlTextNode;
+    const closeTextNode = closeDelimiter.xmlTextNode;
+    const sameNode = openTextNode === closeTextNode;
+    if (!sameNode) {
+      const startParagraph = officeMarkup.query.containingParagraphNode(openTextNode);
+      const endParagraph = officeMarkup.query.containingParagraphNode(closeTextNode);
+      if (startParagraph !== endParagraph) {
+        throw new MissingCloseDelimiterError(openTextNode.textContent);
       }
+    }
 
-      // valid close
-      if (openedTag && !delimiter.isOpen) {
-        // normalize the underlying xml structure
-        // (make sure the tag's node only includes the tag's text)
-        this.normalizeTagNodes(openedDelimiter, delimiter, i, delimiters);
-        openedTag.xmlTextNode = openedDelimiter.xmlTextNode;
-
-        // extract tag info from tag's text
-        this.processTag(openedTag);
-        tags.push(openedTag);
-        openedTag = null;
-        openedDelimiter = null;
+    // Verify no inline drawing in the middle
+    const startRun = officeMarkup.query.containingRunNode(openTextNode);
+    const endRun = officeMarkup.query.containingRunNode(closeTextNode);
+    let currentRun = startRun;
+    while (currentRun && currentRun !== endRun) {
+      const drawing = currentRun.childNodes?.find(child => child.nodeName === OmlNode.W.Drawing);
+      if (!drawing) {
+        currentRun = currentRun.nextSibling;
+        continue;
       }
+      const inline = drawing.childNodes?.find(child => child.nodeName === OmlNode.Wp.Inline);
+      if (!inline) {
+        currentRun = currentRun.nextSibling;
+        continue;
+      }
+      throw new MissingCloseDelimiterError(openTextNode.textContent);
     }
-    return tags;
+
+    // Normalize the underlying xml structure
+    // (make sure the tag's node only includes the tag's text)
+    this.normalizeTextTagNodes(openDelimiter, closeDelimiter, closeDelimiterIndex, allDelimiters);
+
+    // Create the tag
+    const tag = {
+      placement: TagPlacement.TextNode,
+      xmlTextNode: openDelimiter.xmlTextNode,
+      rawText: openDelimiter.xmlTextNode.textContent
+    };
+    return tag;
+  }
+  processAttributeDelimiterPair(openDelimiter, closeDelimiter) {
+    // Verify tag delimiters are in the same attribute
+    const openNode = openDelimiter.xmlNode;
+    const closeNode = closeDelimiter.xmlNode;
+    if (openNode !== closeNode) {
+      throw new MissingCloseDelimiterError(openNode.attributes[openDelimiter.attributeName]);
+    }
+    if (openDelimiter.attributeName !== closeDelimiter.attributeName) {
+      throw new MissingCloseDelimiterError(openNode.attributes[openDelimiter.attributeName]);
+    }
+
+    // Create the tag
+    const attrValue = openNode.attributes[openDelimiter.attributeName];
+    const tagText = attrValue.substring(openDelimiter.index, closeDelimiter.index + this.delimiters.tagEnd.length);
+    const tag = {
+      placement: TagPlacement.Attribute,
+      xmlNode: openNode,
+      attributeName: openDelimiter.attributeName,
+      rawText: tagText
+    };
+    return tag;
   }
 
   /**
@@ -2457,19 +2799,12 @@ class TagParser {
    * Text node before: "some text {some tag} some more text"
    * Text nodes after: [ "some text ", "{some tag}", " some more text" ]
    */
-  normalizeTagNodes(openDelimiter, closeDelimiter, closeDelimiterIndex, allDelimiters) {
+  normalizeTextTagNodes(openDelimiter, closeDelimiter, closeDelimiterIndex, allDelimiters) {
     let startTextNode = openDelimiter.xmlTextNode;
     let endTextNode = closeDelimiter.xmlTextNode;
     const sameNode = startTextNode === endTextNode;
-    if (!sameNode) {
-      const startParagraph = officeMarkup.query.containingParagraphNode(startTextNode);
-      const endParagraph = officeMarkup.query.containingParagraphNode(endTextNode);
-      if (startParagraph !== endParagraph) {
-        throw new MissingCloseDelimiterError(startTextNode.textContent);
-      }
-    }
 
-    // trim start
+    // Trim start
     if (openDelimiter.index > 0) {
       officeMarkup.modify.splitTextNode(startTextNode, openDelimiter.index, true);
       if (sameNode) {
@@ -2477,7 +2812,7 @@ class TagParser {
       }
     }
 
-    // trim end
+    // Trim end
     if (closeDelimiter.index < endTextNode.textContent.length - 1) {
       endTextNode = officeMarkup.modify.splitTextNode(endTextNode, closeDelimiter.index + this.delimiters.tagEnd.length, true);
       if (sameNode) {
@@ -2485,43 +2820,46 @@ class TagParser {
       }
     }
 
-    // join nodes
+    // Join nodes
     if (!sameNode) {
       officeMarkup.modify.joinTextNodesRange(startTextNode, endTextNode);
       endTextNode = startTextNode;
     }
 
-    // update offsets of next delimiters
+    // Update offsets of next delimiters
     for (let i = closeDelimiterIndex + 1; i < allDelimiters.length; i++) {
       let updated = false;
       const curDelimiter = allDelimiters[i];
-      if (curDelimiter.xmlTextNode === openDelimiter.xmlTextNode) {
+      if (curDelimiter.placement === TagPlacement.TextNode && curDelimiter.xmlTextNode === openDelimiter.xmlTextNode) {
         curDelimiter.index -= openDelimiter.index;
         updated = true;
       }
-      if (curDelimiter.xmlTextNode === closeDelimiter.xmlTextNode) {
+      if (curDelimiter.placement === TagPlacement.TextNode && curDelimiter.xmlTextNode === closeDelimiter.xmlTextNode) {
         curDelimiter.index -= closeDelimiter.index + this.delimiters.tagEnd.length;
         updated = true;
       }
       if (!updated) break;
     }
 
-    // update references
+    // Update references
     openDelimiter.xmlTextNode = startTextNode;
     closeDelimiter.xmlTextNode = endTextNode;
   }
-  processTag(tag) {
-    tag.rawText = tag.xmlTextNode.textContent;
-    const tagParts = this.tagRegex.exec(tag.rawText);
+  populateTagFields(partialTag) {
+    if (!partialTag.rawText) {
+      throw new InternalError("tag.rawText is required");
+    }
+    const tag = partialTag;
+    const tagParts = tag.rawText.match(this.tagRegex);
     const tagName = (tagParts.groups?.["tagName"] || '').trim();
 
-    // Ignoring empty tags.
+    // Ignoring empty tags
     if (!tagName?.length) {
       tag.disposition = TagDisposition.SelfClosed;
-      return;
+      return tag;
     }
 
-    // Tag options.
+    // Tag options
     const tagOptionsText = (tagParts.groups?.["tagOptions"] || '').trim();
     if (tagOptionsText) {
       try {
@@ -2531,23 +2869,24 @@ class TagParser {
       }
     }
 
-    // Container open tag.
+    // Container open tag
     if (tagName.startsWith(this.delimiters.containerTagOpen)) {
       tag.disposition = TagDisposition.Open;
       tag.name = tagName.slice(this.delimiters.containerTagOpen.length).trim();
-      return;
+      return tag;
     }
 
-    // Container close tag.
+    // Container close tag
     if (tagName.startsWith(this.delimiters.containerTagClose)) {
       tag.disposition = TagDisposition.Close;
       tag.name = tagName.slice(this.delimiters.containerTagClose.length).trim();
-      return;
+      return tag;
     }
 
-    // Self-closed tag.
+    // Self-closed tag
     tag.disposition = TagDisposition.SelfClosed;
     tag.name = tagName;
+    return tag;
   }
 }
 
@@ -2584,12 +2923,228 @@ class TemplatePlugin {
   }
 }
 
+function nameFromId(imageId) {
+  return `Picture ${imageId}`;
+}
+function pixelsToEmu(pixels) {
+  // https://stackoverflow.com/questions/20194403/openxml-distance-size-units
+  // https://docs.microsoft.com/en-us/windows/win32/vml/msdn-online-vml-units#other-units-of-measurement
+  // https://en.wikipedia.org/wiki/Office_Open_XML_file_formats#DrawingML
+  // http://www.java2s.com/Code/CSharp/2D-Graphics/ConvertpixelstoEMUEMUtopixels.htm
+
+  return Math.round(pixels * 9525);
+}
+function transparencyPercentToAlpha(transparencyPercent) {
+  if (transparencyPercent < 0 || transparencyPercent > 100) {
+    throw new TemplateDataError(`Transparency percent must be between 0 and 100, but was ${transparencyPercent}.`);
+  }
+  return Math.round((100 - transparencyPercent) * 1000);
+}
+
+function createImage(imageId, relId, content) {
+  // http://officeopenxml.com/drwPicInline.php
+
+  //
+  // Performance note:
+  //
+  // I've tried to improve the markup generation performance by parsing
+  // the string once and caching the result (and of course customizing it
+  // per image) but it made no change whatsoever (in both cases 1000 items
+  // loop takes around 8 seconds on my machine) so I'm sticking with this
+  // approach which I find to be more readable.
+  //
+
+  const name = nameFromId(imageId);
+  const markupText = `
+        <w:drawing>
+            <wp:inline distT="0" distB="0" distL="0" distR="0">
+                <wp:extent cx="${pixelsToEmu(content.width)}" cy="${pixelsToEmu(content.height)}"/>
+                <wp:effectExtent l="0" t="0" r="0" b="0"/>
+                ${docProperties(imageId, name, content)}
+                <wp:cNvGraphicFramePr>
+                    <a:graphicFrameLocks xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" noChangeAspect="1"/>
+                </wp:cNvGraphicFramePr>
+                <a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">
+                    <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">
+                        ${pictureMarkup(imageId, relId, name, content)}
+                    </a:graphicData>
+                </a:graphic>
+            </wp:inline>
+        </w:drawing>
+    `;
+  const markupXml = xml.parser.parse(markupText);
+  xml.modify.removeEmptyTextNodes(markupXml); // remove whitespace
+
+  return markupXml;
+}
+function docProperties(imageId, name, content) {
+  if (content.altText) {
+    return `<wp:docPr id="${imageId}" name="${name}" descr="${content.altText}"/>`;
+  }
+  return `
+        <wp:docPr id="${imageId}" name="${name}">
+            <a:extLst xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">
+                <a:ext uri="{C183D7F6-B498-43B3-948B-1728B52AA6E4}">
+                    <adec:decorative xmlns:adec="http://schemas.microsoft.com/office/drawing/2017/decorative" val="1"/>
+                </a:ext>
+            </a:extLst>
+        </wp:docPr>
+    `;
+}
+function pictureMarkup(imageId, relId, name, content) {
+  // http://officeopenxml.com/drwPic.php
+
+  // Legend:
+  // nvPicPr - non-visual picture properties - id, name, etc.
+  // blipFill - binary large image (or) picture fill - image size, image fill, etc.
+  // spPr - shape properties - frame size, frame fill, etc.
+
+  return `
+        <pic:pic xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture">
+            <pic:nvPicPr>
+                <pic:cNvPr id="${imageId}" name="${name}"/>
+                <pic:cNvPicPr>
+                    <a:picLocks noChangeAspect="1" noChangeArrowheads="1"/>
+                </pic:cNvPicPr>
+            </pic:nvPicPr>
+            <pic:blipFill>
+                <a:blip r:embed="${relId}">
+                    ${transparencyMarkup(content.transparencyPercent)}
+                    <a:extLst>
+                        <a:ext uri="{28A0092B-C50C-407E-A947-70E740481C1C}">
+                            <a14:useLocalDpi xmlns:a14="http://schemas.microsoft.com/office/drawing/2010/main" val="0"/>
+                        </a:ext>
+                    </a:extLst>
+                </a:blip>
+                <a:srcRect/>
+                <a:stretch>
+                    <a:fillRect/>
+                </a:stretch>
+            </pic:blipFill>
+            <pic:spPr bwMode="auto">
+                <a:xfrm>
+                    <a:off x="0" y="0"/>
+                    <a:ext cx="${pixelsToEmu(content.width)}" cy="${pixelsToEmu(content.height)}"/>
+                </a:xfrm>
+                <a:prstGeom prst="rect">
+                    <a:avLst/>
+                </a:prstGeom>
+                <a:noFill/>
+                <a:ln>
+                    <a:noFill/>
+                </a:ln>
+            </pic:spPr>
+        </pic:pic>
+    `;
+}
+function transparencyMarkup(transparencyPercent) {
+  if (transparencyPercent === null || transparencyPercent === undefined) {
+    return '';
+  }
+  const alpha = transparencyPercentToAlpha(transparencyPercent);
+  return `<a:alphaModFix amt="${alpha}" />`;
+}
+
+function updateImage(drawingContainerNode, imageId, relId, content) {
+  const inlineNode = xml.query.findByPath(drawingContainerNode, XmlNodeType.General, OmlNode.Wp.Inline);
+  const floatingNode = xml.query.findByPath(drawingContainerNode, XmlNodeType.General, OmlNode.Wp.FloatingAnchor);
+  const drawingNode = inlineNode || floatingNode;
+  if (!inlineNode && !floatingNode) {
+    throw new MalformedFileError("Invalid drawing container node. Expected inline or floating anchor node.");
+  }
+  const pictureNode = xml.query.findByPath(drawingNode, XmlNodeType.General, OmlNode.A.Graphic, OmlNode.A.GraphicData, OmlNode.Pic.Pic);
+  if (!pictureNode) {
+    throw new MalformedFileError("Invalid drawing container node. Expected picture node.");
+  }
+
+  // Set rel ID
+  setRelId(pictureNode, relId);
+
+  // Update non-visual properties
+  updateNonVisualProps(drawingNode, pictureNode, imageId, content);
+
+  // Update size
+  updateSize(drawingNode, pictureNode, content);
+
+  // Update transparency
+  updateTransparency(pictureNode, content);
+}
+function setRelId(pictureNode, relId) {
+  const blipNode = xml.query.findByPath(pictureNode, XmlNodeType.General, OmlNode.Pic.BlipFill, OmlNode.A.Blip);
+  pictureNode.attributes["r:embed"] = relId;
+  blipNode.attributes["r:embed"] = relId;
+}
+function updateNonVisualProps(drawingNode, pictureNode, imageId, content) {
+  const docPrNode = xml.query.findByPath(drawingNode, XmlNodeType.General, OmlNode.Wp.DocPr);
+  if (!docPrNode) {
+    throw new MalformedFileError("Cannot find doc properties node.");
+  }
+  const nvPicPrNode = xml.query.findByPath(pictureNode, XmlNodeType.General, OmlNode.Pic.NvPicPr, OmlNode.Pic.CnVPr);
+  if (!nvPicPrNode) {
+    throw new MalformedFileError("Cannot find non-visual picture properties node.");
+  }
+  docPrNode.attributes["id"] = imageId.toString();
+  nvPicPrNode.attributes["id"] = imageId.toString();
+  const imageName = nameFromId(imageId);
+  docPrNode.attributes["name"] = imageName;
+  nvPicPrNode.attributes["name"] = imageName;
+  if (content.altText) {
+    docPrNode.attributes["descr"] = content.altText;
+    nvPicPrNode.attributes["descr"] = content.altText;
+  }
+}
+function updateSize(drawingNode, pictureNode, content) {
+  if (typeof content.width !== 'number' && typeof content.height !== 'number') {
+    return;
+  }
+  const drawingExtentNode = xml.query.findByPath(drawingNode, XmlNodeType.General, OmlNode.Wp.Extent);
+  if (!drawingExtentNode) {
+    throw new MalformedFileError("Cannot find drawing extent node.");
+  }
+  const pictureExtentNode = xml.query.findByPath(pictureNode, XmlNodeType.General, OmlNode.Pic.SpPr, OmlNode.Pic.Xfrm, OmlNode.Pic.Ext);
+  if (!pictureExtentNode) {
+    throw new MalformedFileError("Cannot find picture extent node.");
+  }
+  if (typeof content.width === 'number') {
+    const widthEmu = pixelsToEmu(content.width);
+    drawingExtentNode.attributes["cx"] = widthEmu.toString();
+    pictureExtentNode.attributes["cx"] = widthEmu.toString();
+  }
+  if (typeof content.height === 'number') {
+    const heightEmu = pixelsToEmu(content.height);
+    drawingExtentNode.attributes["cy"] = heightEmu.toString();
+    pictureExtentNode.attributes["cy"] = heightEmu.toString();
+  }
+}
+function updateTransparency(pictureNode, content) {
+  if (content.transparencyPercent === null || content.transparencyPercent === undefined) {
+    return;
+  }
+  const blipNode = xml.query.findByPath(pictureNode, XmlNodeType.General, OmlNode.Pic.BlipFill, OmlNode.A.Blip);
+  if (!blipNode) {
+    throw new MalformedFileError("Cannot find blip node.");
+  }
+  let alphaNode = xml.query.findByPath(blipNode, XmlNodeType.General, OmlNode.A.AlphaModFix);
+
+  // If the alpha node is not present, create it
+  if (!alphaNode) {
+    alphaNode = xml.create.generalNode(OmlNode.A.AlphaModFix, {
+      attributes: {}
+    });
+    xml.modify.insertChild(blipNode, alphaNode, 0);
+  }
+
+  // Set the alpha value
+  const alpha = transparencyPercentToAlpha(content.transparencyPercent);
+  alphaNode.attributes["amt"] = alpha.toString();
+}
+
 class ImagePlugin extends TemplatePlugin {
   contentType = 'image';
   async simpleTagReplacements(tag, data, context) {
     const content = data.getScopeData();
     if (!content || !content.source) {
-      officeMarkup.modify.removeTag(tag.xmlTextNode);
+      officeMarkup.modify.removeTag(tag);
       return;
     }
 
@@ -2599,12 +3154,25 @@ class ImagePlugin extends TemplatePlugin {
     const relId = await context.currentPart.rels.add(mediaFilePath, relType);
     await context.docx.contentTypes.ensureContentType(content.format);
 
-    // Create the xml markup
+    // Generate a unique image ID
     const imageId = await this.getNextImageId(context);
-    const imageXml = this.createMarkup(imageId, relId, content);
-    const wordTextNode = officeMarkup.query.containingTextNode(tag.xmlTextNode);
-    xml.modify.insertAfter(imageXml, wordTextNode);
-    officeMarkup.modify.removeTag(tag.xmlTextNode);
+
+    // For text tags, create xml markup from scratch
+    if (tag.placement === TagPlacement.TextNode) {
+      const imageXml = createImage(imageId, relId, content);
+      const wordTextNode = officeMarkup.query.containingTextNode(tag.xmlTextNode);
+      xml.modify.insertAfter(imageXml, wordTextNode);
+    }
+
+    // For attribute tags, modify the existing markup
+    if (tag.placement === TagPlacement.Attribute) {
+      const drawingNode = xml.query.findParentByName(tag.xmlNode, OmlNode.W.Drawing);
+      if (!drawingNode) {
+        throw new TemplateSyntaxError(`Cannot find placeholder image for tag "${tag.rawText}".`);
+      }
+      updateImage(drawingNode, imageId, relId, content);
+    }
+    officeMarkup.modify.removeTag(tag);
   }
   async getNextImageId(context) {
     // Init plugin context.
@@ -2629,10 +3197,8 @@ class ImagePlugin extends TemplatePlugin {
     const maxDepth = context.options.maxXmlDepth;
 
     // Get all existing doc props IDs
-    // (docPr stands for "Drawing Object Non-Visual Properties", which isn't
-    // exactly a good acronym but that's how it's called nevertheless)
     const docProps = xml.query.descendants(partRoot, maxDepth, node => {
-      return xml.query.isGeneralNode(node) && node.nodeName === 'wp:docPr';
+      return xml.query.isGeneralNode(node) && node.nodeName === OmlNode.Wp.DocPr;
     });
 
     // Start counting from the current max
@@ -2641,128 +3207,17 @@ class ImagePlugin extends TemplatePlugin {
     lastIdMap[lastIdKey] = maxId + 1;
     return lastIdMap[lastIdKey];
   }
-  createMarkup(imageId, relId, content) {
-    // http://officeopenxml.com/drwPicInline.php
-
-    //
-    // Performance note:
-    //
-    // I've tried to improve the markup generation performance by parsing
-    // the string once and caching the result (and of course customizing it
-    // per image) but it made no change whatsoever (in both cases 1000 items
-    // loop takes around 8 seconds on my machine) so I'm sticking with this
-    // approach which I find to be more readable.
-    //
-
-    const name = `Picture ${imageId}`;
-    const markupText = `
-            <w:drawing>
-                <wp:inline distT="0" distB="0" distL="0" distR="0">
-                    <wp:extent cx="${this.pixelsToEmu(content.width)}" cy="${this.pixelsToEmu(content.height)}"/>
-                    <wp:effectExtent l="0" t="0" r="0" b="0"/>
-                    ${this.docProperties(imageId, name, content)}
-                    <wp:cNvGraphicFramePr>
-                        <a:graphicFrameLocks xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" noChangeAspect="1"/>
-                    </wp:cNvGraphicFramePr>
-                    <a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">
-                        <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture">
-                            ${this.pictureMarkup(imageId, relId, name, content)}
-                        </a:graphicData>
-                    </a:graphic>
-                </wp:inline>
-            </w:drawing>
-        `;
-    const markupXml = xml.parser.parse(markupText);
-    xml.modify.removeEmptyTextNodes(markupXml); // remove whitespace
-
-    return markupXml;
-  }
-  docProperties(imageId, name, content) {
-    if (content.altText) {
-      return `<wp:docPr id="${imageId}" name="${name}" descr="${content.altText}"/>`;
-    }
-    return `
-            <wp:docPr id="${imageId}" name="${name}">
-                <a:extLst xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">
-					<a:ext uri="{C183D7F6-B498-43B3-948B-1728B52AA6E4}">
-						<adec:decorative xmlns:adec="http://schemas.microsoft.com/office/drawing/2017/decorative" val="1"/>
-					</a:ext>
-				</a:extLst>
-            </wp:docPr>
-        `;
-  }
-  pictureMarkup(imageId, relId, name, content) {
-    // http://officeopenxml.com/drwPic.php
-
-    // Legend:
-    // nvPicPr - non-visual picture properties - id, name, etc.
-    // blipFill - binary large image (or) picture fill - image size, image fill, etc.
-    // spPr - shape properties - frame size, frame fill, etc.
-
-    return `
-            <pic:pic xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture">
-                <pic:nvPicPr>
-                    <pic:cNvPr id="${imageId}" name="${name}"/>
-                    <pic:cNvPicPr>
-                        <a:picLocks noChangeAspect="1" noChangeArrowheads="1"/>
-                    </pic:cNvPicPr>
-                </pic:nvPicPr>
-                <pic:blipFill>
-                    <a:blip r:embed="${relId}">
-                        ${this.transparencyMarkup(content.transparencyPercent)}
-                        <a:extLst>
-                            <a:ext uri="{28A0092B-C50C-407E-A947-70E740481C1C}">
-                                <a14:useLocalDpi xmlns:a14="http://schemas.microsoft.com/office/drawing/2010/main" val="0"/>
-                            </a:ext>
-                        </a:extLst>
-                    </a:blip>
-                    <a:srcRect/>
-                    <a:stretch>
-                        <a:fillRect/>
-                    </a:stretch>
-                </pic:blipFill>
-                <pic:spPr bwMode="auto">
-                    <a:xfrm>
-                        <a:off x="0" y="0"/>
-                        <a:ext cx="${this.pixelsToEmu(content.width)}" cy="${this.pixelsToEmu(content.height)}"/>
-                    </a:xfrm>
-                    <a:prstGeom prst="rect">
-                        <a:avLst/>
-                    </a:prstGeom>
-                    <a:noFill/>
-                    <a:ln>
-                        <a:noFill/>
-                    </a:ln>
-                </pic:spPr>
-            </pic:pic>
-        `;
-  }
-  transparencyMarkup(transparencyPercent) {
-    if (transparencyPercent === null || transparencyPercent === undefined) {
-      return '';
-    }
-    if (transparencyPercent < 0 || transparencyPercent > 100) {
-      throw new TemplateDataError(`Transparency percent must be between 0 and 100, but was ${transparencyPercent}.`);
-    }
-    const alpha = Math.round((100 - transparencyPercent) * 1000);
-    return `<a:alphaModFix amt="${alpha}" />`;
-  }
-  pixelsToEmu(pixels) {
-    // https://stackoverflow.com/questions/20194403/openxml-distance-size-units
-    // https://docs.microsoft.com/en-us/windows/win32/vml/msdn-online-vml-units#other-units-of-measurement
-    // https://en.wikipedia.org/wiki/Office_Open_XML_file_formats#DrawingML
-    // http://www.java2s.com/Code/CSharp/2D-Graphics/ConvertpixelstoEMUEMUtopixels.htm
-
-    return Math.round(pixels * 9525);
-  }
 }
 
 class LinkPlugin extends TemplatePlugin {
   contentType = 'link';
   async simpleTagReplacements(tag, data, context) {
+    if (tag.placement !== TagPlacement.TextNode) {
+      throw new TemplateSyntaxError(`Link tag "${tag.rawText}" must be placed in a text node but was placed in ${tag.placement}`);
+    }
     const content = data.getScopeData();
     if (!content || !content.target) {
-      officeMarkup.modify.removeTag(tag.xmlTextNode);
+      officeMarkup.modify.removeTag(tag);
       return;
     }
 
@@ -3157,6 +3612,12 @@ class LoopPlugin extends TemplatePlugin {
     // vars
     const openTag = tags[0];
     const closeTag = last(tags);
+    if (openTag.placement !== TagPlacement.TextNode) {
+      throw new TemplateSyntaxError(`Loop opening tag "${openTag.rawText}" must be placed in a text node but was placed in ${openTag.placement}`);
+    }
+    if (closeTag.placement !== TagPlacement.TextNode) {
+      throw new TemplateSyntaxError(`Loop closing tag "${closeTag.rawText}" must be placed in a text node but was placed in ${closeTag.placement}`);
+    }
 
     // select the suitable strategy
     const loopStrategy = this.loopStrategies.find(strategy => strategy.isApplicable(openTag, closeTag, isCondition));
@@ -3243,6 +3704,9 @@ class LoopPlugin extends TemplatePlugin {
 class RawXmlPlugin extends TemplatePlugin {
   contentType = 'rawXml';
   simpleTagReplacements(tag, data) {
+    if (tag.placement !== TagPlacement.TextNode) {
+      throw new TemplateSyntaxError(`RawXml tag "${tag.rawText}" must be placed in a text node but was placed in ${tag.placement}`);
+    }
     const value = data.getScopeData();
     const replaceNode = value?.replaceParagraph ? officeMarkup.query.containingParagraphNode(tag.xmlTextNode) : officeMarkup.query.containingTextNode(tag.xmlTextNode);
     if (typeof value?.xml === 'string') {
@@ -3252,7 +3716,7 @@ class RawXmlPlugin extends TemplatePlugin {
     if (value?.replaceParagraph) {
       xml.modify.remove(replaceNode);
     } else {
-      officeMarkup.modify.removeTag(tag.xmlTextNode);
+      officeMarkup.modify.removeTag(tag);
     }
   }
 }
@@ -3266,20 +3730,44 @@ class TextPlugin extends TemplatePlugin {
    */
   simpleTagReplacements(tag, data) {
     const value = data.getScopeData();
-    const lines = stringValue(value).split('\n');
+    const strValue = stringValue(value);
+    if (tag.placement === TagPlacement.TextNode) {
+      this.replaceInTextNode(tag, strValue);
+      return;
+    }
+    if (tag.placement === TagPlacement.Attribute) {
+      this.replaceInAttribute(tag, strValue);
+      return;
+    }
+    const anyTag = tag;
+    throw new TemplateSyntaxError(`Unexpected tag placement "${anyTag.placement}" for tag "${anyTag.rawText}".`);
+  }
+  replaceInTextNode(tag, text) {
+    const lines = text.split('\n');
     if (lines.length < 2) {
-      this.replaceSingleLine(tag.xmlTextNode, lines.length ? lines[0] : '');
+      this.replaceSingleLine(tag, lines.length ? lines[0] : '');
     } else {
       this.replaceMultiLine(tag.xmlTextNode, lines);
     }
   }
-  replaceSingleLine(textNode, text) {
+  replaceInAttribute(tag, text) {
     // Set text
+    tag.xmlNode.attributes[tag.attributeName] = tag.xmlNode.attributes[tag.attributeName].replace(tag.rawText, text);
+
+    // Remove the attribute if it's empty
+    if (!text) {
+      officeMarkup.modify.removeTag(tag);
+      return;
+    }
+  }
+  replaceSingleLine(tag, text) {
+    // Set text
+    const textNode = tag.xmlTextNode;
     textNode.textContent = text;
 
     // Clean up if the text node is now empty
     if (!text) {
-      officeMarkup.modify.removeTag(textNode);
+      officeMarkup.modify.removeTag(tag);
       return;
     }
 
@@ -3672,15 +4160,15 @@ async function updateChart(chartPart, chartData) {
   // Get the chart node
   const root = await chartPart.xmlRoot();
   if (root.nodeName !== "c:chartSpace") {
-    throw new Error(`Unexpected chart root node "${root.nodeName}"`);
+    throw new MalformedFileError(`Unexpected chart root node "${root.nodeName}"`);
   }
   const chartWrapperNode = root.childNodes?.find(child => child.nodeName === "c:chart");
   if (!chartWrapperNode) {
-    throw new Error("Chart node not found");
+    throw new MalformedFileError("Chart node not found");
   }
   const plotAreaNode = chartWrapperNode.childNodes?.find(child => child.nodeName === "c:plotArea");
   if (!plotAreaNode) {
-    throw new Error("Plot area node not found");
+    throw new MalformedFileError("Plot area node not found");
   }
   const chartNode = plotAreaNode.childNodes?.find(child => Object.values(chartTypes).includes(child.nodeName));
   if (!chartNode) {
@@ -4450,13 +4938,16 @@ function parseXmlNode(xmlString) {
 class ChartPlugin extends TemplatePlugin {
   contentType = 'chart';
   async simpleTagReplacements(tag, data, context) {
+    if (tag.placement !== TagPlacement.TextNode) {
+      throw new TemplateSyntaxError(`Chart tag "${tag.rawText}" must be placed in a text node but was placed in ${tag.placement}`);
+    }
     const chartNode = xml.query.findParentByName(tag.xmlTextNode, "c:chart");
     if (!chartNode) {
-      throw new TemplateSyntaxError("Chart tag not placed in chart title");
+      throw new TemplateSyntaxError(`Chart tag "${tag.rawText}" must be placed in chart title`);
     }
     const content = data.getScopeData();
     if (!content) {
-      officeMarkup.modify.removeTag(tag.xmlTextNode);
+      officeMarkup.modify.removeTag(tag);
       return;
     }
 
@@ -4464,7 +4955,7 @@ class ChartPlugin extends TemplatePlugin {
     if (content.title) {
       updateTitle(tag, content.title);
     } else {
-      officeMarkup.modify.removeTag(tag.xmlTextNode);
+      officeMarkup.modify.removeTag(tag);
     }
     if (!chartHasData(content)) {
       return;
@@ -4654,7 +5145,7 @@ class Delimiters {
   constructor(initial) {
     Object.assign(this, initial);
     this.encodeAndValidate();
-    if (this.containerTagOpen === this.containerTagClose) throw new Error(`${"containerTagOpen"} can not be equal to ${"containerTagClose"}`);
+    if (this.containerTagOpen === this.containerTagClose) throw new Error(`containerTagOpen can not be equal to containerTagClose`);
   }
   encodeAndValidate() {
     const keys = ['tagStart', 'tagEnd', 'containerTagOpen', 'containerTagClose'];
@@ -4697,19 +5188,17 @@ class TemplateHandler {
   /**
    * Version number of the `easy-template-x` library.
    */
-  version = "6.2.2" ;
+  version = "7.0.0" ;
   constructor(options) {
     this.options = new TemplateHandlerOptions(options);
+    const delimiters = this.options.delimiters;
 
     //
-    // this is the library's composition root
+    // This is the library's composition root
     //
 
-    const delimiterSearcher = new DelimiterSearcher();
-    delimiterSearcher.startDelimiter = this.options.delimiters.tagStart;
-    delimiterSearcher.endDelimiter = this.options.delimiters.tagEnd;
-    delimiterSearcher.maxXmlDepth = this.options.maxXmlDepth;
-    const tagParser = new TagParser(this.options.delimiters);
+    const delimiterSearcher = new DelimiterSearcher(delimiters, this.options.maxXmlDepth);
+    const tagParser = new TagParser(delimiters);
     this.compiler = new TemplateCompiler(delimiterSearcher, tagParser, this.options.plugins, {
       skipEmptyTags: this.options.skipEmptyTags,
       defaultContentType: this.options.defaultContentType,
@@ -4733,14 +5222,14 @@ class TemplateHandler {
   }
 
   //
-  // public methods
+  // Public methods
   //
 
   async process(templateFile, data) {
-    // load the docx file
+    // Load the docx file
     const docx = await Docx.load(templateFile);
 
-    // prepare context
+    // Prepare context
     const scopeData = new ScopeData(data);
     scopeData.scopeDataResolver = this.options.scopeDataResolver;
     const context = {
@@ -4755,18 +5244,18 @@ class TemplateHandler {
     for (const part of contentParts) {
       context.currentPart = part;
 
-      // extensions - before compilation
+      // Extensions - before compilation
       await this.callExtensions(this.options.extensions?.beforeCompilation, scopeData, context);
 
-      // compilation (do replacements)
+      // Compilation (do replacements)
       const xmlRoot = await part.xmlRoot();
       await this.compiler.compile(xmlRoot, scopeData, context);
 
-      // extensions - after compilation
+      // Extensions - after compilation
       await this.callExtensions(this.options.extensions?.afterCompilation, scopeData, context);
     }
 
-    // export the result
+    // Export the result
     return docx.export();
   }
   async parseTags(templateFile) {
@@ -4828,7 +5317,7 @@ class TemplateHandler {
   }
 
   //
-  // private methods
+  // Private methods
   //
 
   async callExtensions(extensions, scopeData, context) {
@@ -4874,6 +5363,7 @@ exports.TEXT_NODE_NAME = TEXT_NODE_NAME;
 exports.TagDisposition = TagDisposition;
 exports.TagOptionsParseError = TagOptionsParseError;
 exports.TagParser = TagParser;
+exports.TagPlacement = TagPlacement;
 exports.TemplateCompiler = TemplateCompiler;
 exports.TemplateDataError = TemplateDataError;
 exports.TemplateExtension = TemplateExtension;