@digipair/skill-docxtemplater 0.136.0 → 0.136.3

package/dist/index.esm.js

@@ -714,6 +714,11 @@ if (UNICODE_SUPPORT) {
     // eslint-disable-next-line es5/no-unicode-code-point-escape
     Char = reg('[', chars(Char), '\\u{10000}-\\u{10FFFF}', ']');
 }
+// Negation of Char: matches any character that is NOT a valid XML 1.0 Char.
+// Derived directly from the Char character class above (after the unicode-support extension).
+// XML 1.0 Char production [2]: #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
+// @see https://www.w3.org/TR/xml/#NT-Char
+var InvalidChar = new RegExp('[^' + chars(Char) + ']', UNICODE_SUPPORT ? 'u' : '');
 var _SChar = /[\x20\x09\x0D\x0A]/;
 var SChar_s = chars(_SChar);
 // https://www.w3.org/TR/xml11/#NT-S
@@ -921,6 +926,12 @@ var PUBLIC = 'PUBLIC';
 // `[75] ExternalID ::= 'SYSTEM' S SystemLiteral | 'PUBLIC' S PubidLiteral S SystemLiteral`
 var ExternalID = regg(regg(SYSTEM, S, SystemLiteral), '|', regg(PUBLIC, S, PubidLiteral, S, SystemLiteral));
 var ExternalID_match = reg('^', regg(regg(SYSTEM, S, '(?<SystemLiteralOnly>', SystemLiteral, ')'), '|', regg(PUBLIC, S, '(?<PubidLiteral>', PubidLiteral, ')', S, '(?<SystemLiteral>', SystemLiteral, ')')));
+// Full-string anchored matcher for requireWellFormed serializer checks
+// https://w3c.github.io/DOM-Parsing/#xml-serializing-a-document-node
+var PubidLiteral_match = reg('^', PubidLiteral, '$');
+// Full-string anchored matcher for requireWellFormed serializer checks
+// https://w3c.github.io/DOM-Parsing/#xml-serializing-a-document-node
+var SystemLiteral_match = reg('^', SystemLiteral, '$');
 // https://www.w3.org/TR/xml11/#NT-NDataDecl
 // `[76] NDataDecl ::= S 'NDATA' S Name` [VC: Notation Declared]
 var NDataDecl = regg(S, 'NDATA', S, Name);
@@ -1032,6 +1043,7 @@ grammar.PEReference = PEReference;
 grammar.PI = PI;
 grammar.PUBLIC = PUBLIC;
 grammar.PubidLiteral = PubidLiteral;
+grammar.PubidLiteral_match = PubidLiteral_match;
 grammar.QName = QName;
 grammar.QName_exact = QName_exact;
 grammar.QName_group = QName_group;
@@ -1040,6 +1052,8 @@ grammar.SChar_s = SChar_s;
 grammar.S_OPT = S_OPT;
 grammar.SYSTEM = SYSTEM;
 grammar.SystemLiteral = SystemLiteral;
+grammar.SystemLiteral_match = SystemLiteral_match;
+grammar.InvalidChar = InvalidChar;
 grammar.UNICODE_REPLACEMENT_CHARACTER = UNICODE_REPLACEMENT_CHARACTER;
 grammar.UNICODE_SUPPORT = UNICODE_SUPPORT;
 grammar.XMLDecl = XMLDecl;
@@ -1349,13 +1363,38 @@ NodeList.prototype = {
     /**
 	 * Returns a string representation of the NodeList.
 	 *
-	 * @param {unknown} nodeFilter
-	 * __A filter function? Not implemented according to the spec?__.
+	 * Accepts the same `options` object as `XMLSerializer.prototype.serializeToString`
+	 * (`requireWellFormed`, `splitCDATASections`, `nodeFilter`). Passing a function is treated as
+	 * a legacy `nodeFilter` for backward compatibility.
+	 *
+	 * @param {Object | function} [options]
+	 * @param {boolean} [options.requireWellFormed=false]
+	 * @param {boolean} [options.splitCDATASections=true]
+	 * @param {function} [options.nodeFilter]
 	 * @returns {string}
-	 * A string representation of the NodeList.
-	 */ toString: function toString(nodeFilter) {
+	 */ toString: function toString(options) {
+        var opts;
+        if (typeof options === 'function') {
+            opts = {
+                requireWellFormed: false,
+                splitCDATASections: true,
+                nodeFilter: options
+            };
+        } else if (!!options) {
+            opts = {
+                requireWellFormed: !!options.requireWellFormed,
+                splitCDATASections: options.splitCDATASections !== false,
+                nodeFilter: options.nodeFilter || null
+            };
+        } else {
+            opts = {
+                requireWellFormed: false,
+                splitCDATASections: true,
+                nodeFilter: null
+            };
+        }
         for(var buf = [], i = 0; i < this.length; i++){
-            serializeToString(this[i], buf, nodeFilter);
+            serializeToString(this[i], buf, null, opts);
         }
         return buf.join('');
     },
@@ -1855,11 +1894,21 @@ DOMImplementation$1.prototype = {
 	 * The {@link https://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-qualifiedname qualified
 	 * name} of the document type to be created.
 	 * @param {string} [publicId]
-	 * The external subset public identifier.
+	 * The external subset public identifier. Stored verbatim including surrounding quotes.
+	 * When serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`
+	 * if the value is non-empty and does not match the XML `PubidLiteral` production
+	 * (W3C DOM Parsing §3.2.1.3; XML 1.0 production [12]). Creation-time validation is not
+	 * enforced — deferred to a future breaking release.
 	 * @param {string} [systemId]
-	 * The external subset system identifier.
+	 * The external subset system identifier. Stored verbatim including surrounding quotes.
+	 * When serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`
+	 * if the value is non-empty and does not match the XML `SystemLiteral` production
+	 * (W3C DOM Parsing §3.2.1.3; XML 1.0 production [11]). Creation-time validation is not
+	 * enforced — deferred to a future breaking release.
 	 * @param {string} [internalSubset]
-	 * the internal subset or an empty string if it is not present
+	 * The internal subset or an empty string if it is not present. Stored verbatim.
+	 * When serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`
+	 * if the value contains `"]>"`. Creation-time validation is not enforced.
 	 * @returns {DocumentType}
 	 * A new {@link DocumentType} node with {@link Node#ownerDocument} set to null.
 	 * @throws {DOMException}
@@ -2052,7 +2101,7 @@ Node.prototype = {
         var parent = other;
         do {
             if (this === parent) return true;
-            parent = other.parentNode;
+            parent = parent.parentNode;
         }while (parent);
         return false;
     },
@@ -2082,50 +2131,73 @@ Node.prototype = {
     /**
 	 * Checks whether the given node is equal to this node.
 	 *
+	 * Two nodes are equal when they have the same type, defining characteristics (for the type),
+	 * and the same childNodes. The comparison is iterative to avoid stack overflows on
+	 * deeply-nested trees. Attribute nodes of each Element pair are also pushed onto the stack
+	 * and compared the same way.
+	 *
 	 * @param {Node} [otherNode]
+	 * @returns {boolean}
 	 * @see https://dom.spec.whatwg.org/#concept-node-equals
+	 * @see ../docs/walk-dom.md.
 	 */ isEqualNode: function isEqualNode(otherNode) {
         if (!otherNode) return false;
-        if (this.nodeType !== otherNode.nodeType) return false;
-        switch(this.nodeType){
-            case this.DOCUMENT_TYPE_NODE:
-                if (this.name !== otherNode.name) return false;
-                if (this.publicId !== otherNode.publicId) return false;
-                if (this.systemId !== otherNode.systemId) return false;
-                break;
-            case this.ELEMENT_NODE:
-                if (this.namespaceURI !== otherNode.namespaceURI) return false;
-                if (this.prefix !== otherNode.prefix) return false;
-                if (this.localName !== otherNode.localName) return false;
-                if (this.attributes.length !== otherNode.attributes.length) return false;
-                for(var i = 0; i < this.attributes.length; i++){
-                    var attr = this.attributes.item(i);
-                    if (!attr.isEqualNode(otherNode.getAttributeNodeNS(attr.namespaceURI, attr.localName))) {
-                        return false;
+        // Use an explicit {node, other} pair stack to avoid call-stack overflow on deep trees.
+        // walkDOM cannot be used here — parallel two-tree traversal requires pairing
+        // corresponding nodes at each step across both trees simultaneously.
+        var stack = [
+            {
+                node: this,
+                other: otherNode
+            }
+        ];
+        while(stack.length > 0){
+            var pair = stack.pop();
+            var node = pair.node;
+            var other = pair.other;
+            if (node.nodeType !== other.nodeType) return false;
+            switch(node.nodeType){
+                case node.DOCUMENT_TYPE_NODE:
+                    if (node.name !== other.name) return false;
+                    if (node.publicId !== other.publicId) return false;
+                    if (node.systemId !== other.systemId) return false;
+                    break;
+                case node.ELEMENT_NODE:
+                    if (node.namespaceURI !== other.namespaceURI) return false;
+                    if (node.prefix !== other.prefix) return false;
+                    if (node.localName !== other.localName) return false;
+                    if (node.attributes.length !== other.attributes.length) return false;
+                    for(var i = 0; i < node.attributes.length; i++){
+                        var attr = node.attributes.item(i);
+                        var otherAttr = other.getAttributeNodeNS(attr.namespaceURI, attr.localName);
+                        if (!otherAttr) return false;
+                        stack.push({
+                            node: attr,
+                            other: otherAttr
+                        });
                     }
-                }
-                break;
-            case this.ATTRIBUTE_NODE:
-                if (this.namespaceURI !== otherNode.namespaceURI) return false;
-                if (this.localName !== otherNode.localName) return false;
-                if (this.value !== otherNode.value) return false;
-                break;
-            case this.PROCESSING_INSTRUCTION_NODE:
-                if (this.target !== otherNode.target || this.data !== otherNode.data) {
-                    return false;
-                }
-                break;
-            case this.TEXT_NODE:
-            case this.COMMENT_NODE:
-                if (this.data !== otherNode.data) return false;
-                break;
-        }
-        if (this.childNodes.length !== otherNode.childNodes.length) {
-            return false;
-        }
-        for(var i = 0; i < this.childNodes.length; i++){
-            if (!this.childNodes[i].isEqualNode(otherNode.childNodes[i])) {
-                return false;
+                    break;
+                case node.ATTRIBUTE_NODE:
+                    if (node.namespaceURI !== other.namespaceURI) return false;
+                    if (node.localName !== other.localName) return false;
+                    if (node.value !== other.value) return false;
+                    break;
+                case node.PROCESSING_INSTRUCTION_NODE:
+                    if (node.target !== other.target || node.data !== other.data) return false;
+                    break;
+                case node.TEXT_NODE:
+                case node.CDATA_SECTION_NODE:
+                case node.COMMENT_NODE:
+                    if (node.data !== other.data) return false;
+                    break;
+            }
+            if (node.childNodes.length !== other.childNodes.length) return false;
+            // Push children in reverse order so index 0 is processed first (LIFO).
+            for(var i = node.childNodes.length - 1; i >= 0; i--){
+                stack.push({
+                    node: node.childNodes[i],
+                    other: other.childNodes[i]
+                });
             }
         }
         return true;
@@ -2237,7 +2309,7 @@ Node.prototype = {
 	 * is `TEXT_NODE`) into a single node with the combined data. It also removes any empty text
 	 * nodes.
 	 *
-	 * This method operates recursively, so it also normalizes any and all descendent nodes within
+	 * This method iterativly traverses all child nodes to normalize all descendent nodes within
 	 * the subtree.
 	 *
 	 * @throws {DOMException}
@@ -2246,18 +2318,27 @@ Node.prototype = {
 	 * @since Modified in DOM Level 2
 	 * @see {@link Node.removeChild}
 	 * @see {@link CharacterData.appendData}
+	 * @see ../docs/walk-dom.md.
 	 */ normalize: function normalize() {
-        var child = this.firstChild;
-        while(child){
-            var next = child.nextSibling;
-            if (next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE) {
-                this.removeChild(next);
-                child.appendData(next.data);
-            } else {
-                child.normalize();
-                child = next;
+        walkDOM(this, null, {
+            enter: function enter(node) {
+                // Merge adjacent text children of node before walkDOM schedules them.
+                // walkDOM reads lastChild/previousSibling after enter returns, so the
+                // surviving post-merge children are what it descends into.
+                var child = node.firstChild;
+                while(child){
+                    var next = child.nextSibling;
+                    if (next !== null && next.nodeType === TEXT_NODE && child.nodeType === TEXT_NODE) {
+                        node.removeChild(next);
+                        child.appendData(next.data);
+                    // Do not advance child: re-check new nextSibling for another text run
+                    } else {
+                        child = next;
+                    }
+                }
+                return true; // descend into surviving children
             }
-        }
+        });
     },
     /**
 	 * Checks whether the DOM implementation implements a specific feature and its version.
@@ -2452,22 +2533,118 @@ copy(NodeType, Node.prototype);
 copy(DocumentPosition, Node);
 copy(DocumentPosition, Node.prototype);
 /**
- * @param callback
- * Return true for continue,false for break.
- * @returns
- * boolean true: break visit;
+ * Visits every node in the subtree rooted at `node` in depth-first pre-order.
+ *
+ * Delegates to {@link walkDOM} for traversal. The `callback` is called on each node;
+ * if it returns a truthy value, traversal stops immediately.
+ *
+ * @param {Node} node
+ * Root of the subtree to visit.
+ * @param {function(Node): *} callback
+ * Called for each node. A truthy return value stops traversal early.
  */ function _visitNode(node, callback) {
-    if (callback(node)) {
-        return true;
-    }
-    if (node = node.firstChild) {
-        do {
-            if (_visitNode(node, callback)) {
-                return true;
+    walkDOM(node, null, {
+        enter: function enter(n) {
+            return callback(n) ? walkDOM.STOP : true;
+        }
+    });
+}
+/**
+ * Depth-first pre/post-order DOM tree walker.
+ *
+ * Visits every node in the subtree rooted at `node`. For each node:
+ *
+ * 1. Calls `callbacks.enter(node, context)` before descending into the node's children. The
+ * return value becomes the `context` passed to each child's `enter` call and to the matching
+ * `exit` call.
+ * 2. If `enter` returns `null` or `undefined`, the node's children are skipped;
+ * sibling traversal continues normally.
+ * 3. If `enter` returns `walkDOM.STOP`, the entire traversal is aborted immediately — no
+ * further `enter` or `exit` calls are made.
+ * 4. `lastChild` and `previousSibling` are read **after** `enter` returns, so `enter` may
+ * safely modify the node's own child list before the walker descends. Modifying siblings of
+ * the current node or any other part of the tree produces unpredictable results: nodes already
+ * queued on the stack are visited regardless of DOM changes, and newly inserted nodes outside
+ * the current child list are never visited.
+ * 5. Calls `callbacks.exit(node, context)` (if provided) after all of a node's children have
+ * been visited, passing the same `context` that `enter`
+ * returned for that node.
+ *
+ * This implementation uses an explicit stack and does not recurse — it is safe on arbitrarily
+ * deep trees.
+ *
+ * @param {Node} node
+ * Root of the subtree to walk.
+ * @param {*} context
+ * Initial context value passed to the root node's `enter`.
+ * @param {{ enter: function(Node, *): *, exit?: function(Node, *): void }} callbacks
+ * @returns {void | walkDOM.STOP}
+ * @see ../docs/walk-dom.md.
+ */ function walkDOM(node, context, callbacks) {
+    // Each stack frame is {node, context, phase}:
+    //   walkDOM.ENTER — call enter, then push children
+    //   walkDOM.EXIT  — call exit
+    var stack = [
+        {
+            node: node,
+            context: context,
+            phase: walkDOM.ENTER
+        }
+    ];
+    while(stack.length > 0){
+        var frame = stack.pop();
+        if (frame.phase === walkDOM.ENTER) {
+            var childContext = callbacks.enter(frame.node, frame.context);
+            if (childContext === walkDOM.STOP) {
+                return walkDOM.STOP;
             }
-        }while (node = node.nextSibling);
+            // Push exit frame before children so it fires after all children are processed (Last In First Out)
+            stack.push({
+                node: frame.node,
+                context: childContext,
+                phase: walkDOM.EXIT
+            });
+            if (childContext === null || childContext === undefined) {
+                continue; // skip children
+            }
+            // lastChild is read after enter returns, so enter may modify the child list.
+            var child = frame.node.lastChild;
+            // Traverse from lastChild backwards so that pushing onto the stack
+            // naturally yields firstChild on top (processed first).
+            while(child){
+                stack.push({
+                    node: child,
+                    context: childContext,
+                    phase: walkDOM.ENTER
+                });
+                child = child.previousSibling;
+            }
+        } else {
+            // frame.phase === walkDOM.EXIT
+            if (callbacks.exit) {
+                callbacks.exit(frame.node, frame.context);
+            }
+        }
     }
 }
+/**
+ * Sentinel value returned from a `walkDOM` `enter` callback to abort the entire traversal
+ * immediately.
+ *
+ * @type {symbol}
+ */ walkDOM.STOP = Symbol('walkDOM.STOP');
+/**
+ * Phase constant for a stack frame that has not yet been visited.
+ * The `enter` callback is called and children are scheduled.
+ *
+ * @type {number}
+ */ walkDOM.ENTER = 0;
+/**
+ * Phase constant for a stack frame whose subtree has been fully visited.
+ * The `exit` callback is called.
+ *
+ * @type {number}
+ */ walkDOM.EXIT = 1;
 /**
  * @typedef DocumentOptions
  * @property {string} [contentType=MIME_TYPE.XML_APPLICATION]
@@ -2987,8 +3164,20 @@ Document.prototype = {
             this.documentElement = newChild;
         }
     },
-    // Introduced in DOM Level 2:
-    importNode: function importNode1(importedNode, deep) {
+    /**
+	 * Imports a node from another document into this document, creating a new copy owned by this
+	 * document. The source node and its subtree are not modified.
+	 *
+	 * @param {Node} importedNode
+	 * The node to import.
+	 * @param {boolean} deep
+	 * If true, the contents of the node are recursively imported.
+	 * If false, only the node itself (and its attributes, if it is an element) are imported.
+	 * @returns {Node}
+	 * Returns the newly created import of the node.
+	 * @see {@link importNode}
+	 * @see {@link https://dom.spec.whatwg.org/#dom-document-importnode}
+	 */ importNode: function importNode1(importedNode, deep) {
         return importNode(this, importedNode, deep);
     },
     // Introduced in DOM Level 2:
@@ -3059,6 +3248,15 @@ Document.prototype = {
     /**
 	 * @param {string} data
 	 * @returns {Comment}
+	 * @see https://dom.spec.whatwg.org/#dom-document-createcomment
+	 * @see https://www.w3.org/TR/xml/#NT-Comment XML 1.0 production [15]
+	 * @see https://www.w3.org/TR/DOM-Parsing/#dfn-concept-serialize-xml §3.2.1.3
+	 *
+	 *      Note: no validation is performed at creation time. When the resulting document is
+	 *      serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`
+	 *      if the comment data contains `--` anywhere, ends with `-`, or contains characters
+	 *      outside the XML Char production (W3C DOM Parsing §3.2.1.3). Without that option the
+	 *      data is emitted verbatim.
 	 */ createComment: function createComment(data) {
         var node = new Comment(PDC);
         node.ownerDocument = this;
@@ -3067,9 +3265,21 @@ Document.prototype = {
         return node;
     },
     /**
+	 * Returns a new CDATASection node whose data is `data`.
+	 *
+	 * __This implementation differs from the specification:__ - calling this method on an HTML
+	 * document does not throw `NotSupportedError`.
+	 *
 	 * @param {string} data
 	 * @returns {CDATASection}
+	 * @throws {DOMException}
+	 * With code `INVALID_CHARACTER_ERR` if `data` contains `"]]>"`.
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/createCDATASection
+	 * @see https://dom.spec.whatwg.org/#dom-document-createcdatasection
 	 */ createCDATASection: function createCDATASection(data) {
+        if (data.indexOf(']]>') !== -1) {
+            throw new DOMException$1(DOMException$1.INVALID_CHARACTER_ERR, 'data contains "]]>"');
+        }
         var node = new CDATASection(PDC);
         node.ownerDocument = this;
         node.childNodes = new NodeList();
@@ -3077,9 +3287,24 @@ Document.prototype = {
         return node;
     },
     /**
+	 * Returns a ProcessingInstruction node whose target is target and data is data.
+	 *
+	 * __This behavior is slightly different from the in the specs__:
+	 * - it does not do any input validation on the arguments and doesn't throw
+	 * "InvalidCharacterError".
+	 *
+	 * Note: When the resulting document is serialized with `requireWellFormed: true`, the
+	 * serializer throws `InvalidStateError` if `.target` contains `:` or is an ASCII
+	 * case-insensitive match for `"xml"`, or if `.data` contains `?>` or characters outside the
+	 * XML Char production (W3C DOM Parsing §3.2.1.7). Without that option the data is emitted
+	 * verbatim.
+	 *
 	 * @param {string} target
 	 * @param {string} data
 	 * @returns {ProcessingInstruction}
+	 * @see https://developer.mozilla.org/docs/Web/API/Document/createProcessingInstruction
+	 * @see https://dom.spec.whatwg.org/#dom-document-createprocessinginstruction
+	 * @see https://www.w3.org/TR/DOM-Parsing/#dfn-concept-serialize-xml §3.2.1.7
 	 */ createProcessingInstruction: function createProcessingInstruction(target, data) {
         var node = new ProcessingInstruction(PDC);
         node.ownerDocument = this;
@@ -3483,7 +3708,31 @@ CDATASection.prototype = {
     nodeType: CDATA_SECTION_NODE
 };
 _extends(CDATASection, Text);
-function DocumentType(symbol) {
+/**
+ * @class DocumentType
+ * @augments Node
+ * @property {string} publicId
+ * The external subset public identifier, stored verbatim (including surrounding quotes).
+ * Declared `readonly` by the WHATWG DOM spec; xmldom does not enforce this constraint —
+ * direct property writes succeed and the written value is serialized verbatim.
+ * When serialized with `requireWellFormed: true`, the serializer validates the value against
+ * the XML `PubidLiteral` production and throws `InvalidStateError` if it does not match.
+ * @property {string} systemId
+ * The external subset system identifier, stored verbatim (including surrounding quotes).
+ * Declared `readonly` by the WHATWG DOM spec; xmldom does not enforce this constraint —
+ * direct property writes succeed and the written value is serialized verbatim.
+ * When serialized with `requireWellFormed: true`, the serializer validates the value against
+ * the XML `SystemLiteral` production and throws `InvalidStateError` if it does not match.
+ * @property {string} internalSubset
+ * The internal subset string (the raw content between `[` and `]`), or an empty string.
+ * Declared `readonly` by the WHATWG DOM spec; xmldom does not enforce this constraint —
+ * direct property writes succeed and the written value is serialized verbatim.
+ * When serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`
+ * if the value contains `"]>"`.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/DocumentType MDN
+ * @see https://dom.spec.whatwg.org/#interface-documenttype WHATWG DOM
+ * @prettierignore
+ */ function DocumentType(symbol) {
     checkSymbol(symbol);
 }
 DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
@@ -3515,11 +3764,89 @@ function ProcessingInstruction(symbol) {
 ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
 _extends(ProcessingInstruction, CharacterData);
 function XMLSerializer$1() {}
-XMLSerializer$1.prototype.serializeToString = function(node, nodeFilter) {
-    return nodeSerializeToString.call(node, nodeFilter);
+/**
+ * Returns the result of serializing `node` to XML.
+ *
+ * When `options.requireWellFormed` is `true`, the serializer throws `InvalidStateError` for
+ * content that would produce ill-formed XML (e.g. CDATASection data containing `"]]>"`, Text
+ * data containing characters outside the XML Char production, or a Document with no
+ * `documentElement`).
+ *
+ * When `options.splitCDATASections` is `false`, CDATASection data is emitted verbatim even
+ * when it contains `"]]>"`. When `true` (the default), `"]]>"` sequences are split across
+ * concatenated CDATA sections — this behavior is **deprecated** and will be removed in the
+ * next breaking release. Callers should migrate to `{ requireWellFormed: true }`, which throws
+ * `InvalidStateError` instead of transforming.
+ *
+ * __This implementation differs from the specification:__ - CDATASection serialization is not
+ * specified by W3C DOM Parsing or WHATWG DOM Parsing (see
+ * {@link https://github.com/w3c/DOM-Parsing/issues/38 w3c/DOM-Parsing#38}).
+ * When `splitCDATASections` is `true` (the default), `"]]>"` sequences in CDATASection data
+ * are split across concatenated CDATA sections — this mechanism is derived from DOM Level 3
+ * Core and is **deprecated**. The split mechanics will be removed in the next breaking
+ * release. Callers that rely on this behavior should migrate to `{ requireWellFormed: true }`.
+ * - W3C DOM Parsing §3.2.1.1 requires well-formedness checks on Element `localName`s,
+ * prefixes,
+ * and attribute serialization (duplicate attributes, namespace declarations, attribute value
+ * characters) when `requireWellFormed` is `true`. These checks are **not implemented** in this
+ * release — see the tracking issue filed against the next breaking milestone.
+ *
+ * @param {Node} node
+ * @param {Object | function} [options]
+ * Options object, or a legacy nodeFilter function (backward compatible).
+ * @param {boolean} [options.requireWellFormed=false]
+ * When `true`, throws `InvalidStateError` for content that would produce ill-formed XML.
+ * @param {boolean} [options.splitCDATASections=true]
+ * When `true` (default), splits `"]]>"` sequences in CDATASection data across concatenated
+ * CDATA sections. **Deprecated** — will be removed in the next breaking release.
+ * @param {function} [options.nodeFilter]
+ * A filter function applied to each node before serialization.
+ * @returns {string}
+ * @throws {DOMException}
+ * With name `InvalidStateError` when `requireWellFormed` is `true` and any of the following
+ * conditions hold:
+ * - CDATASection data contains `"]]>"`
+ * - Text data contains characters outside the XML Char production
+ * - a Comment node's data contains `--` anywhere or ends with `-`
+ * - a ProcessingInstruction's target contains `:` or is an ASCII case-insensitive match for
+ * `"xml"`, or its data contains `?>` or characters outside the XML Char production
+ * - a DocumentType's `publicId` is non-empty and does not match the XML `PubidLiteral`
+ * production (W3C DOM Parsing §3.2.1.3; XML 1.0 production [12])
+ * - a DocumentType's `systemId` is non-empty and does not match the XML `SystemLiteral`
+ * production (W3C DOM Parsing §3.2.1.3; XML 1.0 production [11])
+ * - a DocumentType's `internalSubset` contains `"]>"`
+ * - the Document has no `documentElement`
+ * @see https://developer.mozilla.org/docs/Web/API/XMLSerializer/serializeToString
+ * @see https://html.spec.whatwg.org/#dom-xmlserializer-serializetostring
+ * @see https://github.com/w3c/DOM-Parsing/issues/84
+ * @prettierignore
+ */ XMLSerializer$1.prototype.serializeToString = function(node, options) {
+    return nodeSerializeToString.call(node, options);
 };
 Node.prototype.toString = nodeSerializeToString;
-function nodeSerializeToString(nodeFilter) {
+function nodeSerializeToString(options) {
+    // Normalize the user-supplied options into a single internal opts object so that the
+    // internal serializer always works with a consistent shape rather than positional flags.
+    var opts;
+    if (typeof options === 'function') {
+        opts = {
+            requireWellFormed: false,
+            splitCDATASections: true,
+            nodeFilter: options
+        };
+    } else if (options != null) {
+        opts = {
+            requireWellFormed: !!options.requireWellFormed,
+            splitCDATASections: options.splitCDATASections !== false,
+            nodeFilter: options.nodeFilter || null
+        };
+    } else {
+        opts = {
+            requireWellFormed: false,
+            splitCDATASections: true,
+            nodeFilter: null
+        };
+    }
     var buf = [];
     var refNode = this.nodeType === DOCUMENT_NODE && this.documentElement || this;
     var prefix = refNode.prefix;
@@ -3535,7 +3862,7 @@ function nodeSerializeToString(nodeFilter) {
             ];
         }
     }
-    serializeToString(this, buf, nodeFilter, visibleNamespaces);
+    serializeToString(this, buf, visibleNamespaces, opts);
     return buf.join('');
 }
 function needNamespaceDefine(node, isHTML, visibleNamespaces) {
@@ -3581,222 +3908,302 @@ function needNamespaceDefine(node, isHTML, visibleNamespaces) {
  */ function addSerializedAttribute(buf, qualifiedName, value) {
     buf.push(' ', qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');
 }
-function serializeToString(node, buf, nodeFilter, visibleNamespaces) {
+function serializeToString(node, buf, visibleNamespaces, opts) {
     if (!visibleNamespaces) {
         visibleNamespaces = [];
     }
+    var nodeFilter = opts.nodeFilter;
+    var requireWellFormed = opts.requireWellFormed;
+    var splitCDATASections = opts.splitCDATASections;
     var doc = node.nodeType === DOCUMENT_NODE ? node : node.ownerDocument;
     var isHTML = doc.type === 'html';
-    if (nodeFilter) {
-        node = nodeFilter(node);
-        if (node) {
-            if (typeof node == 'string') {
-                buf.push(node);
-                return;
-            }
-        } else {
-            return;
-        }
-    //buf.sort.apply(attrs, attributeSorter);
-    }
-    switch(node.nodeType){
-        case ELEMENT_NODE:
-            var attrs = node.attributes;
-            var len = attrs.length;
-            var child = node.firstChild;
-            var nodeName = node.tagName;
-            var prefixedNodeName = nodeName;
-            if (!isHTML && !node.prefix && node.namespaceURI) {
-                var defaultNS;
-                // lookup current default ns from `xmlns` attribute
-                for(var ai = 0; ai < attrs.length; ai++){
-                    if (attrs.item(ai).name === 'xmlns') {
-                        defaultNS = attrs.item(ai).value;
-                        break;
+    walkDOM(node, {
+        ns: visibleNamespaces
+    }, {
+        enter: function enter(n, ctx) {
+            var namespaces = ctx.ns;
+            if (nodeFilter) {
+                n = nodeFilter(n);
+                if (n) {
+                    if (typeof n == 'string') {
+                        buf.push(n);
+                        return null;
                     }
+                } else {
+                    return null;
                 }
-                if (!defaultNS) {
-                    // lookup current default ns in visibleNamespaces
-                    for(var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--){
-                        var namespace = visibleNamespaces[nsi];
-                        if (namespace.prefix === '' && namespace.namespace === node.namespaceURI) {
-                            defaultNS = namespace.namespace;
-                            break;
+            }
+            switch(n.nodeType){
+                case ELEMENT_NODE:
+                    var attrs = n.attributes;
+                    var len = attrs.length;
+                    var nodeName = n.tagName;
+                    var prefixedNodeName = nodeName;
+                    if (!isHTML && !n.prefix && n.namespaceURI) {
+                        var defaultNS;
+                        // lookup current default ns from `xmlns` attribute
+                        for(var ai = 0; ai < attrs.length; ai++){
+                            if (attrs.item(ai).name === 'xmlns') {
+                                defaultNS = attrs.item(ai).value;
+                                break;
+                            }
+                        }
+                        if (!defaultNS) {
+                            // lookup current default ns in visibleNamespaces
+                            for(var nsi = namespaces.length - 1; nsi >= 0; nsi--){
+                                var nsEntry = namespaces[nsi];
+                                if (nsEntry.prefix === '' && nsEntry.namespace === n.namespaceURI) {
+                                    defaultNS = nsEntry.namespace;
+                                    break;
+                                }
+                            }
+                        }
+                        if (defaultNS !== n.namespaceURI) {
+                            for(var nsi = namespaces.length - 1; nsi >= 0; nsi--){
+                                var nsEntry = namespaces[nsi];
+                                if (nsEntry.namespace === n.namespaceURI) {
+                                    if (nsEntry.prefix) {
+                                        prefixedNodeName = nsEntry.prefix + ':' + nodeName;
+                                    }
+                                    break;
+                                }
+                            }
                         }
                     }
-                }
-                if (defaultNS !== node.namespaceURI) {
-                    for(var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--){
-                        var namespace = visibleNamespaces[nsi];
-                        if (namespace.namespace === node.namespaceURI) {
-                            if (namespace.prefix) {
-                                prefixedNodeName = namespace.prefix + ':' + nodeName;
+                    buf.push('<', prefixedNodeName);
+                    // Build a fresh namespace snapshot for this element's children.
+                    // The slice prevents sibling elements from inheriting each other's declarations.
+                    var childNamespaces = namespaces.slice();
+                    for(var i = 0; i < len; i++){
+                        // add namespaces for attributes
+                        var attr = attrs.item(i);
+                        if (attr.prefix == 'xmlns') {
+                            childNamespaces.push({
+                                prefix: attr.localName,
+                                namespace: attr.value
+                            });
+                        } else if (attr.nodeName == 'xmlns') {
+                            childNamespaces.push({
+                                prefix: '',
+                                namespace: attr.value
+                            });
+                        }
+                    }
+                    for(var i = 0; i < len; i++){
+                        var attr = attrs.item(i);
+                        if (needNamespaceDefine(attr, isHTML, childNamespaces)) {
+                            var attrPrefix = attr.prefix || '';
+                            var uri = attr.namespaceURI;
+                            addSerializedAttribute(buf, attrPrefix ? 'xmlns:' + attrPrefix : 'xmlns', uri);
+                            childNamespaces.push({
+                                prefix: attrPrefix,
+                                namespace: uri
+                            });
+                        }
+                        // Apply nodeFilter and serialize the attribute.
+                        var filteredAttr = nodeFilter ? nodeFilter(attr) : attr;
+                        if (filteredAttr) {
+                            if (typeof filteredAttr === 'string') {
+                                buf.push(filteredAttr);
+                            } else {
+                                addSerializedAttribute(buf, filteredAttr.name, filteredAttr.value);
                             }
-                            break;
                         }
                     }
-                }
-            }
-            buf.push('<', prefixedNodeName);
-            for(var i = 0; i < len; i++){
-                // add namespaces for attributes
-                var attr = attrs.item(i);
-                if (attr.prefix == 'xmlns') {
-                    visibleNamespaces.push({
-                        prefix: attr.localName,
-                        namespace: attr.value
-                    });
-                } else if (attr.nodeName == 'xmlns') {
-                    visibleNamespaces.push({
-                        prefix: '',
-                        namespace: attr.value
-                    });
-                }
-            }
-            for(var i = 0; i < len; i++){
-                var attr = attrs.item(i);
-                if (needNamespaceDefine(attr, isHTML, visibleNamespaces)) {
-                    var prefix = attr.prefix || '';
-                    var uri = attr.namespaceURI;
-                    addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : 'xmlns', uri);
-                    visibleNamespaces.push({
-                        prefix: prefix,
-                        namespace: uri
-                    });
-                }
-                serializeToString(attr, buf, nodeFilter, visibleNamespaces);
-            }
-            // add namespace for current node
-            if (nodeName === prefixedNodeName && needNamespaceDefine(node, isHTML, visibleNamespaces)) {
-                var prefix = node.prefix || '';
-                var uri = node.namespaceURI;
-                addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : 'xmlns', uri);
-                visibleNamespaces.push({
-                    prefix: prefix,
-                    namespace: uri
-                });
-            }
-            // in XML elements can be closed when they have no children
-            var canCloseTag = !child;
-            if (canCloseTag && (isHTML || node.namespaceURI === NAMESPACE$2.HTML)) {
-                // in HTML (doc or ns) only void elements can be closed right away
-                canCloseTag = isHTMLVoidElement(nodeName);
-            }
-            if (canCloseTag) {
-                buf.push('/>');
-            } else {
-                buf.push('>');
-                //if is cdata child node
-                if (isHTML && isHTMLRawTextElement$1(nodeName)) {
-                    while(child){
-                        if (child.data) {
-                            buf.push(child.data);
-                        } else {
-                            serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
+                    // add namespace for current node
+                    if (nodeName === prefixedNodeName && needNamespaceDefine(n, isHTML, childNamespaces)) {
+                        var nodePrefix = n.prefix || '';
+                        var uri = n.namespaceURI;
+                        addSerializedAttribute(buf, nodePrefix ? 'xmlns:' + nodePrefix : 'xmlns', uri);
+                        childNamespaces.push({
+                            prefix: nodePrefix,
+                            namespace: uri
+                        });
+                    }
+                    // in XML elements can be closed when they have no children
+                    var canCloseTag = !n.firstChild;
+                    if (canCloseTag && (isHTML || n.namespaceURI === NAMESPACE$2.HTML)) {
+                        // in HTML (doc or ns) only void elements can be closed right away
+                        canCloseTag = isHTMLVoidElement(nodeName);
+                    }
+                    if (canCloseTag) {
+                        buf.push('/>');
+                        // Self-closing: no children and no closing tag needed from exit.
+                        return null;
+                    }
+                    buf.push('>');
+                    // HTML raw text elements: serialize children as raw data without further descent.
+                    if (isHTML && isHTMLRawTextElement$1(nodeName)) {
+                        var child = n.firstChild;
+                        while(child){
+                            if (child.data) {
+                                buf.push(child.data);
+                            } else {
+                                serializeToString(child, buf, childNamespaces.slice(), opts);
+                            }
+                            child = child.nextSibling;
                         }
-                        child = child.nextSibling;
+                        buf.push('</', prefixedNodeName, '>');
+                        // Children handled manually above; prevent walkDOM from also traversing them.
+                        return null;
                     }
-                } else {
-                    while(child){
-                        serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
-                        child = child.nextSibling;
+                    // Return child context so walkDOM descends; exit will emit the closing tag.
+                    return {
+                        ns: childNamespaces,
+                        tag: prefixedNodeName
+                    };
+                case DOCUMENT_NODE:
+                case DOCUMENT_FRAGMENT_NODE:
+                    if (requireWellFormed && n.nodeType === DOCUMENT_NODE && n.documentElement == null) {
+                        throw new DOMException$1('The Document has no documentElement', DOMExceptionName.InvalidStateError);
                     }
-                }
-                buf.push('</', prefixedNodeName, '>');
-            }
-            // remove added visible namespaces
-            //visibleNamespaces.length = startVisibleNamespaces;
-            return;
-        case DOCUMENT_NODE:
-        case DOCUMENT_FRAGMENT_NODE:
-            var child = node.firstChild;
-            while(child){
-                serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
-                child = child.nextSibling;
-            }
-            return;
-        case ATTRIBUTE_NODE:
-            return addSerializedAttribute(buf, node.name, node.value);
-        case TEXT_NODE:
-            /*
-			 * The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,
-			 * except when used as markup delimiters, or within a comment, a processing instruction,
-			 * or a CDATA section.
-			 * If they are needed elsewhere, they must be escaped using either numeric character
-			 * references or the strings `&amp;` and `&lt;` respectively.
-			 * The right angle bracket (>) may be represented using the string " &gt; ",
-			 * and must, for compatibility, be escaped using either `&gt;`,
-			 * or a character reference when it appears in the string `]]>` in content,
-			 * when that string is not marking the end of a CDATA section.
-			 *
-			 * In the content of elements, character data is any string of characters which does not
-			 * contain the start-delimiter of any markup and does not include the CDATA-section-close
-			 * delimiter, `]]>`.
-			 *
-			 * @see https://www.w3.org/TR/xml/#NT-CharData
-			 * @see https://w3c.github.io/DOM-Parsing/#xml-serializing-a-text-node
-			 */ return buf.push(node.data.replace(/[<&>]/g, _xmlEncoder));
-        case CDATA_SECTION_NODE:
-            return buf.push(g$1.CDATA_START, node.data, g$1.CDATA_END);
-        case COMMENT_NODE:
-            return buf.push(g$1.COMMENT_START, node.data, g$1.COMMENT_END);
-        case DOCUMENT_TYPE_NODE:
-            var pubid = node.publicId;
-            var sysid = node.systemId;
-            buf.push(g$1.DOCTYPE_DECL_START, ' ', node.name);
-            if (pubid) {
-                buf.push(' ', g$1.PUBLIC, ' ', pubid);
-                if (sysid && sysid !== '.') {
-                    buf.push(' ', sysid);
-                }
-            } else if (sysid && sysid !== '.') {
-                buf.push(' ', g$1.SYSTEM, ' ', sysid);
+                    // Pass namespaces through; each child element will slice independently.
+                    return {
+                        ns: namespaces
+                    };
+                case ATTRIBUTE_NODE:
+                    addSerializedAttribute(buf, n.name, n.value);
+                    return null;
+                case TEXT_NODE:
+                    /*
+						 * The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,
+						 * except when used as markup delimiters, or within a comment, a processing instruction,
+						 * or a CDATA section.
+						 * If they are needed elsewhere, they must be escaped using either numeric character
+						 * references or the strings `&amp;` and `&lt;` respectively.
+						 * The right angle bracket (>) may be represented using the string " &gt; ",
+						 * and must, for compatibility, be escaped using either `&gt;`,
+						 * or a character reference when it appears in the string `]]>` in content,
+						 * when that string is not marking the end of a CDATA section.
+						 *
+						 * In the content of elements, character data is any string of characters which does not
+						 * contain the start-delimiter of any markup and does not include the CDATA-section-close
+						 * delimiter, `]]>`.
+						 *
+						 * @see https://www.w3.org/TR/xml/#NT-CharData
+						 * @see https://w3c.github.io/DOM-Parsing/#xml-serializing-a-text-node
+						 */ if (requireWellFormed && g$1.InvalidChar.test(n.data)) {
+                        throw new DOMException$1('The Text node data contains characters outside the XML Char production', DOMExceptionName.InvalidStateError);
+                    }
+                    buf.push(n.data.replace(/[<&>]/g, _xmlEncoder));
+                    return null;
+                case CDATA_SECTION_NODE:
+                    if (requireWellFormed && n.data.indexOf(']]>') !== -1) {
+                        throw new DOMException$1('The CDATASection data contains "]]>"', DOMExceptionName.InvalidStateError);
+                    }
+                    if (splitCDATASections) {
+                        buf.push(g$1.CDATA_START, n.data.replace(/]]>/g, ']]]]><![CDATA[>'), g$1.CDATA_END);
+                    } else {
+                        buf.push(g$1.CDATA_START, n.data, g$1.CDATA_END);
+                    }
+                    return null;
+                case COMMENT_NODE:
+                    if (requireWellFormed) {
+                        if (g$1.InvalidChar.test(n.data)) {
+                            throw new DOMException$1('The comment node data contains characters outside the XML Char production', DOMExceptionName.InvalidStateError);
+                        }
+                        if (n.data.indexOf('--') !== -1 || n.data[n.data.length - 1] === '-') {
+                            throw new DOMException$1('The comment node data contains "--" or ends with "-"', DOMExceptionName.InvalidStateError);
+                        }
+                    }
+                    buf.push(g$1.COMMENT_START, n.data, g$1.COMMENT_END);
+                    return null;
+                case DOCUMENT_TYPE_NODE:
+                    var pubid = n.publicId;
+                    var sysid = n.systemId;
+                    if (requireWellFormed) {
+                        if (pubid && !g$1.PubidLiteral_match.test(pubid)) {
+                            throw new DOMException$1('DocumentType publicId is not a valid PubidLiteral', DOMExceptionName.InvalidStateError);
+                        }
+                        if (sysid && sysid !== '.' && !g$1.SystemLiteral_match.test(sysid)) {
+                            throw new DOMException$1('DocumentType systemId is not a valid SystemLiteral', DOMExceptionName.InvalidStateError);
+                        }
+                        if (n.internalSubset && n.internalSubset.indexOf(']>') !== -1) {
+                            throw new DOMException$1('DocumentType internalSubset contains "]>"', DOMExceptionName.InvalidStateError);
+                        }
+                    }
+                    buf.push(g$1.DOCTYPE_DECL_START, ' ', n.name);
+                    if (pubid) {
+                        buf.push(' ', g$1.PUBLIC, ' ', pubid);
+                        if (sysid && sysid !== '.') {
+                            buf.push(' ', sysid);
+                        }
+                    } else if (sysid && sysid !== '.') {
+                        buf.push(' ', g$1.SYSTEM, ' ', sysid);
+                    }
+                    if (n.internalSubset) {
+                        buf.push(' [', n.internalSubset, ']');
+                    }
+                    buf.push('>');
+                    return null;
+                case PROCESSING_INSTRUCTION_NODE:
+                    if (requireWellFormed) {
+                        if (n.target.indexOf(':') !== -1 || n.target.toLowerCase() === 'xml') {
+                            throw new DOMException$1('The ProcessingInstruction target is not well-formed', DOMExceptionName.InvalidStateError);
+                        }
+                        if (g$1.InvalidChar.test(n.data)) {
+                            throw new DOMException$1('The ProcessingInstruction data contains characters outside the XML Char production', DOMExceptionName.InvalidStateError);
+                        }
+                        if (n.data.indexOf('?>') !== -1) {
+                            throw new DOMException$1('The ProcessingInstruction data contains "?>"', DOMExceptionName.InvalidStateError);
+                        }
+                    }
+                    buf.push('<?', n.target, ' ', n.data, '?>');
+                    return null;
+                case ENTITY_REFERENCE_NODE:
+                    buf.push('&', n.nodeName, ';');
+                    return null;
+                //case ENTITY_NODE:
+                //case NOTATION_NODE:
+                default:
+                    buf.push('??', n.nodeName);
+                    return null;
             }
-            if (node.internalSubset) {
-                buf.push(' [', node.internalSubset, ']');
+        },
+        exit: function exit(n, childCtx) {
+            // Emit the closing tag for elements that were opened (not self-closed, not raw text).
+            if (childCtx && childCtx.tag) {
+                buf.push('</', childCtx.tag, '>');
             }
-            buf.push('>');
-            return;
-        case PROCESSING_INSTRUCTION_NODE:
-            return buf.push('<?', node.target, ' ', node.data, '?>');
-        case ENTITY_REFERENCE_NODE:
-            return buf.push('&', node.nodeName, ';');
-        //case ENTITY_NODE:
-        //case NOTATION_NODE:
-        default:
-            buf.push('??', node.nodeName);
-    }
+        }
+    });
 }
-function importNode(doc, node, deep) {
-    var node2;
-    switch(node.nodeType){
-        case ELEMENT_NODE:
-            node2 = node.cloneNode(false);
-            node2.ownerDocument = doc;
-        //var attrs = node2.attributes;
-        //var len = attrs.length;
-        //for(var i=0;i<len;i++){
-        //node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));
-        //}
-        case DOCUMENT_FRAGMENT_NODE:
-            break;
-        case ATTRIBUTE_NODE:
-            deep = true;
-            break;
-    }
-    if (!node2) {
-        node2 = node.cloneNode(false); //false
-    }
-    node2.ownerDocument = doc;
-    node2.parentNode = null;
-    if (deep) {
-        var child = node.firstChild;
-        while(child){
-            node2.appendChild(importNode(doc, child, deep));
-            child = child.nextSibling;
+/**
+ * Imports a node from a different document into `doc`, creating a new copy.
+ * Delegates to {@link walkDOM} for traversal. Each node in the subtree is shallow-cloned,
+ * stamped with `doc` as its `ownerDocument`, and detached (`parentNode` set to `null`).
+ * Children are imported recursively when `deep` is `true`; for {@link Attr} nodes `deep` is
+ * always forced to `true`
+ * because an attribute's value lives in a child text node.
+ *
+ * @param {Document} doc
+ * The document that will own the imported node.
+ * @param {Node} node
+ * The node to import.
+ * @param {boolean} deep
+ * If `true`, descendants are imported recursively.
+ * @returns {Node}
+ * The newly imported node, now owned by `doc`.
+ */ function importNode(doc, node, deep) {
+    var destRoot;
+    walkDOM(node, null, {
+        enter: function enter(srcNode, destParent) {
+            // Shallow-clone the node and stamp it into the target document.
+            var destNode = srcNode.cloneNode(false);
+            destNode.ownerDocument = doc;
+            destNode.parentNode = null;
+            // capture as the root of the imported subtree or attach to parent.
+            if (destParent === null) {
+                destRoot = destNode;
+            } else {
+                destParent.appendChild(destNode);
+            }
+            // ATTRIBUTE_NODE must always be imported deeply: its value lives in a child text node.
+            var shouldDeep = srcNode.nodeType === ATTRIBUTE_NODE || deep;
+            return shouldDeep ? destNode : null;
         }
-    }
-    return node2;
+    });
+    return destRoot;
 }
 /**
  * Creates a copy of a node from an existing one.
@@ -3814,46 +4221,73 @@ function importNode(doc, node, deep) {
  * May throw a DOMException if operations within setAttributeNode or appendChild (which are
  * potentially invoked in this function) do not meet their specific constraints.
  */ function cloneNode(doc, node, deep) {
-    var node2 = new node.constructor(PDC);
-    for(var n in node){
-        if (hasOwn$1(node, n)) {
-            var v = node[n];
-            if ((typeof v === "undefined" ? "undefined" : _type_of(v)) != 'object') {
-                if (v != node2[n]) {
-                    node2[n] = v;
+    var destRoot;
+    walkDOM(node, null, {
+        enter: function enter(srcNode, destParent) {
+            // 1. Create a blank node of the same type and copy all scalar own properties.
+            var destNode = new srcNode.constructor(PDC);
+            for(var n in srcNode){
+                if (hasOwn$1(srcNode, n)) {
+                    var v = srcNode[n];
+                    if ((typeof v === "undefined" ? "undefined" : _type_of(v)) != 'object') {
+                        if (v != destNode[n]) {
+                            destNode[n] = v;
+                        }
+                    }
                 }
             }
-        }
-    }
-    if (node.childNodes) {
-        node2.childNodes = new NodeList();
-    }
-    node2.ownerDocument = doc;
-    switch(node2.nodeType){
-        case ELEMENT_NODE:
-            var attrs = node.attributes;
-            var attrs2 = node2.attributes = new NamedNodeMap();
-            var len = attrs.length;
-            attrs2._ownerElement = node2;
-            for(var i = 0; i < len; i++){
-                node2.setAttributeNode(cloneNode(doc, attrs.item(i), true));
+            if (srcNode.childNodes) {
+                destNode.childNodes = new NodeList();
             }
-            break;
-        case ATTRIBUTE_NODE:
-            deep = true;
-    }
-    if (deep) {
-        var child = node.firstChild;
-        while(child){
-            node2.appendChild(cloneNode(doc, child, deep));
-            child = child.nextSibling;
+            destNode.ownerDocument = doc;
+            // 2. Handle node-type-specific setup.
+            //    Attributes are not DOM children, so they are cloned inline here
+            //    rather than by walkDOM descent.
+            //    ATTRIBUTE_NODE forces deep=true so its own children are walked.
+            var shouldDeep = deep;
+            switch(destNode.nodeType){
+                case ELEMENT_NODE:
+                    var attrs = srcNode.attributes;
+                    var attrs2 = destNode.attributes = new NamedNodeMap();
+                    var len = attrs.length;
+                    attrs2._ownerElement = destNode;
+                    for(var i = 0; i < len; i++){
+                        destNode.setAttributeNode(cloneNode(doc, attrs.item(i), true));
+                    }
+                    break;
+                case ATTRIBUTE_NODE:
+                    shouldDeep = true;
+            }
+            // 3. Attach to parent, or capture as the root of the cloned subtree.
+            if (destParent !== null) {
+                destParent.appendChild(destNode);
+            } else {
+                destRoot = destNode;
+            }
+            // 4. Return destNode as the context for children (causes walkDOM to descend),
+            //    or null to skip children (shallow clone).
+            return shouldDeep ? destNode : null;
         }
-    }
-    return node2;
+    });
+    return destRoot;
 }
 function __set__(object, key, value) {
     object[key] = value;
 }
+// Returns a new array of direct Element children.
+// Passed to LiveNodeList to implement ParentNode.children.
+// https://dom.spec.whatwg.org/#dom-parentnode-children
+function childrenRefresh(node) {
+    var ls = [];
+    var child = node.firstChild;
+    while(child){
+        if (child.nodeType === ELEMENT_NODE) {
+            ls.push(child);
+        }
+        child = child.nextSibling;
+    }
+    return ls;
+}
 //do dynamic
 try {
     if (Object.defineProperty) {
@@ -3863,9 +4297,36 @@ try {
                 return this.$$length;
             }
         });
-        Object.defineProperty(Node.prototype, 'textContent', {
+        /**
+		 * The text content of this node and its descendants.
+		 *
+		 * For {@link Element} and {@link DocumentFragment} nodes, returns the concatenation of the
+		 * `nodeValue` of every descendant text node, excluding processing instruction and comment
+		 * nodes. For all other node types, returns `nodeValue`.
+		 *
+		 * Setting `textContent` on an element or document fragment replaces all child nodes with a
+		 * single text node; on other nodes it sets `data`, `value`, and `nodeValue` directly.
+		 *
+		 * @type {string | null}
+		 * @see {@link https://dom.spec.whatwg.org/#dom-node-textcontent}
+		 */ Object.defineProperty(Node.prototype, 'textContent', {
             get: function get() {
-                return getTextContent(this);
+                if (this.nodeType === ELEMENT_NODE || this.nodeType === DOCUMENT_FRAGMENT_NODE) {
+                    var buf = [];
+                    walkDOM(this, null, {
+                        enter: function enter(n) {
+                            if (n.nodeType === ELEMENT_NODE || n.nodeType === DOCUMENT_FRAGMENT_NODE) {
+                                return true; // enter children
+                            }
+                            if (n.nodeType === PROCESSING_INSTRUCTION_NODE || n.nodeType === COMMENT_NODE) {
+                                return null; // excluded from text content
+                            }
+                            buf.push(n.nodeValue);
+                        }
+                    });
+                    return buf.join('');
+                }
+                return this.nodeValue;
             },
             set: function set(data) {
                 switch(this.nodeType){
@@ -3885,23 +4346,21 @@ try {
                 }
             }
         });
-        function getTextContent(node) {
-            switch(node.nodeType){
-                case ELEMENT_NODE:
-                case DOCUMENT_FRAGMENT_NODE:
-                    var buf = [];
-                    node = node.firstChild;
-                    while(node){
-                        if (node.nodeType !== 7 && node.nodeType !== 8) {
-                            buf.push(getTextContent(node));
-                        }
-                        node = node.nextSibling;
-                    }
-                    return buf.join('');
-                default:
-                    return node.nodeValue;
+        Object.defineProperty(Element.prototype, 'children', {
+            get: function get() {
+                return new LiveNodeList(this, childrenRefresh);
             }
-        }
+        });
+        Object.defineProperty(Document.prototype, 'children', {
+            get: function get() {
+                return new LiveNodeList(this, childrenRefresh);
+            }
+        });
+        Object.defineProperty(DocumentFragment.prototype, 'children', {
+            get: function get() {
+                return new LiveNodeList(this, childrenRefresh);
+            }
+        });
         __set__ = function __set__(object, key, value) {
             //console.log(value)
             object['$$' + key] = value;
@@ -3929,6 +4388,7 @@ dom$2.NodeList = NodeList;
 dom$2.Notation = Notation;
 dom$2.Text = Text;
 dom$2.ProcessingInstruction = ProcessingInstruction;
+dom$2.walkDOM = walkDOM;
 dom$2.XMLSerializer = XMLSerializer$1;
 
 var domParser$1 = {};
@@ -7632,76 +8092,200 @@ function requireErrors () {
 	    this.stack = new Error(message).stack;
 	}
 	XTAPIVersionError.prototype = new XTError();
-	function throwApiVersionError(msg, properties) {
+	/*
+	 * Version/Compatibility Errors
+	 * ============================
+	 */ function throwApiVersionError(msg, properties) {
 	    var err = new XTAPIVersionError(msg);
-	    err.properties = _objectSpread({
+	    /*
+	   * This error arises when a recent module version necessitates a more
+	   * current version of the docxtemplater core. Docxtemplater specifies an
+	   * "APIVersion," and if a module requires API Version 3.55 or higher,
+	   * but the docxtemplater instance provides API 3.52, this error will
+	   * occur. To resolve this issue, please update to the latest version of
+	   * docxtemplater.
+	   */ err.properties = _objectSpread({
 	        id: "api_version_error"
 	    }, properties);
 	    throw err;
 	}
-	function throwMultiError(errors) {
-	    var err = new XTTemplateError("Multi error");
-	    err.properties = {
-	        errors: errors,
-	        id: "multi_error",
-	        explanation: "The template has multiple errors"
+	function throwFileTypeNotIdentified(zip) {
+	    var files = Object.keys(zip.files).slice(0, 10);
+	    var msg = "";
+	    if (files.length === 0) {
+	        msg = "Empty zip file";
+	    } else {
+	        msg = "Zip file contains : ".concat(files.join(","));
+	    }
+	    var err = new XTInternalError("The filetype for this file could not be identified, is this file corrupted ? ".concat(msg));
+	    /*
+	   * This error happens if you're creating docxtemplater with a zip file, but that file is not recognized as a docx/pptx/xlsx or odt file.
+	   *
+	   * Note that xlsx files and odt files need a paid module to be templated.
+	   *
+	   * Other zip files (zip, odp, ods) will trigger the same error.
+	   */ err.properties = {
+	        id: "filetype_not_identified",
+	        explanation: "The filetype for this file could not be identified, is this file corrupted ? ".concat(msg)
 	    };
 	    throw err;
 	}
-	function getUnopenedTagException(options) {
-	    var err = new XTTemplateError("Unopened tag");
-	    err.properties = {
+	function throwFileTypeNotHandled(fileType) {
+	    var err = new XTInternalError("The filetype \"".concat(fileType, "\" is not handled by docxtemplater"));
+	    /*
+	   * This error happens if the filetype was recognized (xlsx, odt), but
+	   * without the correct module, this file cannot be templated
+	   */ err.properties = {
+	        id: "filetype_not_handled",
+	        explanation: "The file you are trying to generate is of type \"".concat(fileType, "\", but only docx and pptx formats are handled"),
+	        fileType: fileType
+	    };
+	    throw err;
+	}
+	/*
+	 * Template Errors
+	 * ===============
+	 */ function throwMultiError(errors) {
+	    var err = new XTTemplateError("Multi error");
+	    /*
+	   * This error is an Error that contains all template errors.
+	   * It is a multi error because it contains all errors of the template in :
+	   * err.properties.errors.
+	   *
+	   * You can then map on each sub error like this :
+	   *
+	   * ```js
+	   * for (const err of error.properties.errors) {
+	   *   console.log(err.properties.explanation);
+	   * }
+	   * ```
+	   */ err.properties = {
+	        errors: errors,
+	        id: "multi_error",
+	        explanation: "The template has multiple errors"
+	    };
+	    throw err;
+	}
+	function getUnopenedTagException(options) {
+	    var err = new XTTemplateError("Unopened tag");
+	    /*
+	   * This error happens if a tag is closed but not opened. For example with
+	   * the following template:
+	   *
+	   * ```docx
+	   * Hello name} !
+	   * ```
+	   */ err.properties = {
 	        xtag: last(options.xtag.split(" ")),
 	        id: "unopened_tag",
 	        context: options.xtag,
 	        offset: options.offset,
 	        lIndex: options.lIndex,
-	        explanation: "The tag beginning with \"".concat(options.xtag.substr(0, 10), "\" is unopened")
+	        explanation: "The tag beginning with \"".concat(options.xtag.substr(0, 30), "\" is unopened")
 	    };
 	    return err;
 	}
 	function getDuplicateOpenTagException(options) {
 	    var err = new XTTemplateError("Duplicate open tag, expected one open tag");
-	    err.properties = {
+	    /*
+	   * This error happens with following template :
+	   *
+	   * ```docx
+	   * Hello {{name
+	   * ```
+	   */ err.properties = {
 	        xtag: first(options.xtag.split(" ")),
 	        id: "duplicate_open_tag",
 	        context: options.xtag,
 	        offset: options.offset,
 	        lIndex: options.lIndex,
-	        explanation: "The tag beginning with \"".concat(options.xtag.substr(0, 10), "\" has duplicate open tags")
+	        explanation: "The tag beginning with \"".concat(options.xtag.substr(0, 30), "\" has duplicate open tags")
 	    };
 	    return err;
 	}
 	function getDuplicateCloseTagException(options) {
 	    var err = new XTTemplateError("Duplicate close tag, expected one close tag");
-	    err.properties = {
+	    /*
+	   * This error happens with following template :
+	   *
+	   * ```docx
+	   * Hello {name}}
+	   * ```
+	   */ err.properties = {
 	        xtag: first(options.xtag.split(" ")),
 	        id: "duplicate_close_tag",
 	        context: options.xtag,
 	        offset: options.offset,
 	        lIndex: options.lIndex,
-	        explanation: "The tag ending with \"".concat(options.xtag.substr(0, 10), "\" has duplicate close tags")
+	        explanation: "The tag ending with \"".concat(options.xtag.substr(0, 30), "\" has duplicate close tags")
 	    };
 	    return err;
 	}
 	function getUnclosedTagException(options) {
 	    var err = new XTTemplateError("Unclosed tag");
-	    err.properties = {
+	    /*
+	   * This error happens if a tag is opened but not closed.
+	   * For example with the following template:
+	   *
+	   * ```docx
+	   * Hello {name !
+	   * ```
+	   */ err.properties = {
 	        xtag: first(options.xtag.split(" ")).substr(1),
+	        // name
 	        id: "unclosed_tag",
 	        context: options.xtag,
 	        offset: options.offset,
 	        lIndex: options.lIndex,
-	        explanation: "The tag beginning with \"".concat(options.xtag.substr(0, 10), "\" is unclosed")
+	        explanation: "The tag beginning with \"".concat(options.xtag.substr(0, 30), "\" is unclosed")
 	    };
 	    return err;
 	}
 	function throwXmlTagNotFound(options) {
+	    if (options.position === "left") {
+	        throwXmlTagNotFoundLeft(options);
+	    } else {
+	        throwXmlTagNotFoundRight(options);
+	    }
+	}
+	/*
+	 * Raw XML / XML Expansion Errors
+	 * ==============================
+	 */ function throwXmlTagNotFoundLeft(options) {
 	    var err = new XTTemplateError("No tag \"".concat(options.element, "\" was found at the ").concat(options.position));
 	    var part = options.parsed[options.index];
-	    err.properties = {
-	        id: "no_xml_tag_found_at_".concat(options.position),
-	        explanation: "No tag \"".concat(options.element, "\" was found at the ").concat(options.position),
+	    /*
+	   * This error is not directly linked to the template, it means that some
+	   * tag tried to expand to adjacent XML tags, but those elements cannot be
+	   * accessed from the current node.
+	   *
+	   * This error happens if a rawXMLTag doesn't find a `<w:p>` element
+	   *
+	   * ```docx
+	   * <w:p><w:t>{@raw}</w:t>
+	   * // Note  that the `</w:p>` tag is missing.
+	   * ```
+	   */ err.properties = {
+	        id: "no_xml_tag_found_at_left",
+	        explanation: "No tag \"".concat(options.element, "\" was found at the left"),
+	        offset: part.offset,
+	        part: part,
+	        parsed: options.parsed,
+	        index: options.index,
+	        element: options.element
+	    };
+	    throw err;
+	}
+	function throwXmlTagNotFoundRight(options) {
+	    var err = new XTTemplateError("No tag \"".concat(options.element, "\" was found at the ").concat(options.position));
+	    var part = options.parsed[options.index];
+	    /*
+	   * This error is not directly linked to the template, it means that some
+	   * tag tried to expand to adjacent XML tags, but those elements cannot be
+	   * accessed from the current node.
+	   */ err.properties = {
+	        id: "no_xml_tag_found_at_right",
+	        explanation: "No tag \"".concat(options.element, "\" was found at the right"),
 	        offset: part.offset,
 	        part: part,
 	        parsed: options.parsed,
@@ -7713,24 +8297,35 @@ function requireErrors () {
 	function getCorruptCharactersException(_ref) {
 	    var tag = _ref.tag, value = _ref.value, offset = _ref.offset;
 	    var err = new XTRenderingError("There are some XML corrupt characters");
-	    err.properties = {
+	    /*
+	   * This error prevents the docx document to become corrupt.
+	   * It happens if you're trying to render text that would produce invalid XML output.
+	   *
+	   * See #corrupt-character-error on how this can be fixed by changing your parser.
+	   */ err.properties = {
 	        id: "invalid_xml_characters",
 	        xtag: tag,
 	        value: value,
 	        offset: offset,
-	        explanation: "There are some corrupt characters for the field ".concat(tag)
+	        explanation: "There are some corrupt characters for the field \"".concat(tag, "\"")
 	    };
 	    return err;
 	}
 	function getInvalidRawXMLValueException(_ref2) {
-	    var tag = _ref2.tag, value = _ref2.value, offset = _ref2.offset;
+	    var tag = _ref2.tag, value = _ref2.value, offset = _ref2.offset, partDelims = _ref2.partDelims;
 	    var err = new XTRenderingError("Non string values are not allowed for rawXML tags");
-	    err.properties = {
+	    /*
+	   * This error happens if you try to render a rawXml tag, such as : {@raw}
+	   * And the value of the data for "raw" is truthy but not a string.
+	   *
+	   * (If the value of the data is falsy, than the tag is simply dropped and
+	   * no error is thrown)
+	   */ err.properties = {
 	        id: "invalid_raw_xml_value",
 	        xtag: tag,
 	        value: value,
 	        offset: offset,
-	        explanation: "The value of the raw tag : '".concat(tag, "' is not a string")
+	        explanation: "The value of the raw tag : \"".concat(partDelims, "\" is not a string")
 	    };
 	    return err;
 	}
@@ -7741,7 +8336,10 @@ function requireErrors () {
 	    if (typeof explanation === "function") {
 	        explanation = explanation(part);
 	    }
-	    var err = new XTTemplateError(message);
+	    /*
+	   * This error happens if you try to render a rawXml tag, such as : {@raw},
+	   * but that tag is not placed inside a paragraph.
+	   */ var err = new XTTemplateError(message);
 	    err.properties = {
 	        id: id,
 	        explanation: explanation,
@@ -7757,7 +8355,36 @@ function requireErrors () {
 	function throwRawTagShouldBeOnlyTextInParagraph(options) {
 	    var err = new XTTemplateError("Raw tag should be the only text in paragraph");
 	    var tag = options.part.value;
-	    err.properties = {
+	    /*
+	   * This happens when a rawXMLTag {@raw} is not the only text in the
+	   * paragraph. For example, writing ` {@raw}` (Note the spaces)
+	   * is not acceptable because the {@raw} tag replaces the full paragraph. We
+	   * prefer to throw an Error now rather than have "strange behavior"
+	   * because the spaces "disappeared".
+	   *
+	   * To correct this error, you have to add manually the text that you want
+	   * in your raw tag. (Or you can use the [docxtemplater word-run
+	   * module](/modules/word-run/) which adds a tag
+	   * that can replace rawXML inside a tag).
+	   *
+	   * Writing
+	   *
+	   * ```docx
+	   * {@my_first_tag}{my_second_tag}
+	   * ```
+	   *
+	   * Or even
+	   *
+	   * ```docx
+	   * Hello {@my_first_tag}
+	   * ```
+	   *
+	   * Is misusing docxtemplater.
+	   *
+	   * The `@` at the beginning means "replace the xml of **the
+	   * current paragraph** with scope.my_first_tag" so that means that
+	   * everything else in that Paragraph will be removed.
+	   */ err.properties = {
 	        id: "raw_xml_tag_should_be_only_text_in_paragraph",
 	        explanation: "The raw tag \"".concat(tag, "\" should be the only text in this paragraph. This means that this tag should not be surrounded by any text or spaces."),
 	        xtag: tag,
@@ -7766,13 +8393,23 @@ function requireErrors () {
 	    };
 	    throw err;
 	}
-	function getUnmatchedLoopException(part) {
+	/*
+	 * Loop / Table Structure Errors
+	 * =============================
+	 */ function getUnmatchedLoopException(part) {
 	    var location = part.location, offset = part.offset, square = part.square;
 	    var t = location === "start" ? "unclosed" : "unopened";
 	    var T = location === "start" ? "Unclosed" : "Unopened";
 	    var err = new XTTemplateError("".concat(T, " loop"));
 	    var tag = part.value;
-	    err.properties = {
+	    /*
+	   * This error happens with following template :
+	   *
+	   * ```docx
+	   * {#users}
+	   * {/companies}
+	   * ```
+	   */ err.properties = {
 	        id: "".concat(t, "_loop"),
 	        explanation: "The loop with tag \"".concat(tag, "\" is ").concat(t),
 	        xtag: tag,
@@ -7789,7 +8426,25 @@ function requireErrors () {
 	    var lastR = lastPair[1].part.value;
 	    var l = pair[0].part.value;
 	    var r = pair[1].part.value;
-	    err.properties = {
+	    /*
+	   * This error happens if you create a table and misplace tags inside the table :
+	   *
+	   * ```docx-md
+	   * | Head1    | Head2         |
+	   * | -------- | ------------  |
+	   * | {#a}X    | {/a}{#b}Y{/b} |
+	   * ```
+	   *
+	   *  In the case above, the {#a} and {/a} will expand to the whole loop, but this is not possible because of the other loop in {#b}Y{/b}
+	   *
+	   *  Instead, you should usually write :
+	   *
+	   * ```docx-md
+	   * | Head1    | Head2         |
+	   * | -------- | ------------  |
+	   * | {#a}X    | {#b}Y{/b}{/a} |
+	   * ```
+	   */ err.properties = {
 	        id: "unbalanced_loop_tags",
 	        explanation: "Unbalanced loop tags {#".concat(lastL, "}{/").concat(lastR, "}{#").concat(l, "}{/").concat(r, "}"),
 	        offset: [
@@ -7810,7 +8465,17 @@ function requireErrors () {
 	function getClosingTagNotMatchOpeningTag(_ref3) {
 	    var tags = _ref3.tags;
 	    var err = new XTTemplateError("Closing tag does not match opening tag");
-	    err.properties = {
+	    /*
+	   * This error happens if your loop tags are incorrectly closed
+	   *
+	   * ```docx
+	   * {#condition1}
+	   * Some text
+	   * {/otherCondition}
+	   * ```
+	   *
+	   * Since the start tag does not match the open tag, the template is invalid.
+	   */ err.properties = {
 	        id: "closing_tag_does_not_match_opening_tag",
 	        explanation: "The tag \"".concat(tags[0].value, "\" is closed by the tag \"").concat(tags[1].value, "\""),
 	        openingtag: first(tags).value,
@@ -7828,10 +8493,53 @@ function requireErrors () {
 	    }
 	    return err;
 	}
-	function getScopeCompilationError(_ref4) {
-	    var tag = _ref4.tag, rootError = _ref4.rootError, offset = _ref4.offset;
+	function getLoopPositionProducesInvalidXMLError(_ref4) {
+	    var tag = _ref4.tag, offset = _ref4.offset;
+	    var err = new XTTemplateError("The position of the loop tags \"".concat(tag, "\" would produce invalid XML"));
+	    /*
+	   * This happens when a loop would produce invalid XML.
+	   *
+	   * For example, if you write:
+	   *
+	   * ```docx-md
+	   * | Head1    | Head2         |
+	   * | -------- | ------------  |
+	   * | {#users} | content       |
+	   *
+	   * {/users}
+	   * ```
+	   *
+	   * this is not allowed since a loop that starts in a table must also end
+	   * in that table.
+	   */ err.properties = {
+	        xtag: tag,
+	        id: "loop_position_invalid",
+	        explanation: "The tags \"".concat(tag, "\" are misplaced in the document, for example one of them is in a table and the other one outside the table"),
+	        offset: offset
+	    };
+	    return err;
+	}
+	/*
+	 * Scope Parser Errors
+	 * ===================
+	 */ function getScopeCompilationError(_ref5) {
+	    var tag = _ref5.tag, rootError = _ref5.rootError, offset = _ref5.offset;
 	    var err = new XTScopeParserError("Scope parser compilation failed");
-	    err.properties = {
+	    /*
+	   * This happens when your parser throws an error during compilation. The
+	   * parser is the second argument of the constructor
+	   * `new Docxtemplater(zip, {parser: function parser(tag) {}});`
+	   *
+	   * For example, if your template is:
+	   *
+	   * ```docx
+	   * {name++}
+	   * ```
+	   *
+	   * and you use the angular expression parser, you will have this error. The error
+	   * happens when you call parser('name++'); The underlying error can be
+	   * read in `e.properties.rootError`
+	   */ err.properties = {
 	        id: "scopeparser_compilation_failed",
 	        offset: offset,
 	        xtag: tag,
@@ -7840,12 +8548,47 @@ function requireErrors () {
 	    };
 	    return err;
 	}
-	function getScopeParserExecutionError(_ref5) {
-	    var tag = _ref5.tag, scope = _ref5.scope, error = _ref5.error, offset = _ref5.offset;
+	function getScopeParserExecutionError(_ref6) {
+	    var tag = _ref6.tag, scope = _ref6.scope, error = _ref6.error, offset = _ref6.offset;
 	    var err = new XTScopeParserError("Scope parser execution failed");
-	    err.properties = {
+	    /*
+	   * This happens when your parser throws an error during execution. The
+	   * parser is the second argument of the constructor
+	   * `new Docxtemplater(zip, {parser: function parser(tag) {}});`
+	   *
+	   * For example, if your template is:
+	   *
+	   * ```docx
+	   * {test | toFixed}
+	   * ```
+	   *
+	   * and your code is :
+	   *
+	   * ```js
+	   * const expressionParser = require("docxtemplater/expressions.js");
+	   * const doc = new Docxtemplater(zip, {
+	   *   paragraphLoop: true,
+	   *   linebreaks: true,
+	   *   parser: expressionParser.configure({
+	   *     filters: {
+	   *       toFixed(input) {
+	   *         return input.toFixed();
+	   *       }
+	   *     }
+	   *   }),
+	   * });
+	   * doc.render({
+	   *   test: false
+	   * });
+	   * ```
+	   *
+	   * Since false.toFixed() triggers an error in Javascript, this will then throw an error "Scope parser execution failed".
+	   *
+	   * You can either fix your data or make your toFixed function more robust
+	   * by returning "input" if the input is not a number.
+	   */ err.properties = {
 	        id: "scopeparser_execution_failed",
-	        explanation: "The scope parser for the tag ".concat(tag, " failed to execute"),
+	        explanation: "The scope parser for the tag \"".concat(tag, "\" failed to execute"),
 	        scope: scope,
 	        offset: offset,
 	        xtag: tag,
@@ -7853,24 +8596,20 @@ function requireErrors () {
 	    };
 	    return err;
 	}
-	function getLoopPositionProducesInvalidXMLError(_ref6) {
-	    var tag = _ref6.tag, offset = _ref6.offset;
-	    var err = new XTTemplateError("The position of the loop tags \"".concat(tag, "\" would produce invalid XML"));
-	    err.properties = {
-	        xtag: tag,
-	        id: "loop_position_invalid",
-	        explanation: "The tags \"".concat(tag, "\" are misplaced in the document, for example one of them is in a table and the other one outside the table"),
-	        offset: offset
-	    };
-	    return err;
-	}
-	function throwUnimplementedTagType(part, index) {
+	/*
+	 * Internal / API Misuse Errors
+	 * ============================
+	 */ function throwUnimplementedTagType(part, index) {
 	    var errorMsg = "Unimplemented tag type \"".concat(part.type, "\"");
 	    if (part.module) {
 	        errorMsg += " \"".concat(part.module, "\"");
 	    }
 	    var err = new XTTemplateError(errorMsg);
-	    err.properties = {
+	    /*
+	   * This happens when a tag type is not implemented. It should normally not happen,
+	   * unless you changed docxtemplater code or created your own module and didn't
+	   * implement the `render` function of your module correctly.
+	   */ err.properties = {
 	        part: part,
 	        index: index,
 	        id: "unimplemented_tag_type"
@@ -7879,7 +8618,10 @@ function requireErrors () {
 	}
 	function throwMalformedXml() {
 	    var err = new XTInternalError("Malformed xml");
-	    err.properties = {
+	    /*
+	   * This happens when an xml file of the document cannot be parsed
+	   * correctly.
+	   */ err.properties = {
 	        explanation: "The template contains malformed xml",
 	        id: "malformed_xml"
 	    };
@@ -7887,7 +8629,13 @@ function requireErrors () {
 	}
 	function throwResolveBeforeCompile() {
 	    var err = new XTInternalError("You must run `.compile()` before running `.resolveData()`");
-	    err.properties = {
+	    /*
+	   * This happens if you're calling `resolveData()` before you run `.compile()`.
+	   *
+	   * You should always call `compile` first and then only `resolveData`
+	   *
+	   * Or you can migrate to [the constructor with two arguments](/docs/get-started-node/#usage)
+	   */ err.properties = {
 	        id: "resolve_before_compile",
 	        explanation: "You must run `.compile()` before running `.resolveData()`"
 	    };
@@ -7895,7 +8643,9 @@ function requireErrors () {
 	}
 	function throwRenderInvalidTemplate() {
 	    var err = new XTInternalError("You should not call .render on a document that had compilation errors");
-	    err.properties = {
+	    /*
+	   * This happens if you're calling `render()` on a document that had template errors
+	   */ err.properties = {
 	        id: "render_on_invalid_template",
 	        explanation: "You should not call .render on a document that had compilation errors"
 	    };
@@ -7903,30 +8653,25 @@ function requireErrors () {
 	}
 	function throwRenderTwice() {
 	    var err = new XTInternalError("You should not call .render twice on the same docxtemplater instance");
-	    err.properties = {
+	    /*
+	   * This happens if you're calling `render()` on a document twice.
+	   *
+	   * You should always create a new docxtemplater instance if you need to create two output documents.
+	   */ err.properties = {
 	        id: "render_twice",
 	        explanation: "You should not call .render twice on the same docxtemplater instance"
 	    };
 	    throw err;
 	}
-	function throwFileTypeNotIdentified(zip) {
-	    var files = Object.keys(zip.files).slice(0, 10);
-	    var msg = "";
-	    if (files.length === 0) {
-	        msg = "Empty zip file";
-	    } else {
-	        msg = "Zip file contains : ".concat(files.join(","));
-	    }
-	    var err = new XTInternalError("The filetype for this file could not be identified, is this file corrupted ? ".concat(msg));
-	    err.properties = {
-	        id: "filetype_not_identified",
-	        explanation: "The filetype for this file could not be identified, is this file corrupted ? ".concat(msg)
-	    };
-	    throw err;
-	}
 	function throwXmlInvalid(content, offset) {
 	    var err = new XTTemplateError("An XML file has invalid xml");
-	    err.properties = {
+	    /*
+	   * This error happens if the XML is invalid in your template file.
+	   *
+	   * This should be very rare except if you were using a tool to preprocess
+	   * the template (an XML error in a docx file means that the template file
+	   * is already corrupt).
+	   */ err.properties = {
 	        id: "file_has_invalid_xml",
 	        content: content,
 	        offset: offset,
@@ -7934,15 +8679,6 @@ function requireErrors () {
 	    };
 	    throw err;
 	}
-	function throwFileTypeNotHandled(fileType) {
-	    var err = new XTInternalError("The filetype \"".concat(fileType, "\" is not handled by docxtemplater"));
-	    err.properties = {
-	        id: "filetype_not_handled",
-	        explanation: "The file you are trying to generate is of type \"".concat(fileType, "\", but only docx and pptx formats are handled"),
-	        fileType: fileType
-	    };
-	    throw err;
-	}
 	errors = {
 	    XTError: XTError,
 	    XTTemplateError: XTTemplateError,
@@ -8046,6 +8782,14 @@ function parser(tag) {
         }
     };
 }
+function defaultWarnFn(errors) {
+    for(var _i2 = 0; _i2 < errors.length; _i2++){
+        var error = errors[_i2];
+        if (error.message) {
+            /* eslint-disable-next-line no-console */ console.warn("Warning : " + error.message);
+        }
+    }
+}
 var attrToRegex = {};
 function setSingleAttribute(partValue, attr, attrValue) {
     var regex;
@@ -8107,8 +8851,8 @@ function chunkBy(parsed, f) {
     var chunks = [
         []
     ];
-    for(var _i2 = 0; _i2 < parsed.length; _i2++){
-        var p = parsed[_i2];
+    for(var _i4 = 0; _i4 < parsed.length; _i4++){
+        var p = parsed[_i4];
         var currentChunk = chunks[chunks.length - 1];
         var res = f(p);
         if (res === "start") {
@@ -8123,8 +8867,8 @@ function chunkBy(parsed, f) {
         }
     } // Remove empty chunks
     var result = [];
-    for(var _i4 = 0; _i4 < chunks.length; _i4++){
-        var chunk = chunks[_i4];
+    for(var _i6 = 0; _i6 < chunks.length; _i6++){
+        var chunk = chunks[_i6];
         if (chunk.length > 0) {
             result.push(chunk);
         }
@@ -8143,6 +8887,7 @@ function getDefaults() {
             "[Content_Types].xml"
         ],
         parser: parser,
+        warnFn: defaultWarnFn,
         linebreaks: false,
         fileTypeConfig: null,
         delimiters: {
@@ -8150,7 +8895,11 @@ function getDefaults() {
             end: "}"
         },
         syntax: {
-            changeDelimiterPrefix: "="
+            changeDelimiterPrefix: "=",
+            preserveNewlinesInTags: false,
+            allowUnopenedTag: false,
+            allowUnclosedTag: false,
+            allowUnbalancedLoops: false
         }
     };
 }
@@ -8220,10 +8969,10 @@ function utf8ToWord(string) {
 // This function is written with for loops for performance
 function concatArrays(arrays) {
     var result = [];
-    for(var _i6 = 0; _i6 < arrays.length; _i6++){
-        var array = arrays[_i6];
-        for(var _i8 = 0; _i8 < array.length; _i8++){
-            var el = array[_i8];
+    for(var _i8 = 0; _i8 < arrays.length; _i8++){
+        var array = arrays[_i8];
+        for(var _i0 = 0; _i0 < array.length; _i0++){
+            var el = array[_i0];
             result.push(el);
         }
     }
@@ -8298,8 +9047,8 @@ function getRightOrNull(parsed, elements, index) {
     var level = 1;
     for(var i = index, l = parsed.length; i < l; i++){
         var part = parsed[i];
-        for(var _i0 = 0, _elements2 = elements; _i0 < _elements2.length; _i0++){
-            var element = _elements2[_i0];
+        for(var _i10 = 0, _elements2 = elements; _i10 < _elements2.length; _i10++){
+            var element = _elements2[_i10];
             if (isEnding(part.value, element)) {
                 level--;
             }
@@ -8334,8 +9083,8 @@ function getLeftOrNull(parsed, elements, index) {
     var level = 1;
     for(var i = index; i >= 0; i--){
         var part = parsed[i];
-        for(var _i10 = 0, _elements4 = elements; _i10 < _elements4.length; _i10++){
-            var element = _elements4[_i10];
+        for(var _i12 = 0, _elements4 = elements; _i12 < _elements4.length; _i12++){
+            var element = _elements4[_i12];
             if (isStarting(part.value, element)) {
                 level--;
             }
@@ -8377,20 +9126,27 @@ function isParagraphEnd(_ref6) {
         "text:p"
     ].indexOf(tag) !== -1 && type === "tag" && position === "end";
 }
-function isTextStart(_ref7) {
-    var type = _ref7.type, position = _ref7.position, text = _ref7.text;
-    return text && type === "tag" && position === "start";
+function isBreakTag(_ref7) {
+    var type = _ref7.type, tag = _ref7.tag, position = _ref7.position;
+    return [
+        "w:br",
+        "a:br"
+    ].indexOf(tag) !== -1 && type === "tag" && (position === "start" || position === "selfclosing");
 }
-function isTextEnd(_ref8) {
+function isTextStart(_ref8) {
     var type = _ref8.type, position = _ref8.position, text = _ref8.text;
+    return text && type === "tag" && position === "start";
+}
+function isTextEnd(_ref9) {
+    var type = _ref9.type, position = _ref9.position, text = _ref9.text;
     return text && type === "tag" && position === "end";
 }
-function isContent(_ref9) {
-    var type = _ref9.type, position = _ref9.position;
+function isContent(_ref0) {
+    var type = _ref0.type, position = _ref0.position;
     return type === "placeholder" || type === "content" && position === "insidetag";
 }
-function isModule(_ref0, modules) {
-    var _$module = _ref0.module, type = _ref0.type;
+function isModule(_ref1, modules) {
+    var _$module = _ref1.module, type = _ref1.type;
     if (!_instanceof$2(modules, Array)) {
         modules = [
             modules
@@ -8454,26 +9210,35 @@ function invertMap(map) {
  * is not stable in firefox, as the JS spec does not enforce the sort to be
  * stable.
  */ function stableSort(arr, compare) {
-    // Stryker disable all : in previous versions of Chrome, sort was not stable by itself, so we had to add this. This is to support older versions of JS runners.
-    return arr.map(function(item, index) {
-        return {
-            item: item,
-            index: index
-        };
-    }).sort(function(a, b) {
+    // Stryker disable all
+    var withIndex = [];
+    for(var i = 0; i < arr.length; i++){
+        withIndex.push({
+            item: arr[i],
+            index: i
+        });
+    }
+    withIndex.sort(function(a, b) {
         return compare(a.item, b.item) || a.index - b.index;
-    }).map(function(_ref1) {
-        var item = _ref1.item;
-        return item;
     });
+    var result = [];
+    for(var _i13 = 0; _i13 < withIndex.length; _i13++){
+        result.push(withIndex[_i13].item);
+    }
+    return result;
 // Stryker restore all
 }
+function getPartWithDelimiters(part, options) {
+    return options.delimiters.start + part.raw + options.delimiters.end;
+}
 var docUtils = {
+    getPartWithDelimiters: getPartWithDelimiters,
     endsWith: endsWith,
     startsWith: startsWith,
     isContent: isContent,
     isParagraphStart: isParagraphStart,
     isParagraphEnd: isParagraphEnd,
+    isBreakTag: isBreakTag,
     isTagStart: isTagStart,
     isTagEnd: isTagEnd,
     isTextStart: isTextStart,
@@ -8915,20 +9680,18 @@ function requireGetContentTypes () {
 	        var partName = override.getAttribute("PartName").substr(1);
 	        partNames[partName] = contentType;
 	    }
-	    var _loop = function _loop() {
-	        var def = defaults[_i4];
-	        var contentType = def.getAttribute("ContentType");
-	        var extension = def.getAttribute("Extension");
-	        zip.file(/./).map(function(_ref) {
-	            var name = _ref.name;
+	    zip.file(/./).map(function(_ref) {
+	        var name = _ref.name;
+	        for(var _i4 = 0; _i4 < defaults.length; _i4++){
+	            var def = defaults[_i4];
+	            var _contentType = def.getAttribute("ContentType");
+	            var extension = def.getAttribute("Extension");
 	            if (name.slice(name.length - extension.length) === extension && !partNames[name] && name !== ctXML) {
-	                partNames[name] = contentType;
+	                partNames[name] = _contentType;
 	            }
-	        });
-	    };
-	    for(var _i4 = 0; _i4 < defaults.length; _i4++){
-	        _loop();
-	    }
+	        }
+	        partNames[name] || (partNames[name] = "");
+	    });
 	    return partNames;
 	}
 	function getContentTypes(zip) {
@@ -8963,24 +9726,24 @@ function requireModuleWrapper () {
 	}
 	moduleWrapper = function(module1) {
 	    var defaults = {
+	        on: emptyFun,
 	        set: emptyFun,
+	        getFileType: emptyFun,
+	        optionsTransformer: identity,
+	        preparse: identity,
 	        matchers: function matchers() {
 	            return [];
 	        },
 	        parse: emptyFun,
-	        render: emptyFun,
 	        getTraits: emptyFun,
-	        getFileType: emptyFun,
-	        nullGetter: emptyFun,
-	        optionsTransformer: identity,
-	        postrender: identity,
-	        errorsTransformer: identity,
-	        getRenderedMap: identity,
-	        preparse: identity,
 	        postparse: identity,
-	        on: emptyFun,
+	        errorsTransformer: identity,
+	        preResolve: emptyFun,
 	        resolve: emptyFun,
-	        preResolve: emptyFun
+	        getRenderedMap: identity,
+	        render: emptyFun,
+	        nullGetter: emptyFun,
+	        postrender: identity
 	    };
 	    if (Object.keys(defaults).every(function(key) {
 	        return !module1[key];
@@ -9244,25 +10007,7 @@ function requireTraits () {
 	    return false;
 	}
 	function getExpandToDefault(postparsed, pair, expandTags) {
-	    var parts = postparsed.slice(pair[0].offset, pair[1].offset);
-	    var xmlElements = getListXmlElements(parts);
-	    var closingTagCount = xmlElements.filter(function(tag) {
-	        return tag[1] === "/";
-	    }).length;
-	    var startingTagCount = xmlElements.filter(function(tag) {
-	        return tag[1] !== "/" && tag[tag.length - 2] !== "/";
-	    }).length;
-	    if (closingTagCount !== startingTagCount) {
-	        return {
-	            error: getLoopPositionProducesInvalidXMLError({
-	                tag: first(pair).part.value,
-	                offset: [
-	                    first(pair).part.offset,
-	                    last(pair).part.offset
-	                ]
-	            })
-	        };
-	    }
+	    var xmlElements = getListXmlElements(postparsed.slice(pair[0].offset, pair[1].offset));
 	    var _loop = function _loop() {
 	        var _expandTags$_i = expandTags[_i6], contains = _expandTags$_i.contains, expand = _expandTags$_i.expand, onlyTextInTag = _expandTags$_i.onlyTextInTag;
 	        if (has(contains, xmlElements)) {
@@ -9272,7 +10017,8 @@ function requireTraits () {
 	                if (left === null || right === null) {
 	                    return 0; // continue
 	                }
-	                var chunks = chunkBy(postparsed.slice(left, right), function(p) {
+	                var subparsed = postparsed.slice(left, right);
+	                var chunks = chunkBy(subparsed, function(p) {
 	                    return isTagStart(contains, p) ? "start" : isTagEnd(contains, p) ? "end" : null;
 	                });
 	                var firstChunk = first(chunks);
@@ -9283,6 +10029,33 @@ function requireTraits () {
 	                    return 0; // continue
 	                }
 	            }
+	            var structured = getStructuredTagPositions(xmlElements);
+	            var openCount = 0;
+	            for(var _i8 = 0; _i8 < structured.length; _i8++){
+	                var _structured$_i = structured[_i8], tag = _structured$_i.tag, position = _structured$_i.position;
+	                if (tag === expand) {
+	                    if (position === "start") {
+	                        openCount++;
+	                    }
+	                    if (position === "end") {
+	                        openCount--;
+	                    }
+	                }
+	            }
+	            if (openCount !== 0) {
+	                // Tested by #regression-loop-with-field-and-nofield
+	                return {
+	                    v: {
+	                        error: getLoopPositionProducesInvalidXMLError({
+	                            tag: first(pair).part.value,
+	                            offset: [
+	                                first(pair).part.offset,
+	                                last(pair).part.offset
+	                            ]
+	                        })
+	                    }
+	                };
+	            }
 	            return {
 	                v: {
 	                    value: expand
@@ -9295,8 +10068,50 @@ function requireTraits () {
 	        if (_ret === 0) continue;
 	        if (_ret) return _ret.v;
 	    }
+	    if (!checkStartEnd(xmlElements)) {
+	        return {
+	            error: getLoopPositionProducesInvalidXMLError({
+	                tag: first(pair).part.value,
+	                offset: [
+	                    first(pair).part.offset,
+	                    last(pair).part.offset
+	                ]
+	            })
+	        };
+	    }
 	    return {};
 	}
+	function getStructuredTagPositions(xmlElements) {
+	    var result = [];
+	    for(var _i0 = 0; _i0 < xmlElements.length; _i0++){
+	        var el = xmlElements[_i0];
+	        var tag = getTagName(el);
+	        var position = /^\s*<\//.test(el) ? "end" : "start";
+	        result.push({
+	            tag: tag,
+	            position: position
+	        });
+	    }
+	    return result;
+	}
+	function getTagName(tag) {
+	    return tag.replace(/^\s*<\/?([a-zA-Z:]+).*/, "$1");
+	}
+	function checkStartEnd(xmlElements) {
+	    if (xmlElements.length % 2 === 1) {
+	        return false;
+	    }
+	    for(var i = 0, len = xmlElements.length / 2; i < len; i++){
+	        var start = xmlElements[i];
+	        var end = xmlElements[xmlElements.length - i - 1];
+	        var tagNameStart = getTagName(start);
+	        var tagNameEnd = getTagName(end);
+	        if (tagNameStart !== tagNameEnd) {
+	            return false;
+	        }
+	    }
+	    return true;
+	}
 	function getExpandLimit(part, index, postparsed, options) {
 	    var expandTo = part.expandTo || options.expandTo;
 	    // Stryker disable all : because this condition can be removed in v4 (the only usage was the image module before version 3.12.3 of the image module
@@ -9400,10 +10215,10 @@ function requireTraits () {
 	    });
 	    var maxRight = -1;
 	    var offset = 0;
-	    for(var _i7 = 0, _len = limits.length; _i7 < _len; _i7++){
+	    for(var _i1 = 0, _len = limits.length; _i1 < _len; _i1++){
 	        var _postparsed;
-	        var _limit2 = limits[_i7];
-	        maxRight = Math.max(maxRight, _i7 > 0 ? limits[_i7 - 1].right : 0);
+	        var _limit2 = limits[_i1];
+	        maxRight = Math.max(maxRight, _i1 > 0 ? limits[_i1 - 1].right : 0);
 	        if (_limit2.left < maxRight) {
 	            continue;
 	        }
@@ -9643,7 +10458,7 @@ function requireCommon () {
 	                        }
 	                    }
 	                    if (ftCandidate) {
-	                        return ftCandidate;
+	                        continue;
 	                    }
 	                }
 	                return ftCandidate;
@@ -9723,6 +10538,7 @@ function requireScopeManager () {
 	function _getValue(tag, meta, num) {
 	    var _this = this;
 	    var scope = this.scopeList[num];
+	    var lastScope = this.scopeList[this.scopeList.length - 1];
 	    if (this.root.finishedResolving) {
 	        var w = this.resolved;
 	        var _loop = function _loop() {
@@ -9768,11 +10584,24 @@ function requireScopeManager () {
 	    if (result == null && num > 0) {
 	        return _getValue.call(this, tag, meta, num - 1);
 	    }
+	    if (typeof result === "function") {
+	        try {
+	            result = result(lastScope, this);
+	        } catch (error) {
+	            throw getScopeParserExecutionError({
+	                tag: tag,
+	                scope: scope,
+	                error: error,
+	                offset: meta.part.offset
+	            });
+	        }
+	    }
 	    return result;
 	}
 	function _getValueAsync(tag, meta, num) {
 	    var _this2 = this;
 	    var scope = this.scopeList[num];
+	    var lastScope = this.scopeList[this.scopeList.length - 1];
 	    // search in the scopes (in reverse order) and keep the first defined value
 	    var parser;
 	    if (!this.cachedParsers || !meta.part) {
@@ -9802,6 +10631,20 @@ function requireScopeManager () {
 	            return _getValueAsync.call(_this2, tag, meta, num - 1);
 	        }
 	        return result;
+	    }).then(function(result) {
+	        if (typeof result === "function") {
+	            try {
+	                result = result(lastScope, _this2);
+	            } catch (error) {
+	                throw getScopeParserExecutionError({
+	                    tag: tag,
+	                    scope: scope,
+	                    error: error,
+	                    offset: meta.part.offset
+	                });
+	            }
+	        }
+	        return result;
 	    });
 	}
 	var ScopeManager = /*#__PURE__*/ function() {
@@ -9871,22 +10714,13 @@ function requireScopeManager () {
 	            key: "getValue",
 	            value: function getValue(tag, meta) {
 	                var result = _getValue.call(this, tag, meta, this.scopeList.length - 1);
-	                if (typeof result === "function") {
-	                    return result(this.scopeList[this.scopeList.length - 1], this);
-	                }
 	                return result;
 	            }
 	        },
 	        {
 	            key: "getValueAsync",
 	            value: function getValueAsync(tag, meta) {
-	                var _this3 = this;
-	                return _getValueAsync.call(this, tag, meta, this.scopeList.length - 1).then(function(result) {
-	                    if (typeof result === "function") {
-	                        return result(_this3.scopeList[_this3.scopeList.length - 1], _this3);
-	                    }
-	                    return result;
-	                });
+	                return _getValueAsync.call(this, tag, meta, this.scopeList.length - 1);
 	            }
 	        },
 	        {
@@ -10185,11 +11019,6 @@ function requireLexer () {
 	                    xtag: wordToUtf8(xtag),
 	                    offset: lastDelimiterOffset
 	                }));
-	                lastDelimiterMatch = currDelimiterMatch;
-	                delimiterAcc.push(_objectSpread(_objectSpread({}, currDelimiterMatch), {}, {
-	                    error: true
-	                }));
-	                return delimiterAcc;
 	            }
 	            delimiterAcc.pop();
 	        }
@@ -10232,9 +11061,8 @@ function requireLexer () {
 	                xtag: wordToUtf8(xtag),
 	                offset: lastDelimiterOffset
 	            }));
-	        } else {
-	            delimiterWithErrors.pop();
 	        }
+	        delimiterWithErrors.pop();
 	    }
 	    return {
 	        delimiterWithErrors: delimiterWithErrors,
@@ -10353,28 +11181,35 @@ function requireLexer () {
 	    }
 	}
 	function parseDelimiters(innerContentParts, delimiters, syntaxOptions) {
-	    var full = innerContentParts.map(function(p) {
-	        return p.value;
-	    }).join("");
+	    var full = "";
+	    for(var _i6 = 0; _i6 < innerContentParts.length; _i6++){
+	        var p = innerContentParts[_i6];
+	        full += p.value;
+	    }
 	    var delimiterMatches = getAllDelimiterIndexes(full, delimiters, syntaxOptions);
 	    var offset = 0;
-	    var ranges = innerContentParts.map(function(part) {
+	    var ranges = [];
+	    for(var _i8 = 0; _i8 < innerContentParts.length; _i8++){
+	        var part = innerContentParts[_i8];
 	        offset += part.value.length;
-	        return {
+	        ranges.push({
 	            offset: offset - part.value.length,
 	            lIndex: part.lIndex
-	        };
-	    });
+	        });
+	    }
 	    var _getDelimiterErrors = getDelimiterErrors(delimiterMatches, full, syntaxOptions), delimiterWithErrors = _getDelimiterErrors.delimiterWithErrors, errors = _getDelimiterErrors.errors;
 	    var cutNext = 0;
 	    var delimiterIndex = 0;
-	    var parsed = ranges.map(function(p, i) {
-	        var offset = p.offset;
+	    var parsed = [];
+	    for(var i = 0; i < ranges.length; i++){
+	        var _p = ranges[i];
+	        var innerContentPart = innerContentParts[i];
+	        var _offset = _p.offset;
 	        var range = [
-	            offset,
-	            offset + innerContentParts[i].value.length
+	            _offset,
+	            _offset + innerContentPart.value.length
 	        ];
-	        var partContent = innerContentParts[i].value;
+	        var partContent = innerContentPart.value;
 	        var delimitersInOffset = [];
 	        while(delimiterIndex < delimiterWithErrors.length && inRange(range, delimiterWithErrors[delimiterIndex])){
 	            delimitersInOffset.push(delimiterWithErrors[delimiterIndex]);
@@ -10386,9 +11221,9 @@ function requireLexer () {
 	            cursor = cutNext;
 	            cutNext = 0;
 	        }
-	        for(var _i6 = 0; _i6 < delimitersInOffset.length; _i6++){
-	            var delimiterInOffset = delimitersInOffset[_i6];
-	            var _value = partContent.substr(cursor, delimiterInOffset.offset - offset - cursor);
+	        for(var _i0 = 0; _i0 < delimitersInOffset.length; _i0++){
+	            var delimiterInOffset = delimitersInOffset[_i0];
+	            var _value = partContent.substr(cursor, delimiterInOffset.offset - _offset - cursor);
 	            if (delimiterInOffset.changedelimiter) {
 	                if (delimiterInOffset.position === "start") {
 	                    if (_value.length > 0) {
@@ -10398,7 +11233,7 @@ function requireLexer () {
 	                        });
 	                    }
 	                } else {
-	                    cursor = delimiterInOffset.offset - offset + delimiterInOffset.length;
+	                    cursor = delimiterInOffset.offset - _offset + delimiterInOffset.length;
 	                }
 	                continue;
 	            }
@@ -10412,10 +11247,10 @@ function requireLexer () {
 	            var delimiterPart = {
 	                type: "delimiter",
 	                position: delimiterInOffset.position,
-	                offset: cursor + offset
+	                offset: cursor + _offset
 	            };
 	            parts.push(delimiterPart);
-	            cursor = delimiterInOffset.offset - offset + delimiterInOffset.length;
+	            cursor = delimiterInOffset.offset - _offset + delimiterInOffset.length;
 	        }
 	        cutNext = cursor - partContent.length;
 	        var value = partContent.substr(cursor);
@@ -10425,8 +11260,8 @@ function requireLexer () {
 	                value: value
 	            });
 	        }
-	        return parts;
-	    }, this);
+	        parsed.push(parts);
+	    }
 	    return {
 	        parsed: parsed,
 	        errors: errors
@@ -10442,8 +11277,8 @@ function requireLexer () {
 	}
 	function decodeContentParts(xmlparsed, fileType) {
 	    var inTextTag = false;
-	    for(var _i8 = 0; _i8 < xmlparsed.length; _i8++){
-	        var part = xmlparsed[_i8];
+	    for(var _i10 = 0; _i10 < xmlparsed.length; _i10++){
+	        var part = xmlparsed[_i10];
 	        inTextTag = updateInTextTag(part, inTextTag);
 	        if (part.type === "content") {
 	            part.position = inTextTag ? "insidetag" : "outsidetag";
@@ -10461,11 +11296,11 @@ function requireLexer () {
 	        var lexed = [];
 	        var index = 0;
 	        var lIndex = 0;
-	        for(var _i0 = 0; _i0 < xmllexed.length; _i0++){
-	            var part = xmllexed[_i0];
+	        for(var _i12 = 0; _i12 < xmllexed.length; _i12++){
+	            var part = xmllexed[_i12];
 	            if (isInsideContent(part)) {
-	                for(var _i10 = 0, _delimiterParsed$inde2 = delimiterParsed[index]; _i10 < _delimiterParsed$inde2.length; _i10++){
-	                    var p = _delimiterParsed$inde2[_i10];
+	                for(var _i14 = 0, _delimiterParsed$inde2 = delimiterParsed[index]; _i14 < _delimiterParsed$inde2.length; _i14++){
+	                    var p = _delimiterParsed$inde2[_i14];
 	                    if (p.type === "content") {
 	                        p.position = "insidetag";
 	                    }
@@ -10487,8 +11322,8 @@ function requireLexer () {
 	        var matches = tagMatcher(content, xmltags.text, xmltags.other);
 	        var cursor = 0;
 	        var parsed = [];
-	        for(var _i12 = 0; _i12 < matches.length; _i12++){
-	            var match = matches[_i12];
+	        for(var _i16 = 0; _i16 < matches.length; _i16++){
+	            var match = matches[_i16];
 	            if (content.length > cursor && match.offset - cursor > 0) {
 	                parsed.push({
 	                    type: "content",
@@ -10887,7 +11722,7 @@ function requireParser () {
 	function _arrayWithHoles(r) {
 	    if (Array.isArray(r)) return r;
 	}
-	var _require = docUtils, wordToUtf8 = _require.wordToUtf8, pushArray = _require.pushArray;
+	var _require = docUtils, wordToUtf8 = _require.wordToUtf8, pushArray = _require.pushArray, isParagraphStart = _require.isParagraphStart, isBreakTag = _require.isBreakTag;
 	var _require2 = requirePrefixMatcher(), match = _require2.match, getValue = _require2.getValue, getValues = _require2.getValues;
 	function getMatchers(modules, options) {
 	    var allMatchers = [];
@@ -11022,6 +11857,9 @@ function requireParser () {
 	                return parsed;
 	            }
 	            if (token.type !== "content" || token.position !== "insidetag") {
+	                if (options.syntax.preserveNewlinesInTags && (isBreakTag(token) || isParagraphStart(token))) {
+	                    placeHolderContent += "\n";
+	                }
 	                if (droppedTags.indexOf(token.tag) !== -1) {
 	                    return parsed;
 	                }
@@ -11033,17 +11871,20 @@ function requireParser () {
 	        }, []);
 	    },
 	    postparse: function postparse(postparsed, modules, options) {
-	        function getTraits(traitName, postparsed) {
-	            return modules.map(function(module1) {
-	                return module1.getTraits(traitName, postparsed);
-	            });
+	        function getTraits(traitName, postparsed, options) {
+	            var result = [];
+	            for(var _i10 = 0; _i10 < modules.length; _i10++){
+	                var _module5 = modules[_i10];
+	                result.push(_module5.getTraits(traitName, postparsed, options));
+	            }
+	            return result;
 	        }
 	        var errors = [];
 	        function _postparse(postparsed, options) {
 	            var newPostparsed = postparsed;
-	            for(var _i10 = 0; _i10 < modules.length; _i10++){
-	                var _module5 = modules[_i10];
-	                var postparseResult = _module5.postparse(newPostparsed, _objectSpread(_objectSpread({}, options), {}, {
+	            for(var _i12 = 0; _i12 < modules.length; _i12++){
+	                var _module6 = modules[_i12];
+	                var postparseResult = _module6.postparse(newPostparsed, _objectSpread(_objectSpread({}, options), {}, {
 	                    postparse: function postparse(parsed, opts) {
 	                        return _postparse(parsed, _objectSpread(_objectSpread({}, options), opts));
 	                    },
@@ -11353,58 +12194,99 @@ function requireResolve () {
 	    }
 	    return false;
 	}
+	function resolvePart(part, resolved, errors, options) {
+	    var moduleResolved = moduleResolve(part, _objectSpread(_objectSpread({}, options), {}, {
+	        resolvedId: getResolvedId(part, options)
+	    }));
+	    if (moduleResolved) {
+	        return moduleResolved.then(function(value) {
+	            resolved.push({
+	                tag: part.value,
+	                lIndex: part.lIndex,
+	                value: value
+	            });
+	        })["catch"](function(e) {
+	            if (_instanceof(e, Array)) {
+	                pushArray(errors, e);
+	            } else {
+	                errors.push(e);
+	            }
+	        });
+	    }
+	    if (part.type === "placeholder") {
+	        return options.scopeManager.getValueAsync(part.value, {
+	            part: part
+	        }).then(function(value) {
+	            return value == null ? options.nullGetter(part) : value;
+	        }).then(function(value) {
+	            resolved.push({
+	                tag: part.value,
+	                lIndex: part.lIndex,
+	                value: value
+	            });
+	        })["catch"](function(e) {
+	            if (_instanceof(e, Array)) {
+	                pushArray(errors, e);
+	            } else {
+	                errors.push(e);
+	            }
+	        });
+	    }
+	}
 	function resolve(options) {
 	    var resolved = [];
+	    var errors = [];
 	    var baseNullGetter = options.baseNullGetter;
-	    var compiled = options.compiled, scopeManager = options.scopeManager;
+	    var scopeManager = options.scopeManager;
 	    options.nullGetter = function(part, sm) {
 	        return baseNullGetter(part, sm || scopeManager);
 	    };
 	    options.resolved = resolved;
-	    var errors = [];
-	    return Promise.all(compiled.filter(function(part) {
-	        return [
+	    var p = resolveSerial(options, errors, resolved);
+	    if (p) {
+	        return p.then(function() {
+	            return resolveParallel(options, errors, resolved);
+	        });
+	    }
+	    return resolveParallel(options, errors, resolved);
+	}
+	function resolveSerial(options, errors, resolved) {
+	    var p = null;
+	    var _loop = function _loop() {
+	        var part = _options$compiled2[_i4];
+	        if ([
 	            "content",
 	            "tag"
-	        ].indexOf(part.type) === -1;
-	    }).reduce(function(promises, part) {
-	        var moduleResolved = moduleResolve(part, _objectSpread(_objectSpread({}, options), {}, {
-	            resolvedId: getResolvedId(part, options)
-	        }));
-	        var result;
-	        if (moduleResolved) {
-	            result = moduleResolved.then(function(value) {
-	                resolved.push({
-	                    tag: part.value,
-	                    lIndex: part.lIndex,
-	                    value: value
-	                });
-	            });
-	        } else if (part.type === "placeholder") {
-	            result = scopeManager.getValueAsync(part.value, {
-	                part: part
-	            }).then(function(value) {
-	                return value == null ? options.nullGetter(part) : value;
-	            }).then(function(value) {
-	                resolved.push({
-	                    tag: part.value,
-	                    lIndex: part.lIndex,
-	                    value: value
-	                });
-	                return value;
+	        ].indexOf(part.type) !== -1) {
+	            return 1; // continue
+	        }
+	        if (part.resolveFirst) {
+	            p !== null && p !== void 0 ? p : p = Promise.resolve(null);
+	            p = p.then(function() {
+	                return resolvePart(part, resolved, errors, options);
 	            });
-	        } else {
-	            return;
 	        }
-	        promises.push(result["catch"](function(e) {
-	            if (_instanceof(e, Array)) {
-	                pushArray(errors, e);
-	            } else {
-	                errors.push(e);
-	            }
-	        }));
-	        return promises;
-	    }, [])).then(function() {
+	    };
+	    for(var _i4 = 0, _options$compiled2 = options.compiled; _i4 < _options$compiled2.length; _i4++){
+	        if (_loop()) continue;
+	    }
+	    return p;
+	}
+	function resolveParallel(options, errors, resolved) {
+	    var promises = [];
+	    for(var _i6 = 0, _options$compiled4 = options.compiled; _i6 < _options$compiled4.length; _i6++){
+	        var part = _options$compiled4[_i6];
+	        if ([
+	            "content",
+	            "tag"
+	        ].indexOf(part.type) !== -1) {
+	            continue;
+	        }
+	        if (!part.resolveFirst) {
+	            promises.push(resolvePart(part, resolved, errors, options));
+	        }
+	    }
+	    return Promise.all(promises).then(function() {
 	        return {
 	            errors: errors,
 	            resolved: resolved
@@ -11579,9 +12461,11 @@ function requireXmlTemplater () {
 	var joinUncorrupt = requireJoinUncorrupt();
 	function _getFullText(content, tagsXmlArray) {
 	    var matcher = xmlMatcher(content, tagsXmlArray);
-	    var result = matcher.matches.map(function(match) {
-	        return match.array[2];
-	    });
+	    var result = [];
+	    for(var _i2 = 0, _matcher$matches2 = matcher.matches; _i2 < _matcher$matches2.length; _i2++){
+	        var match = _matcher$matches2[_i2];
+	        result.push(match.array[2]);
+	    }
 	    return wordToUtf8(convertSpaces(result.join("")));
 	}
 	xmlTemplater = /*#__PURE__*/ function() {
@@ -11609,18 +12493,22 @@ function requireXmlTemplater () {
 	                options.scopeManager = this.scopeManager;
 	                options.resolve = resolve;
 	                var errors = [];
-	                return Promise.all(this.modules.map(function(module1) {
-	                    return Promise.resolve(module1.preResolve(options))["catch"](function(e) {
+	                var promises = [];
+	                for(var _i4 = 0, _this$modules2 = this.modules; _i4 < _this$modules2.length; _i4++){
+	                    var _module = _this$modules2[_i4];
+	                    promises.push(Promise.resolve(_module.preResolve(options))["catch"](function(e) {
 	                        errors.push(e);
-	                    });
-	                })).then(function() {
+	                    }));
+	                }
+	                return Promise.all(promises).then(function() {
 	                    if (errors.length !== 0) {
 	                        throw errors;
 	                    }
 	                    return resolve(options).then(function(_ref) {
 	                        var resolved = _ref.resolved, errors = _ref.errors;
-	                        errors = errors.map(function(error) {
+	                        for(var i = 0; i < errors.length; i++){
 	                            var _error;
+	                            var error = errors[i];
 	                            // If a string is thrown, convert it to a real Error
 	                            if (!_instanceof(error, Error)) {
 	                                error = new Error(error);
@@ -11631,8 +12519,8 @@ function requireXmlTemplater () {
 	             * thrown.
 	             */ (_error = error).properties || (_error.properties = {});
 	                            error.properties.file = filePath;
-	                            return error;
-	                        });
+	                            errors[i] = error;
+	                        }
 	                        if (errors.length !== 0) {
 	                            throw errors;
 	                        }
@@ -11663,9 +12551,9 @@ function requireXmlTemplater () {
 	        {
 	            key: "setModules",
 	            value: function setModules(obj) {
-	                for(var _i2 = 0, _this$modules2 = this.modules; _i2 < _this$modules2.length; _i2++){
-	                    var _module = _this$modules2[_i2];
-	                    _module.set(obj);
+	                for(var _i6 = 0, _this$modules4 = this.modules; _i6 < _this$modules4.length; _i6++){
+	                    var _module2 = _this$modules4[_i6];
+	                    _module2.set(obj);
 	                }
 	            }
 	        },
@@ -11740,8 +12628,8 @@ function requireXmlTemplater () {
 	        {
 	            key: "errorChecker",
 	            value: function errorChecker(errors) {
-	                for(var _i4 = 0, _errors2 = errors; _i4 < _errors2.length; _i4++){
-	                    var error = _errors2[_i4];
+	                for(var _i8 = 0, _errors2 = errors; _i8 < _errors2.length; _i8++){
+	                    var error = _errors2[_i8];
 	                    /*
 	         * error properties might not be defined if some foreign
 	         * (unhandled error not thrown by docxtemplater willingly) is
@@ -11749,9 +12637,9 @@ function requireXmlTemplater () {
 	         */ error.properties || (error.properties = {});
 	                    error.properties.file = this.filePath;
 	                }
-	                for(var _i6 = 0, _this$modules4 = this.modules; _i6 < _this$modules4.length; _i6++){
-	                    var _module2 = _this$modules4[_i6];
-	                    errors = _module2.errorsTransformer(errors);
+	                for(var _i0 = 0, _this$modules6 = this.modules; _i0 < _this$modules6.length; _i0++){
+	                    var _module3 = _this$modules6[_i0];
+	                    errors = _module3.errorsTransformer(errors);
 	                }
 	            }
 	        },
@@ -11759,12 +12647,12 @@ function requireXmlTemplater () {
 	            key: "baseNullGetter",
 	            value: function baseNullGetter(part, sm) {
 	                var value = null;
-	                for(var _i8 = 0, _this$modules6 = this.modules; _i8 < _this$modules6.length; _i8++){
-	                    var _module3 = _this$modules6[_i8];
+	                for(var _i10 = 0, _this$modules8 = this.modules; _i10 < _this$modules8.length; _i10++){
+	                    var _module4 = _this$modules8[_i10];
 	                    if (value != null) {
 	                        continue;
 	                    }
-	                    value = _module3.nullGetter(part, sm, this);
+	                    value = _module4.nullGetter(part, sm, this);
 	                }
 	                if (value != null) {
 	                    return value;
@@ -11785,6 +12673,7 @@ function requireXmlTemplater () {
 	                    relsType: this.relsType,
 	                    baseNullGetter: this.baseNullGetter.bind(this),
 	                    filePath: this.filePath,
+	                    syntax: this.syntax,
 	                    fileTypeConfig: this.fileTypeConfig,
 	                    fileType: this.fileType,
 	                    linebreaks: this.linebreaks,
@@ -11942,15 +12831,20 @@ function requireLoop () {
 	var _require = docUtils, chunkBy = _require.chunkBy, last = _require.last, isParagraphStart = _require.isParagraphStart, isModule = _require.isModule, pushArray = _require.pushArray, isParagraphEnd = _require.isParagraphEnd, isContent = _require.isContent, startsWith = _require.startsWith, isTagEnd = _require.isTagEnd, isTagStart = _require.isTagStart, getSingleAttribute = _require.getSingleAttribute, setSingleAttribute = _require.setSingleAttribute;
 	var filetypes = requireFiletypes();
 	var wrapper = requireModuleWrapper();
+	var _require2 = docUtils, isWhiteSpace = _require2.isWhiteSpace;
 	var moduleName = "loop";
 	function hasContent(parts) {
-	    return parts.some(function(part) {
-	        return isContent(part);
-	    });
+	    for(var _i2 = 0; _i2 < parts.length; _i2++){
+	        var part = parts[_i2];
+	        if (isContent(part)) {
+	            return true;
+	        }
+	    }
+	    return false;
 	}
 	function getFirstMeaningFulPart(parsed) {
-	    for(var _i2 = 0; _i2 < parsed.length; _i2++){
-	        var part = parsed[_i2];
+	    for(var _i4 = 0; _i4 < parsed.length; _i4++){
+	        var part = parsed[_i4];
 	        if (part.type !== "content") {
 	            return part;
 	        }
@@ -11982,74 +12876,94 @@ function requireLoop () {
 	    subRendered.parts.unshift('<w:p><w:r><w:br w:type="page"/></w:r></w:p>');
 	}
 	function isContinuous(parts) {
-	    return parts.some(function(part) {
-	        return isTagStart("w:type", part) && part.value.indexOf("continuous") !== -1;
-	    });
+	    for(var _i6 = 0; _i6 < parts.length; _i6++){
+	        var part = parts[_i6];
+	        if (isTagStart("w:type", part) && part.value.indexOf("continuous") !== -1) {
+	            return true;
+	        }
+	    }
+	    return false;
 	}
 	function isNextPage(parts) {
-	    return parts.some(function(part) {
-	        return isTagStart("w:type", part) && part.value.indexOf('w:val="nextPage"') !== -1;
-	    });
+	    for(var _i8 = 0; _i8 < parts.length; _i8++){
+	        var part = parts[_i8];
+	        if (isTagStart("w:type", part) && part.value.indexOf('w:val="nextPage"') !== -1) {
+	            return true;
+	        }
+	    }
+	    return false;
 	}
 	function addSectionBefore(parts, sect) {
-	    return pushArray([
-	        "<w:p><w:pPr>".concat(sect.map(function(_ref) {
-	            var value = _ref.value;
-	            return value;
-	        }).join(""), "</w:pPr></w:p>")
-	    ], parts);
+	    var result = "";
+	    for(var _i0 = 0; _i0 < sect.length; _i0++){
+	        var value = sect[_i0].value;
+	        result += value;
+	    }
+	    parts.unshift("<w:p><w:pPr>".concat(result, "</w:pPr></w:p>"));
 	}
 	function addContinuousType(parts) {
 	    var stop = false;
 	    var inSectPr = false;
-	    var result = [];
-	    for(var _i4 = 0; _i4 < parts.length; _i4++){
-	        var part = parts[_i4];
-	        if (stop === false && startsWith(part, "<w:sectPr")) {
+	    for(var i = 0; i < parts.length; i++){
+	        var part = parts[i];
+	        if (!stop && startsWith(part, "<w:sectPr")) {
 	            inSectPr = true;
 	        }
 	        if (inSectPr) {
 	            if (startsWith(part, "<w:type")) {
 	                stop = true;
 	            }
-	            if (stop === false && startsWith(part, "</w:sectPr")) {
-	                result.push('<w:type w:val="continuous"/>');
+	            if (!stop && startsWith(part, "</w:sectPr")) {
+	                parts.splice(i, 0, '<w:type w:val="continuous"/>');
+	                i++; // Skip re-processing the now-shifted closing tag to avoid infinite insertion
 	            }
 	        }
-	        result.push(part);
 	    }
-	    return result;
+	    return parts;
 	}
 	function dropHeaderFooterRefs(parts) {
-	    return parts.filter(function(text) {
-	        return !startsWith(text, "<w:headerReference") && !startsWith(text, "<w:footerReference");
-	    });
+	    var writeIndex = 0;
+	    for(var readIndex = 0; readIndex < parts.length; readIndex++){
+	        if (!startsWith(parts[readIndex], "<w:headerReference") && !startsWith(parts[readIndex], "<w:footerReference")) {
+	            parts[writeIndex] = parts[readIndex];
+	            writeIndex++;
+	        }
+	    }
+	    parts.length = writeIndex;
+	    return parts;
 	}
 	function hasPageBreak(chunk) {
-	    return chunk.some(function(part) {
-	        return part.tag === "w:br" && part.value.indexOf('w:type="page"') !== -1;
-	    });
+	    for(var _i10 = 0; _i10 < chunk.length; _i10++){
+	        var part = chunk[_i10];
+	        if (part.tag === "w:br" && part.value.indexOf('w:type="page"') !== -1) {
+	            return true;
+	        }
+	    }
+	    return false;
 	}
 	function hasImage(chunk) {
-	    return chunk.some(function(_ref2) {
-	        var tag = _ref2.tag;
-	        return tag === "w:drawing";
-	    });
+	    for(var _i12 = 0; _i12 < chunk.length; _i12++){
+	        var el = chunk[_i12];
+	        if (el.tag === "w:drawing") {
+	            return true;
+	        }
+	    }
+	    return false;
 	}
 	function getSectPr(chunks) {
-	    var collectSectPr = false;
 	    var sectPrs = [];
-	    for(var _i6 = 0; _i6 < chunks.length; _i6++){
-	        var part = chunks[_i6];
+	    var currentSectPr = null;
+	    for(var _i14 = 0; _i14 < chunks.length; _i14++){
+	        var part = chunks[_i14];
 	        if (isTagStart("w:sectPr", part)) {
-	            sectPrs.push([]);
-	            collectSectPr = true;
+	            currentSectPr = [];
+	            sectPrs.push(currentSectPr);
 	        }
-	        if (collectSectPr) {
-	            sectPrs[sectPrs.length - 1].push(part);
+	        if (currentSectPr !== null) {
+	            currentSectPr.push(part);
 	        }
 	        if (isTagEnd("w:sectPr", part)) {
-	            collectSectPr = false;
+	            currentSectPr = null;
 	        }
 	    }
 	    return sectPrs;
@@ -12057,8 +12971,8 @@ function requireLoop () {
 	function getSectPrHeaderFooterChangeCount(chunks) {
 	    var collectSectPr = false;
 	    var sectPrCount = 0;
-	    for(var _i8 = 0; _i8 < chunks.length; _i8++){
-	        var part = chunks[_i8];
+	    for(var _i16 = 0; _i16 < chunks.length; _i16++){
+	        var part = chunks[_i16];
 	        if (isTagStart("w:sectPr", part)) {
 	            collectSectPr = true;
 	        }
@@ -12079,7 +12993,11 @@ function requireLoop () {
 	    var inSectPr = false;
 	    for(var i = parsed.length - 1; i >= 0; i--){
 	        var part = parsed[i];
-	        if (isTagEnd("w:sectPr", part)) {
+	        /*
+	     * Since we try to get the last sectPr, we traverse the parsed array
+	     * from the end to beginning, this is why inSectPr becomes true when we
+	     * we see a </w:sectPr> closing tag
+	     */ if (isTagEnd("w:sectPr", part)) {
 	            inSectPr = true;
 	        }
 	        if (isTagStart("w:sectPr", part)) {
@@ -12121,8 +13039,8 @@ function requireLoop () {
 	        },
 	        {
 	            key: "preparse",
-	            value: function preparse(parsed, _ref3) {
-	                var contentType = _ref3.contentType;
+	            value: function preparse(parsed, _ref) {
+	                var contentType = _ref.contentType;
 	                if (filetypes.main.indexOf(contentType) !== -1) {
 	                    this.sects = getSectPr(parsed);
 	                }
@@ -12161,8 +13079,8 @@ function requireLoop () {
 	                    [
 	                        this.prefix.dash,
 	                        _$module,
-	                        function(_ref4) {
-	                            var _ref5 = _slicedToArray(_ref4, 3), expandTo = _ref5[1], value = _ref5[2];
+	                        function(_ref2) {
+	                            var _ref3 = _slicedToArray(_ref2, 3), expandTo = _ref3[1], value = _ref3[2];
 	                            return {
 	                                location: "start",
 	                                inverted: false,
@@ -12197,18 +13115,19 @@ function requireLoop () {
 	        },
 	        {
 	            key: "postparse",
-	            value: function postparse(parsed, _ref6) {
-	                var basePart = _ref6.basePart;
+	            value: function postparse(parsed, _ref4) {
+	                var basePart = _ref4.basePart;
 	                if (basePart && this.docxtemplater.fileType === "docx" && parsed.length > 0) {
 	                    basePart.sectPrCount = getSectPrHeaderFooterChangeCount(parsed);
 	                    this.totalSectPr += basePart.sectPrCount;
 	                    var sects = this.sects;
-	                    sects.some(function(sect, index) {
+	                    for(var index = 0, len = sects.length; index < len; index++){
+	                        var sect = sects[index];
 	                        if (basePart.lIndex < sect[0].lIndex) {
 	                            if (index + 1 < sects.length && isContinuous(sects[index + 1])) {
 	                                basePart.addContinuousType = true;
 	                            }
-	                            return true;
+	                            break;
 	                        }
 	                        if (parsed[0].lIndex < sect[0].lIndex && sect[0].lIndex < basePart.lIndex) {
 	                            if (isNextPage(sects[index])) {
@@ -12216,9 +13135,9 @@ function requireLoop () {
 	                                    index: index
 	                                };
 	                            }
-	                            return true;
+	                            break;
 	                        }
-	                    });
+	                    }
 	                    basePart.lastParagrapSectPr = getLastSectPr(parsed);
 	                }
 	                if (!basePart || basePart.expandTo !== "auto" || basePart.module !== moduleName || !isEnclosedByParagraphs(parsed)) {
@@ -12245,6 +13164,12 @@ function requireLoop () {
 	                var lastChunk = last(chunks);
 	                var firstOffset = getOffset(firstChunk);
 	                var lastOffset = getOffset(lastChunk);
+	                if (firstOffset > 0 && chunks[1][0].type === "content" && isWhiteSpace(chunks[1][0].value)) {
+	                    firstOffset += 1;
+	                }
+	                if (lastOffset > 0 && last(chunks[chunks.length - 2]).type === "content" && isWhiteSpace(last(chunks[chunks.length - 2]).value)) {
+	                    lastOffset += 1;
+	                }
 	                basePart.hasPageBreakBeginning = hasPageBreak(firstChunk);
 	                basePart.hasPageBreak = hasPageBreak(lastChunk);
 	                if (hasImage(firstChunk)) {
@@ -12259,6 +13184,7 @@ function requireLoop () {
 	        {
 	            key: "resolve",
 	            value: function resolve(part, options) {
+	                var self = this;
 	                if (!isModule(part, moduleName)) {
 	                    return null;
 	                }
@@ -12267,46 +13193,59 @@ function requireLoop () {
 	                    part: part
 	                });
 	                var promises = [];
+	                var lastPromise;
+	                if (self.resolveSerially) {
+	                    lastPromise = Promise.resolve(null);
+	                }
 	                function loopOver(scope, i, length) {
 	                    var scopeManager = sm.createSubScopeManager(scope, part.value, i, part, length);
-	                    promises.push(options.resolve(_objectSpread(_objectSpread({}, options), {}, {
-	                        compiled: part.subparsed,
-	                        tags: {},
-	                        scopeManager: scopeManager
-	                    })));
+	                    if (self.resolveSerially) {
+	                        lastPromise = lastPromise.then(function() {
+	                            return options.resolve(_objectSpread(_objectSpread({}, options), {}, {
+	                                compiled: part.subparsed,
+	                                tags: {},
+	                                scopeManager: scopeManager
+	                            }));
+	                        });
+	                        promises.push(lastPromise);
+	                    } else {
+	                        promises.push(options.resolve(_objectSpread(_objectSpread({}, options), {}, {
+	                            compiled: part.subparsed,
+	                            tags: {},
+	                            scopeManager: scopeManager
+	                        })));
+	                    }
 	                }
 	                var errorList = [];
 	                return promisedValue.then(function(values) {
 	                    values !== null && values !== void 0 ? values : values = options.nullGetter(part);
-	                    return new Promise(function(resolve) {
-	                        if (_instanceof(values, Promise)) {
-	                            return values.then(function(values) {
-	                                if (_instanceof(values, Array)) {
-	                                    Promise.all(values).then(resolve);
-	                                } else {
-	                                    resolve(values);
-	                                }
-	                            });
-	                        }
-	                        if (_instanceof(values, Array)) {
-	                            Promise.all(values).then(resolve);
-	                        } else {
-	                            resolve(values);
-	                        }
-	                    }).then(function(values) {
-	                        sm.loopOverValue(values, loopOver, part.inverted);
-	                        return Promise.all(promises).then(function(r) {
-	                            return r.map(function(_ref7) {
-	                                var resolved = _ref7.resolved, errors = _ref7.errors;
-	                                pushArray(errorList, errors);
-	                                return resolved;
-	                            });
-	                        }).then(function(value) {
-	                            if (errorList.length > 0) {
-	                                throw errorList;
+	                    if (_instanceof(values, Promise)) {
+	                        return values.then(function(values) {
+	                            if (_instanceof(values, Array)) {
+	                                return Promise.all(values);
 	                            }
-	                            return value;
+	                            return values;
 	                        });
+	                    }
+	                    if (_instanceof(values, Array)) {
+	                        return Promise.all(values);
+	                    }
+	                    return values;
+	                }).then(function(values) {
+	                    sm.loopOverValue(values, loopOver, part.inverted);
+	                    return Promise.all(promises).then(function(r) {
+	                        var result = [];
+	                        for(var _i18 = 0; _i18 < r.length; _i18++){
+	                            var _r$_i = r[_i18], resolved = _r$_i.resolved, errors = _r$_i.errors;
+	                            pushArray(errorList, errors);
+	                            result.push(resolved);
+	                        }
+	                        return result;
+	                    }).then(function(value) {
+	                        if (errorList.length > 0) {
+	                            throw errorList;
+	                        }
+	                        return value;
 	                    });
 	                });
 	            }
@@ -12314,11 +13253,12 @@ function requireLoop () {
 	        {
 	            key: "render",
 	            value: function render(part, options) {
+	                var self = this;
 	                if (part.tag === "p:xfrm") {
-	                    this.inXfrm = part.position === "start";
+	                    self.inXfrm = part.position === "start";
 	                }
-	                if (part.tag === "a:ext" && this.inXfrm) {
-	                    this.lastExt = part;
+	                if (part.tag === "a:ext" && self.inXfrm) {
+	                    self.lastExt = part;
 	                    return part;
 	                }
 	                if (!isModule(part, moduleName)) {
@@ -12327,7 +13267,6 @@ function requireLoop () {
 	                var totalValue = [];
 	                var errors = [];
 	                var heightOffset = 0;
-	                var self = this;
 	                var firstTag = part.subparsed[0];
 	                var tagHeight = 0;
 	                if ((firstTag === null || firstTag === void 0 ? void 0 : firstTag.tag) === "a:tr") {
@@ -12339,8 +13278,8 @@ function requireLoop () {
 	                function loopOver(scope, i, length) {
 	                    heightOffset += tagHeight;
 	                    var scopeManager = options.scopeManager.createSubScopeManager(scope, part.value, i, part, length);
-	                    for(var _i0 = 0, _part$subparsed2 = part.subparsed; _i0 < _part$subparsed2.length; _i0++){
-	                        var pp = _part$subparsed2[_i0];
+	                    for(var _i20 = 0, _part$subparsed2 = part.subparsed; _i20 < _part$subparsed2.length; _i20++){
+	                        var pp = _part$subparsed2[_i20];
 	                        if (isTagStart("a16:rowId", pp)) {
 	                            var val = +getSingleAttribute(pp.value, "val") + a16RowIdOffset;
 	                            a16RowIdOffset = 1;
@@ -12366,7 +13305,7 @@ function requireLoop () {
 	                            subRendered.parts = addContinuousType(subRendered.parts);
 	                        }
 	                    } else if (part.addNextPage) {
-	                        subRendered.parts = addSectionBefore(subRendered.parts, self.sects[part.addNextPage.index]);
+	                        addSectionBefore(subRendered.parts, self.sects[part.addNextPage.index]);
 	                    }
 	                    if (part.addNextPage) {
 	                        addPageBreakAtEnd(subRendered);
@@ -12374,8 +13313,8 @@ function requireLoop () {
 	                    if (part.hasPageBreakBeginning && insideParagraphLoop) {
 	                        addPageBreakAtBeginning(subRendered);
 	                    }
-	                    for(var _i10 = 0, _subRendered$parts2 = subRendered.parts; _i10 < _subRendered$parts2.length; _i10++){
-	                        var _val = _subRendered$parts2[_i10];
+	                    for(var _i22 = 0, _subRendered$parts2 = subRendered.parts; _i22 < _subRendered$parts2.length; _i22++){
+	                        var _val = _subRendered$parts2[_i22];
 	                        totalValue.push(_val);
 	                    }
 	                    pushArray(errors, subRendered.errors);
@@ -12403,11 +13342,11 @@ function requireLoop () {
 	                    };
 	                }
 	                if (heightOffset !== 0) {
-	                    var cy = +getSingleAttribute(this.lastExt.value, "cy");
+	                    var cy = +getSingleAttribute(self.lastExt.value, "cy");
 	                    /*
 	         * We do edit the value of a previous result here
 	         * #edit-value-backwards
-	         */ this.lastExt.value = setSingleAttribute(this.lastExt.value, "cy", cy + heightOffset);
+	         */ self.lastExt.value = setSingleAttribute(self.lastExt.value, "cy", cy + heightOffset);
 	                }
 	                return {
 	                    value: options.joinUncorrupt(totalValue, _objectSpread(_objectSpread({}, options), {}, {
@@ -12623,7 +13562,7 @@ function requireRawxml () {
 	    return (String )(t);
 	}
 	var traits = requireTraits();
-	var _require = docUtils, isContent = _require.isContent;
+	var _require = docUtils, isContent = _require.isContent, getPartWithDelimiters = _require.getPartWithDelimiters;
 	var _require2 = requireErrors(), throwRawTagShouldBeOnlyTextInParagraph = _require2.throwRawTagShouldBeOnlyTextInParagraph, getInvalidRawXMLValueException = _require2.getInvalidRawXMLValueException;
 	var wrapper = requireModuleWrapper();
 	var moduleName = "rawxml";
@@ -12672,6 +13611,7 @@ function requireRawxml () {
 	        {
 	            key: "postparse",
 	            value: function postparse(postparsed) {
+	                var _this = this;
 	                return traits.expandToOne(postparsed, {
 	                    moduleName: moduleName,
 	                    getInner: getInner,
@@ -12680,7 +13620,7 @@ function requireRawxml () {
 	                        message: "Raw tag not in paragraph",
 	                        id: "raw_tag_outerxml_invalid",
 	                        explanation: function explanation(part) {
-	                            return "The tag \"".concat(part.value, "\" is not inside a paragraph, putting raw tags inside an inline loop is disallowed.");
+	                            return "The tag \"".concat(getPartWithDelimiters(part, _this.docxtemplater), "\" is not inside a paragraph, putting raw tags inside an inline loop is disallowed.");
 	                        }
 	                    }
 	                });
@@ -12716,6 +13656,8 @@ function requireRawxml () {
 	                        getInvalidRawXMLValueException({
 	                            tag: part.value,
 	                            value: value,
+	                            partDelims: getPartWithDelimiters(part, this.docxtemplater),
+	                            part: part,
 	                            offset: part.offset
 	                        })
 	                    ]
@@ -12968,10 +13910,10 @@ function requireExpandPairTrait () {
 	        },
 	        {
 	            key: "postparse",
-	            value: function postparse(postparsed, _ref) {
+	            value: function postparse(postparsed, options) {
 	                var _this = this;
-	                var getTraits = _ref.getTraits, _postparse = _ref.postparse, fileType = _ref.fileType;
-	                var traits = getTraits(traitName, postparsed);
+	                var getTraits = options.getTraits, postparse = options.postparse, fileType = options.fileType;
+	                var traits = getTraits(traitName, postparsed, options);
 	                traits = traits.map(function(trait) {
 	                    return trait || [];
 	                });
@@ -13052,7 +13994,7 @@ function requireExpandPairTrait () {
 	                    if (expandedPair[1] === i) {
 	                        // End pair
 	                        var basePart = postparsed[pair[0].offset];
-	                        basePart.subparsed = _postparse(innerParts, {
+	                        basePart.subparsed = postparse(innerParts, {
 	                            basePart: basePart
 	                        });
 	                        basePart.endLindex = pair[1].part.lIndex;
@@ -13158,17 +14100,6 @@ function requireRender () {
 	        this.recordedRun = [];
 	    }
 	    return _createClass(Render, [
-	        {
-	            key: "optionsTransformer",
-	            value: function optionsTransformer(options, docxtemplater) {
-	                this.docxtemplater = docxtemplater;
-	                this.brTag = docxtemplater.fileType === "docx" ? "<w:r><w:br/></w:r>" : "<a:br/>";
-	                this.prefix = ftprefix[docxtemplater.fileType];
-	                this.runStartTag = "".concat(this.prefix, ":r");
-	                this.runPropsStartTag = "".concat(this.prefix, ":rPr");
-	                return options;
-	            }
-	        },
 	        {
 	            key: "set",
 	            value: function set(obj) {
@@ -13181,15 +14112,14 @@ function requireRender () {
 	            }
 	        },
 	        {
-	            key: "getRenderedMap",
-	            value: function getRenderedMap(mapper) {
-	                for(var from in this.compiled){
-	                    mapper[from] = {
-	                        from: from,
-	                        data: this.data
-	                    };
-	                }
-	                return mapper;
+	            key: "optionsTransformer",
+	            value: function optionsTransformer(options, docxtemplater) {
+	                this.docxtemplater = docxtemplater;
+	                this.brTag = docxtemplater.fileType === "docx" ? "<w:r><w:br/></w:r>" : "<a:br/>";
+	                this.prefix = ftprefix[docxtemplater.fileType];
+	                this.runStartTag = "".concat(this.prefix, ":r");
+	                this.runPropsStartTag = "".concat(this.prefix, ":rPr");
+	                return options;
 	            }
 	        },
 	        {
@@ -13219,6 +14149,18 @@ function requireRender () {
 	                };
 	            }
 	        },
+	        {
+	            key: "getRenderedMap",
+	            value: function getRenderedMap(mapper) {
+	                for(var from in this.compiled){
+	                    mapper[from] = {
+	                        from: from,
+	                        data: this.data
+	                    };
+	                }
+	                return mapper;
+	            }
+	        },
 	        {
 	            key: "render",
 	            value: function render(part, _ref) {
@@ -13332,6 +14274,9 @@ function requireFileTypeConfig () {
 	        getTemplatedFiles: function getTemplatedFiles() {
 	            return [];
 	        },
+	        templatedNs: [
+	            "http://schemas.microsoft.com/office/2006/coverPageProps"
+	        ],
 	        textPath: function textPath(doc) {
 	            return doc.textTarget;
 	        },
@@ -13346,6 +14291,12 @@ function requireFileTypeConfig () {
 	            "dc:subject",
 	            "dc:title",
 	            "cp:contentStatus",
+	            "PublishDate",
+	            "Abstract",
+	            "CompanyAddress",
+	            "CompanyPhone",
+	            "CompanyFax",
+	            "CompanyEmail",
 	            "w:t",
 	            "a:t",
 	            "m:t",
@@ -13699,7 +14650,8 @@ function requireFileTypeConfig () {
 	    linebreaks: z["boolean"]().optional(),
 	    nullGetter: z["function"]().optional(),
 	    syntax: dxtSyntaxSchema.optional(),
-	    stripInvalidXMLChars: z["boolean"]().optional()
+	    stripInvalidXMLChars: z["boolean"]().optional(),
+	    warnFn: z["function"]().optional()
 	}).strict();
 	var _require = requireGetRelationTypes(), getRelsTypes = _require.getRelsTypes;
 	var _require2 = requireGetContentTypes(), collectContentTypes = _require2.collectContentTypes, getContentTypes = _require2.getContentTypes;
@@ -13725,22 +14677,24 @@ function requireFileTypeConfig () {
 	    2
 	];
 	function throwIfDuplicateModules(modules) {
-	    var duplicates = getDuplicates(modules.map(function(_ref) {
-	        var name = _ref.name;
-	        return name;
-	    }));
+	    var names = [];
+	    for(var _i2 = 0; _i2 < modules.length; _i2++){
+	        var mod = modules[_i2];
+	        names.push(mod.name);
+	    }
+	    var duplicates = getDuplicates(names);
 	    if (duplicates.length > 0) {
 	        throw new XTInternalError("Detected duplicate module \"".concat(duplicates[0], "\""));
 	    }
 	}
 	function addXmlFileNamesFromXmlContentType(doc) {
-	    for(var _i2 = 0, _doc$modules2 = doc.modules; _i2 < _doc$modules2.length; _i2++){
-	        var _module = _doc$modules2[_i2];
-	        for(var _i4 = 0, _ref3 = _module.xmlContentTypes || []; _i4 < _ref3.length; _i4++){
-	            var contentType = _ref3[_i4];
+	    for(var _i4 = 0, _doc$modules2 = doc.modules; _i4 < _doc$modules2.length; _i4++){
+	        var _module = _doc$modules2[_i4];
+	        for(var _i6 = 0, _ref2 = _module.xmlContentTypes || []; _i6 < _ref2.length; _i6++){
+	            var contentType = _ref2[_i6];
 	            var candidates = doc.invertedContentTypes[contentType] || [];
-	            for(var _i6 = 0; _i6 < candidates.length; _i6++){
-	                var candidate = candidates[_i6];
+	            for(var _i8 = 0; _i8 < candidates.length; _i8++){
+	                var candidate = candidates[_i8];
 	                if (doc.zip.files[candidate]) {
 	                    doc.options.xmlFileNames.push(candidate);
 	                }
@@ -13793,10 +14747,10 @@ function requireFileTypeConfig () {
 	        "xl/",
 	        "ppt/"
 	    ];
-	    for(var _i8 = 0; _i8 < allFiles.length; _i8++){
-	        var _name = allFiles[_i8];
-	        for(var _i0 = 0; _i0 < prefixes.length; _i0++){
-	            var prefix = prefixes[_i0];
+	    for(var _i0 = 0; _i0 < allFiles.length; _i0++){
+	        var _name = allFiles[_i0];
+	        for(var _i10 = 0; _i10 < prefixes.length; _i10++){
+	            var prefix = prefixes[_i10];
 	            if (_name.indexOf("".concat(prefix)) === 0) {
 	                resultFiles.push(_name);
 	            }
@@ -13804,8 +14758,8 @@ function requireFileTypeConfig () {
 	    }
 	    /*
 	   * Push the rest of files, such as docProps/core.xml and docProps/app.xml
-	   */ for(var _i10 = 0; _i10 < allFiles.length; _i10++){
-	        var _name2 = allFiles[_i10];
+	   */ for(var _i12 = 0; _i12 < allFiles.length; _i12++){
+	        var _name2 = allFiles[_i12];
 	        if (resultFiles.indexOf(_name2) === -1) {
 	            resultFiles.push(_name2);
 	        }
@@ -13857,7 +14811,7 @@ function requireFileTypeConfig () {
 	}
 	var Docxtemplater = /*#__PURE__*/ function() {
 	    function Docxtemplater(zip) {
-	        var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, _ref4$modules = _ref4.modules, modules = _ref4$modules === void 0 ? [] : _ref4$modules, options = _objectWithoutProperties(_ref4, _excluded);
+	        var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, _ref3$modules = _ref3.modules, modules = _ref3$modules === void 0 ? [] : _ref3$modules, options = _objectWithoutProperties(_ref3, _excluded);
 	        _classCallCheck(this, Docxtemplater);
 	        this.targets = [];
 	        this.rendered = false;
@@ -13883,8 +14837,8 @@ function requireFileTypeConfig () {
 	            if (!Array.isArray(modules)) {
 	                throw new Error("The modules argument of docxtemplater's constructor must be an array");
 	            }
-	            for(var _i12 = 0; _i12 < modules.length; _i12++){
-	                var _module2 = modules[_i12];
+	            for(var _i14 = 0; _i14 < modules.length; _i14++){
+	                var _module2 = modules[_i14];
 	                this.attachModule(_module2);
 	            }
 	            this.loadZip(zip);
@@ -13897,9 +14851,10 @@ function requireFileTypeConfig () {
 	        {
 	            key: "verifyApiVersion",
 	            value: function verifyApiVersion(neededVersion) {
-	                neededVersion = neededVersion.split(".").map(function(i) {
-	                    return parseInt(i, 10);
-	                });
+	                neededVersion = neededVersion.split(".");
+	                for(var i = 0; i < neededVersion.length; i++){
+	                    neededVersion[i] = parseInt(neededVersion[i], 10);
+	                }
 	                if (neededVersion.length !== 3) {
 	                    throwApiVersionError("neededVersion is not a valid version", {
 	                        neededVersion: neededVersion,
@@ -13933,8 +14888,8 @@ function requireFileTypeConfig () {
 	        {
 	            key: "setModules",
 	            value: function setModules(obj) {
-	                for(var _i14 = 0, _this$modules2 = this.modules; _i14 < _this$modules2.length; _i14++){
-	                    var _module3 = _this$modules2[_i14];
+	                for(var _i16 = 0, _this$modules2 = this.modules; _i16 < _this$modules2.length; _i16++){
+	                    var _module3 = _this$modules2[_i16];
 	                    _module3.set(obj);
 	                }
 	            }
@@ -13942,8 +14897,8 @@ function requireFileTypeConfig () {
 	        {
 	            key: "sendEvent",
 	            value: function sendEvent(eventName) {
-	                for(var _i16 = 0, _this$modules4 = this.modules; _i16 < _this$modules4.length; _i16++){
-	                    var _module4 = _this$modules4[_i16];
+	                for(var _i18 = 0, _this$modules4 = this.modules; _i18 < _this$modules4.length; _i18++){
+	                    var _module4 = _this$modules4[_i18];
 	                    _module4.on(eventName);
 	                }
 	            }
@@ -13985,8 +14940,8 @@ function requireFileTypeConfig () {
 	        {
 	            key: "findModule",
 	            value: function findModule(name) {
-	                for(var _i18 = 0, _this$modules6 = this.modules; _i18 < _this$modules6.length; _i18++){
-	                    var _module5 = _this$modules6[_i18];
+	                for(var _i20 = 0, _this$modules6 = this.modules; _i20 < _this$modules6.length; _i20++){
+	                    var _module5 = _this$modules6[_i20];
 	                    if (_module5.name === name) {
 	                        return _module5;
 	                    }
@@ -14030,6 +14985,11 @@ function requireFileTypeConfig () {
 	                if (zip.loadAsync) {
 	                    throw new XTInternalError("Docxtemplater doesn't handle JSZip version >=3, please use pizzip");
 	                }
+	                if (zip.xtRendered) {
+	                    this.options.warnFn([
+	                        new Error("This zip file appears to be the outcome of a previous docxtemplater generation. This typically indicates that docxtemplater was integrated by reusing the same zip file. It is recommended to create a new Pizzip instance for each docxtemplater generation.")
+	                    ]);
+	                }
 	                this.zip = zip;
 	                this.updateFileTypeConfig();
 	                this.modules = concatArrays([
@@ -14038,8 +14998,8 @@ function requireFileTypeConfig () {
 	                    }),
 	                    this.modules
 	                ]);
-	                for(var _i20 = 0, _this$modules8 = this.modules; _i20 < _this$modules8.length; _i20++){
-	                    var _module6 = _this$modules8[_i20];
+	                for(var _i22 = 0, _this$modules8 = this.modules; _i22 < _this$modules8.length; _i22++){
+	                    var _module6 = _this$modules8[_i22];
 	                    _module6.zip = this.zip;
 	                    _module6.docxtemplater = this;
 	                    _module6.fileTypeConfig = this.fileTypeConfig;
@@ -14095,9 +15055,11 @@ function requireFileTypeConfig () {
 	                    _this.mapper = _this.modules.reduce(function(value, module1) {
 	                        return module1.getRenderedMap(value);
 	                    }, {});
-	                    return Promise.all(Object.keys(_this.mapper).map(function(to) {
+	                    var promises = [];
+	                    var _loop = function _loop() {
+	                        var to = _Object$keys2[_i24];
 	                        var _this$mapper$to = _this.mapper[to], from = _this$mapper$to.from, _$data = _this$mapper$to.data;
-	                        return Promise.resolve(_$data).then(function(data) {
+	                        promises.push(Promise.resolve(_$data).then(function(data) {
 	                            var currentFile = _this.compiled[from];
 	                            currentFile.filePath = to;
 	                            currentFile.scopeManager = _this.getScopeManager(to, currentFile, data);
@@ -14107,8 +15069,12 @@ function requireFileTypeConfig () {
 	                            }, function(errs) {
 	                                pushArray(errors, errs);
 	                            });
-	                        });
-	                    })).then(function(resolved) {
+	                        }));
+	                    };
+	                    for(var _i24 = 0, _Object$keys2 = Object.keys(_this.mapper); _i24 < _Object$keys2.length; _i24++){
+	                        _loop();
+	                    }
+	                    return Promise.all(promises).then(function(resolved) {
 	                        if (errors.length !== 0) {
 	                            if (_this.options.errorLogging) {
 	                                logErrors(errors, _this.options.errorLogging);
@@ -14131,14 +15097,14 @@ function requireFileTypeConfig () {
 	                    return this;
 	                }
 	                var options = this.options;
-	                for(var _i22 = 0, _this$modules0 = this.modules; _i22 < _this$modules0.length; _i22++){
-	                    var _module7 = _this$modules0[_i22];
+	                for(var _i26 = 0, _this$modules0 = this.modules; _i26 < _this$modules0.length; _i26++){
+	                    var _module7 = _this$modules0[_i26];
 	                    options = _module7.optionsTransformer(options, this);
 	                }
 	                this.options = options;
 	                this.options.xmlFileNames = uniq(this.options.xmlFileNames);
-	                for(var _i24 = 0, _this$options$xmlFile2 = this.options.xmlFileNames; _i24 < _this$options$xmlFile2.length; _i24++){
-	                    var fileName = _this$options$xmlFile2[_i24];
+	                for(var _i28 = 0, _this$options$xmlFile2 = this.options.xmlFileNames; _i28 < _this$options$xmlFile2.length; _i28++){
+	                    var fileName = _this$options$xmlFile2[_i28];
 	                    var content = this.zip.files[fileName].asText();
 	                    this.xmlDocuments[fileName] = str2xml(content);
 	                }
@@ -14146,8 +15112,8 @@ function requireFileTypeConfig () {
 	                    zip: this.zip,
 	                    xmlDocuments: this.xmlDocuments
 	                });
-	                for(var _i26 = 0, _this$modules10 = this.modules; _i26 < _this$modules10.length; _i26++){
-	                    var _module8 = _this$modules10[_i26];
+	                for(var _i30 = 0, _this$modules10 = this.modules; _i30 < _this$modules10.length; _i30++){
+	                    var _module8 = _this$modules10[_i30];
 	                    _module8.xmlDocuments = this.xmlDocuments;
 	                }
 	                this.getTemplatedFiles();
@@ -14155,15 +15121,15 @@ function requireFileTypeConfig () {
 	       * Loop inside all templatedFiles (ie xml files with content).
 	       * Sometimes they don't exist (footer.xml for example)
 	       */ this.sendEvent("before-preparse");
-	                for(var _i28 = 0, _this$templatedFiles2 = this.templatedFiles; _i28 < _this$templatedFiles2.length; _i28++){
-	                    var _fileName = _this$templatedFiles2[_i28];
+	                for(var _i32 = 0, _this$templatedFiles2 = this.templatedFiles; _i32 < _this$templatedFiles2.length; _i32++){
+	                    var _fileName = _this$templatedFiles2[_i32];
 	                    if (this.zip.files[_fileName] != null) {
 	                        this.precompileFile(_fileName);
 	                    }
 	                }
 	                this.sendEvent("after-preparse");
-	                for(var _i30 = 0, _this$templatedFiles4 = this.templatedFiles; _i30 < _this$templatedFiles4.length; _i30++){
-	                    var _fileName2 = _this$templatedFiles4[_i30];
+	                for(var _i34 = 0, _this$templatedFiles4 = this.templatedFiles; _i34 < _this$templatedFiles4.length; _i34++){
+	                    var _fileName2 = _this$templatedFiles4[_i34];
 	                    if (this.zip.files[_fileName2] != null) {
 	                        this.compiled[_fileName2].parse({
 	                            noPostParse: true
@@ -14171,8 +15137,8 @@ function requireFileTypeConfig () {
 	                    }
 	                }
 	                this.sendEvent("after-parse");
-	                for(var _i32 = 0, _this$templatedFiles6 = this.templatedFiles; _i32 < _this$templatedFiles6.length; _i32++){
-	                    var _fileName3 = _this$templatedFiles6[_i32];
+	                for(var _i36 = 0, _this$templatedFiles6 = this.templatedFiles; _i36 < _this$templatedFiles6.length; _i36++){
+	                    var _fileName3 = _this$templatedFiles6[_i36];
 	                    if (this.zip.files[_fileName3] != null) {
 	                        this.compiled[_fileName3].postparse();
 	                    }
@@ -14202,8 +15168,8 @@ function requireFileTypeConfig () {
 	                if (this.zip.files.mimetype) {
 	                    fileType = "odt";
 	                }
-	                for(var _i34 = 0, _this$modules12 = this.modules; _i34 < _this$modules12.length; _i34++){
-	                    var _module9 = _this$modules12[_i34];
+	                for(var _i38 = 0, _this$modules12 = this.modules; _i38 < _this$modules12.length; _i38++){
+	                    var _module9 = _this$modules12[_i38];
 	                    fileType = _module9.getFileType({
 	                        zip: this.zip,
 	                        contentTypes: contentTypes,
@@ -14254,6 +15220,7 @@ function requireFileTypeConfig () {
 	                this.hideDeprecations = true;
 	                var promise = this.resolveData(data);
 	                this.hideDeprecations = false;
+	                this.zip.xtRendered = true;
 	                return promise.then(function() {
 	                    return _this2.render();
 	                });
@@ -14262,6 +15229,7 @@ function requireFileTypeConfig () {
 	        {
 	            key: "render",
 	            value: function render(data) {
+	                this.zip.xtRendered = true;
 	                if (this.rendered) {
 	                    throwRenderTwice();
 	                }
@@ -14295,11 +15263,11 @@ function requireFileTypeConfig () {
 	                    ]);
 	                    delete currentFile.content;
 	                }
-	                for(var _i36 = 0; _i36 < output.length; _i36++){
-	                    var outputPart = output[_i36];
+	                for(var _i40 = 0; _i40 < output.length; _i40++){
+	                    var outputPart = output[_i40];
 	                    var _outputPart = _slicedToArray(outputPart, 3), content = _outputPart[1], _currentFile = _outputPart[2];
-	                    for(var _i38 = 0, _this$modules14 = this.modules; _i38 < _this$modules14.length; _i38++){
-	                        var _module0 = _this$modules14[_i38];
+	                    for(var _i42 = 0, _this$modules14 = this.modules; _i42 < _this$modules14.length; _i42++){
+	                        var _module0 = _this$modules14[_i42];
 	                        if (_module0.preZip) {
 	                            var result = _module0.preZip(content, _currentFile);
 	                            if (typeof result === "string") {
@@ -14308,8 +15276,8 @@ function requireFileTypeConfig () {
 	                        }
 	                    }
 	                }
-	                for(var _i40 = 0; _i40 < output.length; _i40++){
-	                    var _output$_i = _slicedToArray(output[_i40], 2), _to = _output$_i[0], _content = _output$_i[1];
+	                for(var _i44 = 0; _i44 < output.length; _i44++){
+	                    var _output$_i = _slicedToArray(output[_i44], 2), _to = _output$_i[0], _content = _output$_i[1];
 	                    this.zip.file(_to, _content, {
 	                        createFolders: true
 	                    });
@@ -14370,8 +15338,8 @@ function requireFileTypeConfig () {
 	                    "fileType",
 	                    "modules"
 	                ]);
-	                for(var _i42 = 0; _i42 < defaultKeys.length; _i42++){
-	                    var key = defaultKeys[_i42];
+	                for(var _i46 = 0; _i46 < defaultKeys.length; _i46++){
+	                    var key = defaultKeys[_i46];
 	                    xmltOptions[key] = this[key];
 	                }
 	                return new Docxtemplater.XmlTemplater(content, xmltOptions);
@@ -14388,6 +15356,20 @@ function requireFileTypeConfig () {
 	            value: function getTemplatedFiles() {
 	                this.templatedFiles = this.fileTypeConfig.getTemplatedFiles(this.zip);
 	                pushArray(this.templatedFiles, this.targets);
+	                var templatedNs = this.fileTypeConfig.templatedNs || [];
+	                if (templatedNs.length > 0) {
+	                    for(var key in this.filesContentTypes){
+	                        if (/^customXml\/item\d+\.xml$/.test(key)) {
+	                            for(var _i48 = 0; _i48 < templatedNs.length; _i48++){
+	                                var ns = templatedNs[_i48];
+	                                var text = this.zip.file(key).asText();
+	                                if (text.indexOf("xmlns=\"".concat(ns, "\"")) !== -1) {
+	                                    this.templatedFiles.push(key);
+	                                }
+	                            }
+	                        }
+	                    }
+	                }
 	                this.templatedFiles = uniq(this.templatedFiles);
 	                return this.templatedFiles;
 	            }