@digipair/skill-docxtemplater 0.136.3 → 0.136.4

package/dist/index.esm.js

@@ -714,11 +714,6 @@ 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
@@ -926,12 +921,6 @@ 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);
@@ -1043,7 +1032,6 @@ 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;
@@ -1052,8 +1040,6 @@ 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;
@@ -1363,38 +1349,13 @@ NodeList.prototype = {
     /**
 	 * Returns a string representation of the NodeList.
 	 *
-	 * 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]
+	 * @param {unknown} nodeFilter
+	 * __A filter function? Not implemented according to the spec?__.
 	 * @returns {string}
-	 */ 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
-            };
-        }
+	 * A string representation of the NodeList.
+	 */ toString: function toString(nodeFilter) {
         for(var buf = [], i = 0; i < this.length; i++){
-            serializeToString(this[i], buf, null, opts);
+            serializeToString(this[i], buf, nodeFilter);
         }
         return buf.join('');
     },
@@ -1894,21 +1855,11 @@ 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. 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.
+	 * The external subset public identifier.
 	 * @param {string} [systemId]
-	 * 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.
+	 * The external subset system identifier.
 	 * @param {string} [internalSubset]
-	 * 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.
+	 * the internal subset or an empty string if it is not present
 	 * @returns {DocumentType}
 	 * A new {@link DocumentType} node with {@link Node#ownerDocument} set to null.
 	 * @throws {DOMException}
@@ -2101,7 +2052,7 @@ Node.prototype = {
         var parent = other;
         do {
             if (this === parent) return true;
-            parent = parent.parentNode;
+            parent = other.parentNode;
         }while (parent);
         return false;
     },
@@ -2131,73 +2082,50 @@ 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;
-        // 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
-                        });
+        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;
                     }
-                    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]
-                });
+                }
+                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;
             }
         }
         return true;
@@ -2309,7 +2237,7 @@ Node.prototype = {
 	 * is `TEXT_NODE`) into a single node with the combined data. It also removes any empty text
 	 * nodes.
 	 *
-	 * This method iterativly traverses all child nodes to normalize all descendent nodes within
+	 * This method operates recursively, so it also normalizes any and all descendent nodes within
 	 * the subtree.
 	 *
 	 * @throws {DOMException}
@@ -2318,27 +2246,18 @@ Node.prototype = {
 	 * @since Modified in DOM Level 2
 	 * @see {@link Node.removeChild}
 	 * @see {@link CharacterData.appendData}
-	 * @see ../docs/walk-dom.md.
 	 */ normalize: function normalize() {
-        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
+        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;
             }
-        });
+        }
     },
     /**
 	 * Checks whether the DOM implementation implements a specific feature and its version.
@@ -2533,118 +2452,22 @@ copy(NodeType, Node.prototype);
 copy(DocumentPosition, Node);
 copy(DocumentPosition, Node.prototype);
 /**
- * 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.
+ * @param callback
+ * Return true for continue,false for break.
+ * @returns
+ * boolean true: break visit;
  */ function _visitNode(node, callback) {
-    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;
-            }
-            // 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);
+    if (callback(node)) {
+        return true;
+    }
+    if (node = node.firstChild) {
+        do {
+            if (_visitNode(node, callback)) {
+                return true;
             }
-        }
+        }while (node = node.nextSibling);
     }
 }
-/**
- * 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]
@@ -3164,20 +2987,8 @@ Document.prototype = {
             this.documentElement = newChild;
         }
     },
-    /**
-	 * 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) {
+    // Introduced in DOM Level 2:
+    importNode: function importNode1(importedNode, deep) {
         return importNode(this, importedNode, deep);
     },
     // Introduced in DOM Level 2:
@@ -3248,15 +3059,6 @@ 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;
@@ -3265,21 +3067,9 @@ 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();
@@ -3287,24 +3077,9 @@ 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;
@@ -3708,31 +3483,7 @@ CDATASection.prototype = {
     nodeType: CDATA_SECTION_NODE
 };
 _extends(CDATASection, Text);
-/**
- * @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) {
+function DocumentType(symbol) {
     checkSymbol(symbol);
 }
 DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
@@ -3764,89 +3515,11 @@ function ProcessingInstruction(symbol) {
 ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
 _extends(ProcessingInstruction, CharacterData);
 function XMLSerializer$1() {}
-/**
- * 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);
+XMLSerializer$1.prototype.serializeToString = function(node, nodeFilter) {
+    return nodeSerializeToString.call(node, nodeFilter);
 };
 Node.prototype.toString = nodeSerializeToString;
-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
-        };
-    }
+function nodeSerializeToString(nodeFilter) {
     var buf = [];
     var refNode = this.nodeType === DOCUMENT_NODE && this.documentElement || this;
     var prefix = refNode.prefix;
@@ -3862,7 +3535,7 @@ function nodeSerializeToString(options) {
             ];
         }
     }
-    serializeToString(this, buf, visibleNamespaces, opts);
+    serializeToString(this, buf, nodeFilter, visibleNamespaces);
     return buf.join('');
 }
 function needNamespaceDefine(node, isHTML, visibleNamespaces) {
@@ -3908,302 +3581,222 @@ function needNamespaceDefine(node, isHTML, visibleNamespaces) {
  */ function addSerializedAttribute(buf, qualifiedName, value) {
     buf.push(' ', qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');
 }
-function serializeToString(node, buf, visibleNamespaces, opts) {
+function serializeToString(node, buf, nodeFilter, visibleNamespaces) {
     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';
-    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 (nodeFilter) {
+        node = nodeFilter(node);
+        if (node) {
+            if (typeof node == 'string') {
+                buf.push(node);
+                return;
             }
-            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;
-                                }
-                            }
-                        }
-                    }
-                    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
-                            });
-                        }
+        } 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;
                     }
-                    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);
-                            }
+                }
+                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;
                         }
                     }
-                    // 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);
+                }
+                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;
                             }
-                            child = child.nextSibling;
-                        }
-                        buf.push('</', prefixedNodeName, '>');
-                        // Children handled manually above; prevent walkDOM from also traversing them.
-                        return null;
-                    }
-                    // 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);
-                    }
-                    // 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);
+                            break;
                         }
                     }
-                    buf.push(g$1.DOCTYPE_DECL_START, ' ', n.name);
-                    if (pubid) {
-                        buf.push(' ', g$1.PUBLIC, ' ', pubid);
-                        if (sysid && sysid !== '.') {
-                            buf.push(' ', sysid);
+                }
+            }
+            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());
                         }
-                    } else if (sysid && sysid !== '.') {
-                        buf.push(' ', g$1.SYSTEM, ' ', sysid);
-                    }
-                    if (n.internalSubset) {
-                        buf.push(' [', n.internalSubset, ']');
+                        child = child.nextSibling;
                     }
-                    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);
-                        }
+                } else {
+                    while(child){
+                        serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
+                        child = child.nextSibling;
                     }
-                    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;
+                }
+                buf.push('</', prefixedNodeName, '>');
             }
-        },
-        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, '>');
+            // 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;
             }
-        }
-    });
-}
-/**
- * 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);
+            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);
+            }
+            if (node.internalSubset) {
+                buf.push(' [', node.internalSubset, ']');
             }
-            // 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;
+            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;
         }
-    });
-    return destRoot;
+    }
+    return node2;
 }
 /**
  * Creates a copy of a node from an existing one.
@@ -4221,73 +3814,46 @@ function serializeToString(node, buf, visibleNamespaces, opts) {
  * 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 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;
-                        }
-                    }
+    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;
                 }
             }
-            if (srcNode.childNodes) {
-                destNode.childNodes = new NodeList();
-            }
-            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;
+        }
+    }
+    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));
             }
-            // 4. Return destNode as the context for children (causes walkDOM to descend),
-            //    or null to skip children (shallow clone).
-            return shouldDeep ? destNode : null;
+            break;
+        case ATTRIBUTE_NODE:
+            deep = true;
+    }
+    if (deep) {
+        var child = node.firstChild;
+        while(child){
+            node2.appendChild(cloneNode(doc, child, deep));
+            child = child.nextSibling;
         }
-    });
-    return destRoot;
+    }
+    return node2;
 }
 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) {
@@ -4297,36 +3863,9 @@ try {
                 return this.$$length;
             }
         });
-        /**
-		 * 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', {
+        Object.defineProperty(Node.prototype, 'textContent', {
             get: function get() {
-                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;
+                return getTextContent(this);
             },
             set: function set(data) {
                 switch(this.nodeType){
@@ -4346,21 +3885,23 @@ try {
                 }
             }
         });
-        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);
+        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;
             }
-        });
+        }
         __set__ = function __set__(object, key, value) {
             //console.log(value)
             object['$$' + key] = value;
@@ -4388,7 +3929,6 @@ 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 = {};
@@ -8092,200 +7632,76 @@ function requireErrors () {
 	    this.stack = new Error(message).stack;
 	}
 	XTAPIVersionError.prototype = new XTError();
-	/*
-	 * Version/Compatibility Errors
-	 * ============================
-	 */ function throwApiVersionError(msg, properties) {
+	function throwApiVersionError(msg, properties) {
 	    var err = new XTAPIVersionError(msg);
-	    /*
-	   * 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({
+	    err.properties = _objectSpread({
 	        id: "api_version_error"
 	    }, properties);
 	    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));
-	    /*
-	   * 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 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"
+	function throwMultiError(errors) {
+	    var err = new XTTemplateError("Multi error");
+	    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 = {
+	    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, 30), "\" is unopened")
+	        explanation: "The tag beginning with \"".concat(options.xtag.substr(0, 10), "\" is unopened")
 	    };
 	    return err;
 	}
 	function getDuplicateOpenTagException(options) {
 	    var err = new XTTemplateError("Duplicate open tag, expected one open tag");
-	    /*
-	   * This error happens with following template :
-	   *
-	   * ```docx
-	   * Hello {{name
-	   * ```
-	   */ err.properties = {
+	    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, 30), "\" has duplicate open tags")
+	        explanation: "The tag beginning with \"".concat(options.xtag.substr(0, 10), "\" has duplicate open tags")
 	    };
 	    return err;
 	}
 	function getDuplicateCloseTagException(options) {
 	    var err = new XTTemplateError("Duplicate close tag, expected one close tag");
-	    /*
-	   * This error happens with following template :
-	   *
-	   * ```docx
-	   * Hello {name}}
-	   * ```
-	   */ err.properties = {
+	    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, 30), "\" has duplicate close tags")
+	        explanation: "The tag ending with \"".concat(options.xtag.substr(0, 10), "\" has duplicate close tags")
 	    };
 	    return err;
 	}
 	function getUnclosedTagException(options) {
 	    var err = new XTTemplateError("Unclosed tag");
-	    /*
-	   * This error happens if a tag is opened but not closed.
-	   * For example with the following template:
-	   *
-	   * ```docx
-	   * Hello {name !
-	   * ```
-	   */ err.properties = {
+	    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, 30), "\" is unclosed")
+	        explanation: "The tag beginning with \"".concat(options.xtag.substr(0, 10), "\" 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];
-	    /*
-	   * 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"),
+	    err.properties = {
+	        id: "no_xml_tag_found_at_".concat(options.position),
+	        explanation: "No tag \"".concat(options.element, "\" was found at the ").concat(options.position),
 	        offset: part.offset,
 	        part: part,
 	        parsed: options.parsed,
@@ -8297,35 +7713,24 @@ 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");
-	    /*
-	   * 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 = {
+	    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, partDelims = _ref2.partDelims;
+	    var tag = _ref2.tag, value = _ref2.value, offset = _ref2.offset;
 	    var err = new XTRenderingError("Non string values are not allowed for rawXML tags");
-	    /*
-	   * 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 = {
+	    err.properties = {
 	        id: "invalid_raw_xml_value",
 	        xtag: tag,
 	        value: value,
 	        offset: offset,
-	        explanation: "The value of the raw tag : \"".concat(partDelims, "\" is not a string")
+	        explanation: "The value of the raw tag : '".concat(tag, "' is not a string")
 	    };
 	    return err;
 	}
@@ -8336,10 +7741,7 @@ function requireErrors () {
 	    if (typeof explanation === "function") {
 	        explanation = explanation(part);
 	    }
-	    /*
-	   * 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);
+	    var err = new XTTemplateError(message);
 	    err.properties = {
 	        id: id,
 	        explanation: explanation,
@@ -8355,36 +7757,7 @@ function requireErrors () {
 	function throwRawTagShouldBeOnlyTextInParagraph(options) {
 	    var err = new XTTemplateError("Raw tag should be the only text in paragraph");
 	    var tag = options.part.value;
-	    /*
-	   * 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 = {
+	    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,
@@ -8393,23 +7766,13 @@ function requireErrors () {
 	    };
 	    throw err;
 	}
-	/*
-	 * Loop / Table Structure Errors
-	 * =============================
-	 */ function getUnmatchedLoopException(part) {
+	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;
-	    /*
-	   * This error happens with following template :
-	   *
-	   * ```docx
-	   * {#users}
-	   * {/companies}
-	   * ```
-	   */ err.properties = {
+	    err.properties = {
 	        id: "".concat(t, "_loop"),
 	        explanation: "The loop with tag \"".concat(tag, "\" is ").concat(t),
 	        xtag: tag,
@@ -8426,25 +7789,7 @@ function requireErrors () {
 	    var lastR = lastPair[1].part.value;
 	    var l = pair[0].part.value;
 	    var r = pair[1].part.value;
-	    /*
-	   * 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 = {
+	    err.properties = {
 	        id: "unbalanced_loop_tags",
 	        explanation: "Unbalanced loop tags {#".concat(lastL, "}{/").concat(lastR, "}{#").concat(l, "}{/").concat(r, "}"),
 	        offset: [
@@ -8465,17 +7810,7 @@ function requireErrors () {
 	function getClosingTagNotMatchOpeningTag(_ref3) {
 	    var tags = _ref3.tags;
 	    var err = new XTTemplateError("Closing tag does not match opening tag");
-	    /*
-	   * 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 = {
+	    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,
@@ -8493,53 +7828,10 @@ function requireErrors () {
 	    }
 	    return err;
 	}
-	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;
+	function getScopeCompilationError(_ref4) {
+	    var tag = _ref4.tag, rootError = _ref4.rootError, offset = _ref4.offset;
 	    var err = new XTScopeParserError("Scope parser compilation failed");
-	    /*
-	   * 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 = {
+	    err.properties = {
 	        id: "scopeparser_compilation_failed",
 	        offset: offset,
 	        xtag: tag,
@@ -8548,47 +7840,12 @@ function requireErrors () {
 	    };
 	    return err;
 	}
-	function getScopeParserExecutionError(_ref6) {
-	    var tag = _ref6.tag, scope = _ref6.scope, error = _ref6.error, offset = _ref6.offset;
+	function getScopeParserExecutionError(_ref5) {
+	    var tag = _ref5.tag, scope = _ref5.scope, error = _ref5.error, offset = _ref5.offset;
 	    var err = new XTScopeParserError("Scope parser execution failed");
-	    /*
-	   * 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 = {
+	    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,
@@ -8596,20 +7853,24 @@ function requireErrors () {
 	    };
 	    return err;
 	}
-	/*
-	 * Internal / API Misuse Errors
-	 * ============================
-	 */ function throwUnimplementedTagType(part, index) {
+	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) {
 	    var errorMsg = "Unimplemented tag type \"".concat(part.type, "\"");
 	    if (part.module) {
 	        errorMsg += " \"".concat(part.module, "\"");
 	    }
 	    var err = new XTTemplateError(errorMsg);
-	    /*
-	   * 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 = {
+	    err.properties = {
 	        part: part,
 	        index: index,
 	        id: "unimplemented_tag_type"
@@ -8618,10 +7879,7 @@ function requireErrors () {
 	}
 	function throwMalformedXml() {
 	    var err = new XTInternalError("Malformed xml");
-	    /*
-	   * This happens when an xml file of the document cannot be parsed
-	   * correctly.
-	   */ err.properties = {
+	    err.properties = {
 	        explanation: "The template contains malformed xml",
 	        id: "malformed_xml"
 	    };
@@ -8629,13 +7887,7 @@ function requireErrors () {
 	}
 	function throwResolveBeforeCompile() {
 	    var err = new XTInternalError("You must run `.compile()` before running `.resolveData()`");
-	    /*
-	   * 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 = {
+	    err.properties = {
 	        id: "resolve_before_compile",
 	        explanation: "You must run `.compile()` before running `.resolveData()`"
 	    };
@@ -8643,9 +7895,7 @@ function requireErrors () {
 	}
 	function throwRenderInvalidTemplate() {
 	    var err = new XTInternalError("You should not call .render on a document that had compilation errors");
-	    /*
-	   * This happens if you're calling `render()` on a document that had template errors
-	   */ err.properties = {
+	    err.properties = {
 	        id: "render_on_invalid_template",
 	        explanation: "You should not call .render on a document that had compilation errors"
 	    };
@@ -8653,25 +7903,30 @@ function requireErrors () {
 	}
 	function throwRenderTwice() {
 	    var err = new XTInternalError("You should not call .render twice on the same docxtemplater instance");
-	    /*
-	   * 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 = {
+	    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");
-	    /*
-	   * 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 = {
+	    err.properties = {
 	        id: "file_has_invalid_xml",
 	        content: content,
 	        offset: offset,
@@ -8679,6 +7934,15 @@ 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,
@@ -8782,14 +8046,6 @@ 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;
@@ -8851,8 +8107,8 @@ function chunkBy(parsed, f) {
     var chunks = [
         []
     ];
-    for(var _i4 = 0; _i4 < parsed.length; _i4++){
-        var p = parsed[_i4];
+    for(var _i2 = 0; _i2 < parsed.length; _i2++){
+        var p = parsed[_i2];
         var currentChunk = chunks[chunks.length - 1];
         var res = f(p);
         if (res === "start") {
@@ -8867,8 +8123,8 @@ function chunkBy(parsed, f) {
         }
     } // Remove empty chunks
     var result = [];
-    for(var _i6 = 0; _i6 < chunks.length; _i6++){
-        var chunk = chunks[_i6];
+    for(var _i4 = 0; _i4 < chunks.length; _i4++){
+        var chunk = chunks[_i4];
         if (chunk.length > 0) {
             result.push(chunk);
         }
@@ -8887,7 +8143,6 @@ function getDefaults() {
             "[Content_Types].xml"
         ],
         parser: parser,
-        warnFn: defaultWarnFn,
         linebreaks: false,
         fileTypeConfig: null,
         delimiters: {
@@ -8895,11 +8150,7 @@ function getDefaults() {
             end: "}"
         },
         syntax: {
-            changeDelimiterPrefix: "=",
-            preserveNewlinesInTags: false,
-            allowUnopenedTag: false,
-            allowUnclosedTag: false,
-            allowUnbalancedLoops: false
+            changeDelimiterPrefix: "="
         }
     };
 }
@@ -8969,10 +8220,10 @@ function utf8ToWord(string) {
 // This function is written with for loops for performance
 function concatArrays(arrays) {
     var result = [];
-    for(var _i8 = 0; _i8 < arrays.length; _i8++){
-        var array = arrays[_i8];
-        for(var _i0 = 0; _i0 < array.length; _i0++){
-            var el = array[_i0];
+    for(var _i6 = 0; _i6 < arrays.length; _i6++){
+        var array = arrays[_i6];
+        for(var _i8 = 0; _i8 < array.length; _i8++){
+            var el = array[_i8];
             result.push(el);
         }
     }
@@ -9047,8 +8298,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 _i10 = 0, _elements2 = elements; _i10 < _elements2.length; _i10++){
-            var element = _elements2[_i10];
+        for(var _i0 = 0, _elements2 = elements; _i0 < _elements2.length; _i0++){
+            var element = _elements2[_i0];
             if (isEnding(part.value, element)) {
                 level--;
             }
@@ -9083,8 +8334,8 @@ function getLeftOrNull(parsed, elements, index) {
     var level = 1;
     for(var i = index; i >= 0; i--){
         var part = parsed[i];
-        for(var _i12 = 0, _elements4 = elements; _i12 < _elements4.length; _i12++){
-            var element = _elements4[_i12];
+        for(var _i10 = 0, _elements4 = elements; _i10 < _elements4.length; _i10++){
+            var element = _elements4[_i10];
             if (isStarting(part.value, element)) {
                 level--;
             }
@@ -9126,27 +8377,20 @@ function isParagraphEnd(_ref6) {
         "text:p"
     ].indexOf(tag) !== -1 && type === "tag" && position === "end";
 }
-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 isTextStart(_ref8) {
-    var type = _ref8.type, position = _ref8.position, text = _ref8.text;
+function isTextStart(_ref7) {
+    var type = _ref7.type, position = _ref7.position, text = _ref7.text;
     return text && type === "tag" && position === "start";
 }
-function isTextEnd(_ref9) {
-    var type = _ref9.type, position = _ref9.position, text = _ref9.text;
+function isTextEnd(_ref8) {
+    var type = _ref8.type, position = _ref8.position, text = _ref8.text;
     return text && type === "tag" && position === "end";
 }
-function isContent(_ref0) {
-    var type = _ref0.type, position = _ref0.position;
+function isContent(_ref9) {
+    var type = _ref9.type, position = _ref9.position;
     return type === "placeholder" || type === "content" && position === "insidetag";
 }
-function isModule(_ref1, modules) {
-    var _$module = _ref1.module, type = _ref1.type;
+function isModule(_ref0, modules) {
+    var _$module = _ref0.module, type = _ref0.type;
     if (!_instanceof$2(modules, Array)) {
         modules = [
             modules
@@ -9210,35 +8454,26 @@ 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
-    var withIndex = [];
-    for(var i = 0; i < arr.length; i++){
-        withIndex.push({
-            item: arr[i],
-            index: i
-        });
-    }
-    withIndex.sort(function(a, b) {
+    // 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) {
         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,
@@ -9680,18 +8915,20 @@ function requireGetContentTypes () {
 	        var partName = override.getAttribute("PartName").substr(1);
 	        partNames[partName] = contentType;
 	    }
-	    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");
+	    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;
 	            if (name.slice(name.length - extension.length) === extension && !partNames[name] && name !== ctXML) {
-	                partNames[name] = _contentType;
+	                partNames[name] = contentType;
 	            }
-	        }
-	        partNames[name] || (partNames[name] = "");
-	    });
+	        });
+	    };
+	    for(var _i4 = 0; _i4 < defaults.length; _i4++){
+	        _loop();
+	    }
 	    return partNames;
 	}
 	function getContentTypes(zip) {
@@ -9726,24 +8963,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,
-	        postparse: identity,
+	        getFileType: emptyFun,
+	        nullGetter: emptyFun,
+	        optionsTransformer: identity,
+	        postrender: identity,
 	        errorsTransformer: identity,
-	        preResolve: emptyFun,
-	        resolve: emptyFun,
 	        getRenderedMap: identity,
-	        render: emptyFun,
-	        nullGetter: emptyFun,
-	        postrender: identity
+	        preparse: identity,
+	        postparse: identity,
+	        on: emptyFun,
+	        resolve: emptyFun,
+	        preResolve: emptyFun
 	    };
 	    if (Object.keys(defaults).every(function(key) {
 	        return !module1[key];
@@ -10007,7 +9244,25 @@ function requireTraits () {
 	    return false;
 	}
 	function getExpandToDefault(postparsed, pair, expandTags) {
-	    var xmlElements = getListXmlElements(postparsed.slice(pair[0].offset, pair[1].offset));
+	    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 _loop = function _loop() {
 	        var _expandTags$_i = expandTags[_i6], contains = _expandTags$_i.contains, expand = _expandTags$_i.expand, onlyTextInTag = _expandTags$_i.onlyTextInTag;
 	        if (has(contains, xmlElements)) {
@@ -10017,8 +9272,7 @@ function requireTraits () {
 	                if (left === null || right === null) {
 	                    return 0; // continue
 	                }
-	                var subparsed = postparsed.slice(left, right);
-	                var chunks = chunkBy(subparsed, function(p) {
+	                var chunks = chunkBy(postparsed.slice(left, right), function(p) {
 	                    return isTagStart(contains, p) ? "start" : isTagEnd(contains, p) ? "end" : null;
 	                });
 	                var firstChunk = first(chunks);
@@ -10029,33 +9283,6 @@ 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
@@ -10068,50 +9295,8 @@ 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
@@ -10215,10 +9400,10 @@ function requireTraits () {
 	    });
 	    var maxRight = -1;
 	    var offset = 0;
-	    for(var _i1 = 0, _len = limits.length; _i1 < _len; _i1++){
+	    for(var _i7 = 0, _len = limits.length; _i7 < _len; _i7++){
 	        var _postparsed;
-	        var _limit2 = limits[_i1];
-	        maxRight = Math.max(maxRight, _i1 > 0 ? limits[_i1 - 1].right : 0);
+	        var _limit2 = limits[_i7];
+	        maxRight = Math.max(maxRight, _i7 > 0 ? limits[_i7 - 1].right : 0);
 	        if (_limit2.left < maxRight) {
 	            continue;
 	        }
@@ -10458,7 +9643,7 @@ function requireCommon () {
 	                        }
 	                    }
 	                    if (ftCandidate) {
-	                        continue;
+	                        return ftCandidate;
 	                    }
 	                }
 	                return ftCandidate;
@@ -10538,7 +9723,6 @@ 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() {
@@ -10584,24 +9768,11 @@ 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) {
@@ -10631,20 +9802,6 @@ 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() {
@@ -10714,13 +9871,22 @@ 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) {
-	                return _getValueAsync.call(this, tag, meta, this.scopeList.length - 1);
+	                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;
+	                });
 	            }
 	        },
 	        {
@@ -11019,6 +10185,11 @@ function requireLexer () {
 	                    xtag: wordToUtf8(xtag),
 	                    offset: lastDelimiterOffset
 	                }));
+	                lastDelimiterMatch = currDelimiterMatch;
+	                delimiterAcc.push(_objectSpread(_objectSpread({}, currDelimiterMatch), {}, {
+	                    error: true
+	                }));
+	                return delimiterAcc;
 	            }
 	            delimiterAcc.pop();
 	        }
@@ -11061,8 +10232,9 @@ function requireLexer () {
 	                xtag: wordToUtf8(xtag),
 	                offset: lastDelimiterOffset
 	            }));
+	        } else {
+	            delimiterWithErrors.pop();
 	        }
-	        delimiterWithErrors.pop();
 	    }
 	    return {
 	        delimiterWithErrors: delimiterWithErrors,
@@ -11181,35 +10353,28 @@ function requireLexer () {
 	    }
 	}
 	function parseDelimiters(innerContentParts, delimiters, syntaxOptions) {
-	    var full = "";
-	    for(var _i6 = 0; _i6 < innerContentParts.length; _i6++){
-	        var p = innerContentParts[_i6];
-	        full += p.value;
-	    }
+	    var full = innerContentParts.map(function(p) {
+	        return p.value;
+	    }).join("");
 	    var delimiterMatches = getAllDelimiterIndexes(full, delimiters, syntaxOptions);
 	    var offset = 0;
-	    var ranges = [];
-	    for(var _i8 = 0; _i8 < innerContentParts.length; _i8++){
-	        var part = innerContentParts[_i8];
+	    var ranges = innerContentParts.map(function(part) {
 	        offset += part.value.length;
-	        ranges.push({
+	        return {
 	            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 = [];
-	    for(var i = 0; i < ranges.length; i++){
-	        var _p = ranges[i];
-	        var innerContentPart = innerContentParts[i];
-	        var _offset = _p.offset;
+	    var parsed = ranges.map(function(p, i) {
+	        var offset = p.offset;
 	        var range = [
-	            _offset,
-	            _offset + innerContentPart.value.length
+	            offset,
+	            offset + innerContentParts[i].value.length
 	        ];
-	        var partContent = innerContentPart.value;
+	        var partContent = innerContentParts[i].value;
 	        var delimitersInOffset = [];
 	        while(delimiterIndex < delimiterWithErrors.length && inRange(range, delimiterWithErrors[delimiterIndex])){
 	            delimitersInOffset.push(delimiterWithErrors[delimiterIndex]);
@@ -11221,9 +10386,9 @@ function requireLexer () {
 	            cursor = cutNext;
 	            cutNext = 0;
 	        }
-	        for(var _i0 = 0; _i0 < delimitersInOffset.length; _i0++){
-	            var delimiterInOffset = delimitersInOffset[_i0];
-	            var _value = partContent.substr(cursor, delimiterInOffset.offset - _offset - cursor);
+	        for(var _i6 = 0; _i6 < delimitersInOffset.length; _i6++){
+	            var delimiterInOffset = delimitersInOffset[_i6];
+	            var _value = partContent.substr(cursor, delimiterInOffset.offset - offset - cursor);
 	            if (delimiterInOffset.changedelimiter) {
 	                if (delimiterInOffset.position === "start") {
 	                    if (_value.length > 0) {
@@ -11233,7 +10398,7 @@ function requireLexer () {
 	                        });
 	                    }
 	                } else {
-	                    cursor = delimiterInOffset.offset - _offset + delimiterInOffset.length;
+	                    cursor = delimiterInOffset.offset - offset + delimiterInOffset.length;
 	                }
 	                continue;
 	            }
@@ -11247,10 +10412,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);
@@ -11260,8 +10425,8 @@ function requireLexer () {
 	                value: value
 	            });
 	        }
-	        parsed.push(parts);
-	    }
+	        return parts;
+	    }, this);
 	    return {
 	        parsed: parsed,
 	        errors: errors
@@ -11277,8 +10442,8 @@ function requireLexer () {
 	}
 	function decodeContentParts(xmlparsed, fileType) {
 	    var inTextTag = false;
-	    for(var _i10 = 0; _i10 < xmlparsed.length; _i10++){
-	        var part = xmlparsed[_i10];
+	    for(var _i8 = 0; _i8 < xmlparsed.length; _i8++){
+	        var part = xmlparsed[_i8];
 	        inTextTag = updateInTextTag(part, inTextTag);
 	        if (part.type === "content") {
 	            part.position = inTextTag ? "insidetag" : "outsidetag";
@@ -11296,11 +10461,11 @@ function requireLexer () {
 	        var lexed = [];
 	        var index = 0;
 	        var lIndex = 0;
-	        for(var _i12 = 0; _i12 < xmllexed.length; _i12++){
-	            var part = xmllexed[_i12];
+	        for(var _i0 = 0; _i0 < xmllexed.length; _i0++){
+	            var part = xmllexed[_i0];
 	            if (isInsideContent(part)) {
-	                for(var _i14 = 0, _delimiterParsed$inde2 = delimiterParsed[index]; _i14 < _delimiterParsed$inde2.length; _i14++){
-	                    var p = _delimiterParsed$inde2[_i14];
+	                for(var _i10 = 0, _delimiterParsed$inde2 = delimiterParsed[index]; _i10 < _delimiterParsed$inde2.length; _i10++){
+	                    var p = _delimiterParsed$inde2[_i10];
 	                    if (p.type === "content") {
 	                        p.position = "insidetag";
 	                    }
@@ -11322,8 +10487,8 @@ function requireLexer () {
 	        var matches = tagMatcher(content, xmltags.text, xmltags.other);
 	        var cursor = 0;
 	        var parsed = [];
-	        for(var _i16 = 0; _i16 < matches.length; _i16++){
-	            var match = matches[_i16];
+	        for(var _i12 = 0; _i12 < matches.length; _i12++){
+	            var match = matches[_i12];
 	            if (content.length > cursor && match.offset - cursor > 0) {
 	                parsed.push({
 	                    type: "content",
@@ -11722,7 +10887,7 @@ function requireParser () {
 	function _arrayWithHoles(r) {
 	    if (Array.isArray(r)) return r;
 	}
-	var _require = docUtils, wordToUtf8 = _require.wordToUtf8, pushArray = _require.pushArray, isParagraphStart = _require.isParagraphStart, isBreakTag = _require.isBreakTag;
+	var _require = docUtils, wordToUtf8 = _require.wordToUtf8, pushArray = _require.pushArray;
 	var _require2 = requirePrefixMatcher(), match = _require2.match, getValue = _require2.getValue, getValues = _require2.getValues;
 	function getMatchers(modules, options) {
 	    var allMatchers = [];
@@ -11857,9 +11022,6 @@ 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;
 	                }
@@ -11871,20 +11033,17 @@ function requireParser () {
 	        }, []);
 	    },
 	    postparse: function postparse(postparsed, modules, options) {
-	        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;
+	        function getTraits(traitName, postparsed) {
+	            return modules.map(function(module1) {
+	                return module1.getTraits(traitName, postparsed);
+	            });
 	        }
 	        var errors = [];
 	        function _postparse(postparsed, options) {
 	            var newPostparsed = postparsed;
-	            for(var _i12 = 0; _i12 < modules.length; _i12++){
-	                var _module6 = modules[_i12];
-	                var postparseResult = _module6.postparse(newPostparsed, _objectSpread(_objectSpread({}, options), {}, {
+	            for(var _i10 = 0; _i10 < modules.length; _i10++){
+	                var _module5 = modules[_i10];
+	                var postparseResult = _module5.postparse(newPostparsed, _objectSpread(_objectSpread({}, options), {}, {
 	                    postparse: function postparse(parsed, opts) {
 	                        return _postparse(parsed, _objectSpread(_objectSpread({}, options), opts));
 	                    },
@@ -12194,99 +11353,58 @@ 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 scopeManager = options.scopeManager;
+	    var compiled = options.compiled, scopeManager = options.scopeManager;
 	    options.nullGetter = function(part, sm) {
 	        return baseNullGetter(part, sm || scopeManager);
 	    };
 	    options.resolved = resolved;
-	    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 ([
+	    var errors = [];
+	    return Promise.all(compiled.filter(function(part) {
+	        return [
 	            "content",
 	            "tag"
-	        ].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);
+	        ].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;
+	            });
+	        } else {
+	            return;
 	        }
-	    };
-	    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() {
+	        promises.push(result["catch"](function(e) {
+	            if (_instanceof(e, Array)) {
+	                pushArray(errors, e);
+	            } else {
+	                errors.push(e);
+	            }
+	        }));
+	        return promises;
+	    }, [])).then(function() {
 	        return {
 	            errors: errors,
 	            resolved: resolved
@@ -12461,11 +11579,9 @@ function requireXmlTemplater () {
 	var joinUncorrupt = requireJoinUncorrupt();
 	function _getFullText(content, tagsXmlArray) {
 	    var matcher = xmlMatcher(content, tagsXmlArray);
-	    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]);
-	    }
+	    var result = matcher.matches.map(function(match) {
+	        return match.array[2];
+	    });
 	    return wordToUtf8(convertSpaces(result.join("")));
 	}
 	xmlTemplater = /*#__PURE__*/ function() {
@@ -12493,22 +11609,18 @@ function requireXmlTemplater () {
 	                options.scopeManager = this.scopeManager;
 	                options.resolve = resolve;
 	                var errors = [];
-	                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) {
+	                return Promise.all(this.modules.map(function(module1) {
+	                    return Promise.resolve(module1.preResolve(options))["catch"](function(e) {
 	                        errors.push(e);
-	                    }));
-	                }
-	                return Promise.all(promises).then(function() {
+	                    });
+	                })).then(function() {
 	                    if (errors.length !== 0) {
 	                        throw errors;
 	                    }
 	                    return resolve(options).then(function(_ref) {
 	                        var resolved = _ref.resolved, errors = _ref.errors;
-	                        for(var i = 0; i < errors.length; i++){
+	                        errors = errors.map(function(error) {
 	                            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);
@@ -12519,8 +11631,8 @@ function requireXmlTemplater () {
 	             * thrown.
 	             */ (_error = error).properties || (_error.properties = {});
 	                            error.properties.file = filePath;
-	                            errors[i] = error;
-	                        }
+	                            return error;
+	                        });
 	                        if (errors.length !== 0) {
 	                            throw errors;
 	                        }
@@ -12551,9 +11663,9 @@ function requireXmlTemplater () {
 	        {
 	            key: "setModules",
 	            value: function setModules(obj) {
-	                for(var _i6 = 0, _this$modules4 = this.modules; _i6 < _this$modules4.length; _i6++){
-	                    var _module2 = _this$modules4[_i6];
-	                    _module2.set(obj);
+	                for(var _i2 = 0, _this$modules2 = this.modules; _i2 < _this$modules2.length; _i2++){
+	                    var _module = _this$modules2[_i2];
+	                    _module.set(obj);
 	                }
 	            }
 	        },
@@ -12628,8 +11740,8 @@ function requireXmlTemplater () {
 	        {
 	            key: "errorChecker",
 	            value: function errorChecker(errors) {
-	                for(var _i8 = 0, _errors2 = errors; _i8 < _errors2.length; _i8++){
-	                    var error = _errors2[_i8];
+	                for(var _i4 = 0, _errors2 = errors; _i4 < _errors2.length; _i4++){
+	                    var error = _errors2[_i4];
 	                    /*
 	         * error properties might not be defined if some foreign
 	         * (unhandled error not thrown by docxtemplater willingly) is
@@ -12637,9 +11749,9 @@ function requireXmlTemplater () {
 	         */ error.properties || (error.properties = {});
 	                    error.properties.file = this.filePath;
 	                }
-	                for(var _i0 = 0, _this$modules6 = this.modules; _i0 < _this$modules6.length; _i0++){
-	                    var _module3 = _this$modules6[_i0];
-	                    errors = _module3.errorsTransformer(errors);
+	                for(var _i6 = 0, _this$modules4 = this.modules; _i6 < _this$modules4.length; _i6++){
+	                    var _module2 = _this$modules4[_i6];
+	                    errors = _module2.errorsTransformer(errors);
 	                }
 	            }
 	        },
@@ -12647,12 +11759,12 @@ function requireXmlTemplater () {
 	            key: "baseNullGetter",
 	            value: function baseNullGetter(part, sm) {
 	                var value = null;
-	                for(var _i10 = 0, _this$modules8 = this.modules; _i10 < _this$modules8.length; _i10++){
-	                    var _module4 = _this$modules8[_i10];
+	                for(var _i8 = 0, _this$modules6 = this.modules; _i8 < _this$modules6.length; _i8++){
+	                    var _module3 = _this$modules6[_i8];
 	                    if (value != null) {
 	                        continue;
 	                    }
-	                    value = _module4.nullGetter(part, sm, this);
+	                    value = _module3.nullGetter(part, sm, this);
 	                }
 	                if (value != null) {
 	                    return value;
@@ -12673,7 +11785,6 @@ 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,
@@ -12831,20 +11942,15 @@ 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) {
-	    for(var _i2 = 0; _i2 < parts.length; _i2++){
-	        var part = parts[_i2];
-	        if (isContent(part)) {
-	            return true;
-	        }
-	    }
-	    return false;
+	    return parts.some(function(part) {
+	        return isContent(part);
+	    });
 	}
 	function getFirstMeaningFulPart(parsed) {
-	    for(var _i4 = 0; _i4 < parsed.length; _i4++){
-	        var part = parsed[_i4];
+	    for(var _i2 = 0; _i2 < parsed.length; _i2++){
+	        var part = parsed[_i2];
 	        if (part.type !== "content") {
 	            return part;
 	        }
@@ -12876,94 +11982,74 @@ function requireLoop () {
 	    subRendered.parts.unshift('<w:p><w:r><w:br w:type="page"/></w:r></w:p>');
 	}
 	function isContinuous(parts) {
-	    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;
+	    return parts.some(function(part) {
+	        return isTagStart("w:type", part) && part.value.indexOf("continuous") !== -1;
+	    });
 	}
 	function isNextPage(parts) {
-	    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;
+	    return parts.some(function(part) {
+	        return isTagStart("w:type", part) && part.value.indexOf('w:val="nextPage"') !== -1;
+	    });
 	}
 	function addSectionBefore(parts, sect) {
-	    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>"));
+	    return pushArray([
+	        "<w:p><w:pPr>".concat(sect.map(function(_ref) {
+	            var value = _ref.value;
+	            return value;
+	        }).join(""), "</w:pPr></w:p>")
+	    ], parts);
 	}
 	function addContinuousType(parts) {
 	    var stop = false;
 	    var inSectPr = false;
-	    for(var i = 0; i < parts.length; i++){
-	        var part = parts[i];
-	        if (!stop && startsWith(part, "<w:sectPr")) {
+	    var result = [];
+	    for(var _i4 = 0; _i4 < parts.length; _i4++){
+	        var part = parts[_i4];
+	        if (stop === false && startsWith(part, "<w:sectPr")) {
 	            inSectPr = true;
 	        }
 	        if (inSectPr) {
 	            if (startsWith(part, "<w:type")) {
 	                stop = true;
 	            }
-	            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
+	            if (stop === false && startsWith(part, "</w:sectPr")) {
+	                result.push('<w:type w:val="continuous"/>');
 	            }
 	        }
+	        result.push(part);
 	    }
-	    return parts;
+	    return result;
 	}
 	function dropHeaderFooterRefs(parts) {
-	    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;
+	    return parts.filter(function(text) {
+	        return !startsWith(text, "<w:headerReference") && !startsWith(text, "<w:footerReference");
+	    });
 	}
 	function hasPageBreak(chunk) {
-	    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;
+	    return chunk.some(function(part) {
+	        return part.tag === "w:br" && part.value.indexOf('w:type="page"') !== -1;
+	    });
 	}
 	function hasImage(chunk) {
-	    for(var _i12 = 0; _i12 < chunk.length; _i12++){
-	        var el = chunk[_i12];
-	        if (el.tag === "w:drawing") {
-	            return true;
-	        }
-	    }
-	    return false;
+	    return chunk.some(function(_ref2) {
+	        var tag = _ref2.tag;
+	        return tag === "w:drawing";
+	    });
 	}
 	function getSectPr(chunks) {
+	    var collectSectPr = false;
 	    var sectPrs = [];
-	    var currentSectPr = null;
-	    for(var _i14 = 0; _i14 < chunks.length; _i14++){
-	        var part = chunks[_i14];
+	    for(var _i6 = 0; _i6 < chunks.length; _i6++){
+	        var part = chunks[_i6];
 	        if (isTagStart("w:sectPr", part)) {
-	            currentSectPr = [];
-	            sectPrs.push(currentSectPr);
+	            sectPrs.push([]);
+	            collectSectPr = true;
 	        }
-	        if (currentSectPr !== null) {
-	            currentSectPr.push(part);
+	        if (collectSectPr) {
+	            sectPrs[sectPrs.length - 1].push(part);
 	        }
 	        if (isTagEnd("w:sectPr", part)) {
-	            currentSectPr = null;
+	            collectSectPr = false;
 	        }
 	    }
 	    return sectPrs;
@@ -12971,8 +12057,8 @@ function requireLoop () {
 	function getSectPrHeaderFooterChangeCount(chunks) {
 	    var collectSectPr = false;
 	    var sectPrCount = 0;
-	    for(var _i16 = 0; _i16 < chunks.length; _i16++){
-	        var part = chunks[_i16];
+	    for(var _i8 = 0; _i8 < chunks.length; _i8++){
+	        var part = chunks[_i8];
 	        if (isTagStart("w:sectPr", part)) {
 	            collectSectPr = true;
 	        }
@@ -12993,11 +12079,7 @@ function requireLoop () {
 	    var inSectPr = false;
 	    for(var i = parsed.length - 1; i >= 0; i--){
 	        var part = parsed[i];
-	        /*
-	     * 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)) {
+	        if (isTagEnd("w:sectPr", part)) {
 	            inSectPr = true;
 	        }
 	        if (isTagStart("w:sectPr", part)) {
@@ -13039,8 +12121,8 @@ function requireLoop () {
 	        },
 	        {
 	            key: "preparse",
-	            value: function preparse(parsed, _ref) {
-	                var contentType = _ref.contentType;
+	            value: function preparse(parsed, _ref3) {
+	                var contentType = _ref3.contentType;
 	                if (filetypes.main.indexOf(contentType) !== -1) {
 	                    this.sects = getSectPr(parsed);
 	                }
@@ -13079,8 +12161,8 @@ function requireLoop () {
 	                    [
 	                        this.prefix.dash,
 	                        _$module,
-	                        function(_ref2) {
-	                            var _ref3 = _slicedToArray(_ref2, 3), expandTo = _ref3[1], value = _ref3[2];
+	                        function(_ref4) {
+	                            var _ref5 = _slicedToArray(_ref4, 3), expandTo = _ref5[1], value = _ref5[2];
 	                            return {
 	                                location: "start",
 	                                inverted: false,
@@ -13115,19 +12197,18 @@ function requireLoop () {
 	        },
 	        {
 	            key: "postparse",
-	            value: function postparse(parsed, _ref4) {
-	                var basePart = _ref4.basePart;
+	            value: function postparse(parsed, _ref6) {
+	                var basePart = _ref6.basePart;
 	                if (basePart && this.docxtemplater.fileType === "docx" && parsed.length > 0) {
 	                    basePart.sectPrCount = getSectPrHeaderFooterChangeCount(parsed);
 	                    this.totalSectPr += basePart.sectPrCount;
 	                    var sects = this.sects;
-	                    for(var index = 0, len = sects.length; index < len; index++){
-	                        var sect = sects[index];
+	                    sects.some(function(sect, index) {
 	                        if (basePart.lIndex < sect[0].lIndex) {
 	                            if (index + 1 < sects.length && isContinuous(sects[index + 1])) {
 	                                basePart.addContinuousType = true;
 	                            }
-	                            break;
+	                            return true;
 	                        }
 	                        if (parsed[0].lIndex < sect[0].lIndex && sect[0].lIndex < basePart.lIndex) {
 	                            if (isNextPage(sects[index])) {
@@ -13135,9 +12216,9 @@ function requireLoop () {
 	                                    index: index
 	                                };
 	                            }
-	                            break;
+	                            return true;
 	                        }
-	                    }
+	                    });
 	                    basePart.lastParagrapSectPr = getLastSectPr(parsed);
 	                }
 	                if (!basePart || basePart.expandTo !== "auto" || basePart.module !== moduleName || !isEnclosedByParagraphs(parsed)) {
@@ -13164,12 +12245,6 @@ 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)) {
@@ -13184,7 +12259,6 @@ function requireLoop () {
 	        {
 	            key: "resolve",
 	            value: function resolve(part, options) {
-	                var self = this;
 	                if (!isModule(part, moduleName)) {
 	                    return null;
 	                }
@@ -13193,59 +12267,46 @@ 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);
-	                    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
-	                        })));
-	                    }
+	                    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);
-	                    if (_instanceof(values, Promise)) {
-	                        return values.then(function(values) {
-	                            if (_instanceof(values, Array)) {
-	                                return Promise.all(values);
-	                            }
-	                            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 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);
+	                                }
+	                            });
 	                        }
-	                        return result;
-	                    }).then(function(value) {
-	                        if (errorList.length > 0) {
-	                            throw errorList;
+	                        if (_instanceof(values, Array)) {
+	                            Promise.all(values).then(resolve);
+	                        } else {
+	                            resolve(values);
 	                        }
-	                        return value;
+	                    }).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;
+	                            }
+	                            return value;
+	                        });
 	                    });
 	                });
 	            }
@@ -13253,12 +12314,11 @@ function requireLoop () {
 	        {
 	            key: "render",
 	            value: function render(part, options) {
-	                var self = this;
 	                if (part.tag === "p:xfrm") {
-	                    self.inXfrm = part.position === "start";
+	                    this.inXfrm = part.position === "start";
 	                }
-	                if (part.tag === "a:ext" && self.inXfrm) {
-	                    self.lastExt = part;
+	                if (part.tag === "a:ext" && this.inXfrm) {
+	                    this.lastExt = part;
 	                    return part;
 	                }
 	                if (!isModule(part, moduleName)) {
@@ -13267,6 +12327,7 @@ 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") {
@@ -13278,8 +12339,8 @@ function requireLoop () {
 	                function loopOver(scope, i, length) {
 	                    heightOffset += tagHeight;
 	                    var scopeManager = options.scopeManager.createSubScopeManager(scope, part.value, i, part, length);
-	                    for(var _i20 = 0, _part$subparsed2 = part.subparsed; _i20 < _part$subparsed2.length; _i20++){
-	                        var pp = _part$subparsed2[_i20];
+	                    for(var _i0 = 0, _part$subparsed2 = part.subparsed; _i0 < _part$subparsed2.length; _i0++){
+	                        var pp = _part$subparsed2[_i0];
 	                        if (isTagStart("a16:rowId", pp)) {
 	                            var val = +getSingleAttribute(pp.value, "val") + a16RowIdOffset;
 	                            a16RowIdOffset = 1;
@@ -13305,7 +12366,7 @@ function requireLoop () {
 	                            subRendered.parts = addContinuousType(subRendered.parts);
 	                        }
 	                    } else if (part.addNextPage) {
-	                        addSectionBefore(subRendered.parts, self.sects[part.addNextPage.index]);
+	                        subRendered.parts = addSectionBefore(subRendered.parts, self.sects[part.addNextPage.index]);
 	                    }
 	                    if (part.addNextPage) {
 	                        addPageBreakAtEnd(subRendered);
@@ -13313,8 +12374,8 @@ function requireLoop () {
 	                    if (part.hasPageBreakBeginning && insideParagraphLoop) {
 	                        addPageBreakAtBeginning(subRendered);
 	                    }
-	                    for(var _i22 = 0, _subRendered$parts2 = subRendered.parts; _i22 < _subRendered$parts2.length; _i22++){
-	                        var _val = _subRendered$parts2[_i22];
+	                    for(var _i10 = 0, _subRendered$parts2 = subRendered.parts; _i10 < _subRendered$parts2.length; _i10++){
+	                        var _val = _subRendered$parts2[_i10];
 	                        totalValue.push(_val);
 	                    }
 	                    pushArray(errors, subRendered.errors);
@@ -13342,11 +12403,11 @@ function requireLoop () {
 	                    };
 	                }
 	                if (heightOffset !== 0) {
-	                    var cy = +getSingleAttribute(self.lastExt.value, "cy");
+	                    var cy = +getSingleAttribute(this.lastExt.value, "cy");
 	                    /*
 	         * We do edit the value of a previous result here
 	         * #edit-value-backwards
-	         */ self.lastExt.value = setSingleAttribute(self.lastExt.value, "cy", cy + heightOffset);
+	         */ this.lastExt.value = setSingleAttribute(this.lastExt.value, "cy", cy + heightOffset);
 	                }
 	                return {
 	                    value: options.joinUncorrupt(totalValue, _objectSpread(_objectSpread({}, options), {}, {
@@ -13562,7 +12623,7 @@ function requireRawxml () {
 	    return (String )(t);
 	}
 	var traits = requireTraits();
-	var _require = docUtils, isContent = _require.isContent, getPartWithDelimiters = _require.getPartWithDelimiters;
+	var _require = docUtils, isContent = _require.isContent;
 	var _require2 = requireErrors(), throwRawTagShouldBeOnlyTextInParagraph = _require2.throwRawTagShouldBeOnlyTextInParagraph, getInvalidRawXMLValueException = _require2.getInvalidRawXMLValueException;
 	var wrapper = requireModuleWrapper();
 	var moduleName = "rawxml";
@@ -13611,7 +12672,6 @@ function requireRawxml () {
 	        {
 	            key: "postparse",
 	            value: function postparse(postparsed) {
-	                var _this = this;
 	                return traits.expandToOne(postparsed, {
 	                    moduleName: moduleName,
 	                    getInner: getInner,
@@ -13620,7 +12680,7 @@ function requireRawxml () {
 	                        message: "Raw tag not in paragraph",
 	                        id: "raw_tag_outerxml_invalid",
 	                        explanation: function explanation(part) {
-	                            return "The tag \"".concat(getPartWithDelimiters(part, _this.docxtemplater), "\" is not inside a paragraph, putting raw tags inside an inline loop is disallowed.");
+	                            return "The tag \"".concat(part.value, "\" is not inside a paragraph, putting raw tags inside an inline loop is disallowed.");
 	                        }
 	                    }
 	                });
@@ -13656,8 +12716,6 @@ function requireRawxml () {
 	                        getInvalidRawXMLValueException({
 	                            tag: part.value,
 	                            value: value,
-	                            partDelims: getPartWithDelimiters(part, this.docxtemplater),
-	                            part: part,
 	                            offset: part.offset
 	                        })
 	                    ]
@@ -13910,10 +12968,10 @@ function requireExpandPairTrait () {
 	        },
 	        {
 	            key: "postparse",
-	            value: function postparse(postparsed, options) {
+	            value: function postparse(postparsed, _ref) {
 	                var _this = this;
-	                var getTraits = options.getTraits, postparse = options.postparse, fileType = options.fileType;
-	                var traits = getTraits(traitName, postparsed, options);
+	                var getTraits = _ref.getTraits, _postparse = _ref.postparse, fileType = _ref.fileType;
+	                var traits = getTraits(traitName, postparsed);
 	                traits = traits.map(function(trait) {
 	                    return trait || [];
 	                });
@@ -13994,7 +13052,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;
@@ -14100,6 +13158,17 @@ 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) {
@@ -14112,14 +13181,15 @@ function requireRender () {
 	            }
 	        },
 	        {
-	            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: "getRenderedMap",
+	            value: function getRenderedMap(mapper) {
+	                for(var from in this.compiled){
+	                    mapper[from] = {
+	                        from: from,
+	                        data: this.data
+	                    };
+	                }
+	                return mapper;
 	            }
 	        },
 	        {
@@ -14149,18 +13219,6 @@ 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) {
@@ -14274,9 +13332,6 @@ function requireFileTypeConfig () {
 	        getTemplatedFiles: function getTemplatedFiles() {
 	            return [];
 	        },
-	        templatedNs: [
-	            "http://schemas.microsoft.com/office/2006/coverPageProps"
-	        ],
 	        textPath: function textPath(doc) {
 	            return doc.textTarget;
 	        },
@@ -14291,12 +13346,6 @@ function requireFileTypeConfig () {
 	            "dc:subject",
 	            "dc:title",
 	            "cp:contentStatus",
-	            "PublishDate",
-	            "Abstract",
-	            "CompanyAddress",
-	            "CompanyPhone",
-	            "CompanyFax",
-	            "CompanyEmail",
 	            "w:t",
 	            "a:t",
 	            "m:t",
@@ -14650,8 +13699,7 @@ function requireFileTypeConfig () {
 	    linebreaks: z["boolean"]().optional(),
 	    nullGetter: z["function"]().optional(),
 	    syntax: dxtSyntaxSchema.optional(),
-	    stripInvalidXMLChars: z["boolean"]().optional(),
-	    warnFn: z["function"]().optional()
+	    stripInvalidXMLChars: z["boolean"]().optional()
 	}).strict();
 	var _require = requireGetRelationTypes(), getRelsTypes = _require.getRelsTypes;
 	var _require2 = requireGetContentTypes(), collectContentTypes = _require2.collectContentTypes, getContentTypes = _require2.getContentTypes;
@@ -14677,24 +13725,22 @@ function requireFileTypeConfig () {
 	    2
 	];
 	function throwIfDuplicateModules(modules) {
-	    var names = [];
-	    for(var _i2 = 0; _i2 < modules.length; _i2++){
-	        var mod = modules[_i2];
-	        names.push(mod.name);
-	    }
-	    var duplicates = getDuplicates(names);
+	    var duplicates = getDuplicates(modules.map(function(_ref) {
+	        var name = _ref.name;
+	        return name;
+	    }));
 	    if (duplicates.length > 0) {
 	        throw new XTInternalError("Detected duplicate module \"".concat(duplicates[0], "\""));
 	    }
 	}
 	function addXmlFileNamesFromXmlContentType(doc) {
-	    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];
+	    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];
 	            var candidates = doc.invertedContentTypes[contentType] || [];
-	            for(var _i8 = 0; _i8 < candidates.length; _i8++){
-	                var candidate = candidates[_i8];
+	            for(var _i6 = 0; _i6 < candidates.length; _i6++){
+	                var candidate = candidates[_i6];
 	                if (doc.zip.files[candidate]) {
 	                    doc.options.xmlFileNames.push(candidate);
 	                }
@@ -14747,10 +13793,10 @@ function requireFileTypeConfig () {
 	        "xl/",
 	        "ppt/"
 	    ];
-	    for(var _i0 = 0; _i0 < allFiles.length; _i0++){
-	        var _name = allFiles[_i0];
-	        for(var _i10 = 0; _i10 < prefixes.length; _i10++){
-	            var prefix = prefixes[_i10];
+	    for(var _i8 = 0; _i8 < allFiles.length; _i8++){
+	        var _name = allFiles[_i8];
+	        for(var _i0 = 0; _i0 < prefixes.length; _i0++){
+	            var prefix = prefixes[_i0];
 	            if (_name.indexOf("".concat(prefix)) === 0) {
 	                resultFiles.push(_name);
 	            }
@@ -14758,8 +13804,8 @@ function requireFileTypeConfig () {
 	    }
 	    /*
 	   * Push the rest of files, such as docProps/core.xml and docProps/app.xml
-	   */ for(var _i12 = 0; _i12 < allFiles.length; _i12++){
-	        var _name2 = allFiles[_i12];
+	   */ for(var _i10 = 0; _i10 < allFiles.length; _i10++){
+	        var _name2 = allFiles[_i10];
 	        if (resultFiles.indexOf(_name2) === -1) {
 	            resultFiles.push(_name2);
 	        }
@@ -14811,7 +13857,7 @@ function requireFileTypeConfig () {
 	}
 	var Docxtemplater = /*#__PURE__*/ function() {
 	    function Docxtemplater(zip) {
-	        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);
+	        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);
 	        _classCallCheck(this, Docxtemplater);
 	        this.targets = [];
 	        this.rendered = false;
@@ -14837,8 +13883,8 @@ function requireFileTypeConfig () {
 	            if (!Array.isArray(modules)) {
 	                throw new Error("The modules argument of docxtemplater's constructor must be an array");
 	            }
-	            for(var _i14 = 0; _i14 < modules.length; _i14++){
-	                var _module2 = modules[_i14];
+	            for(var _i12 = 0; _i12 < modules.length; _i12++){
+	                var _module2 = modules[_i12];
 	                this.attachModule(_module2);
 	            }
 	            this.loadZip(zip);
@@ -14851,10 +13897,9 @@ function requireFileTypeConfig () {
 	        {
 	            key: "verifyApiVersion",
 	            value: function verifyApiVersion(neededVersion) {
-	                neededVersion = neededVersion.split(".");
-	                for(var i = 0; i < neededVersion.length; i++){
-	                    neededVersion[i] = parseInt(neededVersion[i], 10);
-	                }
+	                neededVersion = neededVersion.split(".").map(function(i) {
+	                    return parseInt(i, 10);
+	                });
 	                if (neededVersion.length !== 3) {
 	                    throwApiVersionError("neededVersion is not a valid version", {
 	                        neededVersion: neededVersion,
@@ -14888,8 +13933,8 @@ function requireFileTypeConfig () {
 	        {
 	            key: "setModules",
 	            value: function setModules(obj) {
-	                for(var _i16 = 0, _this$modules2 = this.modules; _i16 < _this$modules2.length; _i16++){
-	                    var _module3 = _this$modules2[_i16];
+	                for(var _i14 = 0, _this$modules2 = this.modules; _i14 < _this$modules2.length; _i14++){
+	                    var _module3 = _this$modules2[_i14];
 	                    _module3.set(obj);
 	                }
 	            }
@@ -14897,8 +13942,8 @@ function requireFileTypeConfig () {
 	        {
 	            key: "sendEvent",
 	            value: function sendEvent(eventName) {
-	                for(var _i18 = 0, _this$modules4 = this.modules; _i18 < _this$modules4.length; _i18++){
-	                    var _module4 = _this$modules4[_i18];
+	                for(var _i16 = 0, _this$modules4 = this.modules; _i16 < _this$modules4.length; _i16++){
+	                    var _module4 = _this$modules4[_i16];
 	                    _module4.on(eventName);
 	                }
 	            }
@@ -14940,8 +13985,8 @@ function requireFileTypeConfig () {
 	        {
 	            key: "findModule",
 	            value: function findModule(name) {
-	                for(var _i20 = 0, _this$modules6 = this.modules; _i20 < _this$modules6.length; _i20++){
-	                    var _module5 = _this$modules6[_i20];
+	                for(var _i18 = 0, _this$modules6 = this.modules; _i18 < _this$modules6.length; _i18++){
+	                    var _module5 = _this$modules6[_i18];
 	                    if (_module5.name === name) {
 	                        return _module5;
 	                    }
@@ -14985,11 +14030,6 @@ 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([
@@ -14998,8 +14038,8 @@ function requireFileTypeConfig () {
 	                    }),
 	                    this.modules
 	                ]);
-	                for(var _i22 = 0, _this$modules8 = this.modules; _i22 < _this$modules8.length; _i22++){
-	                    var _module6 = _this$modules8[_i22];
+	                for(var _i20 = 0, _this$modules8 = this.modules; _i20 < _this$modules8.length; _i20++){
+	                    var _module6 = _this$modules8[_i20];
 	                    _module6.zip = this.zip;
 	                    _module6.docxtemplater = this;
 	                    _module6.fileTypeConfig = this.fileTypeConfig;
@@ -15055,11 +14095,9 @@ function requireFileTypeConfig () {
 	                    _this.mapper = _this.modules.reduce(function(value, module1) {
 	                        return module1.getRenderedMap(value);
 	                    }, {});
-	                    var promises = [];
-	                    var _loop = function _loop() {
-	                        var to = _Object$keys2[_i24];
+	                    return Promise.all(Object.keys(_this.mapper).map(function(to) {
 	                        var _this$mapper$to = _this.mapper[to], from = _this$mapper$to.from, _$data = _this$mapper$to.data;
-	                        promises.push(Promise.resolve(_$data).then(function(data) {
+	                        return Promise.resolve(_$data).then(function(data) {
 	                            var currentFile = _this.compiled[from];
 	                            currentFile.filePath = to;
 	                            currentFile.scopeManager = _this.getScopeManager(to, currentFile, data);
@@ -15069,12 +14107,8 @@ function requireFileTypeConfig () {
 	                            }, function(errs) {
 	                                pushArray(errors, errs);
 	                            });
-	                        }));
-	                    };
-	                    for(var _i24 = 0, _Object$keys2 = Object.keys(_this.mapper); _i24 < _Object$keys2.length; _i24++){
-	                        _loop();
-	                    }
-	                    return Promise.all(promises).then(function(resolved) {
+	                        });
+	                    })).then(function(resolved) {
 	                        if (errors.length !== 0) {
 	                            if (_this.options.errorLogging) {
 	                                logErrors(errors, _this.options.errorLogging);
@@ -15097,14 +14131,14 @@ function requireFileTypeConfig () {
 	                    return this;
 	                }
 	                var options = this.options;
-	                for(var _i26 = 0, _this$modules0 = this.modules; _i26 < _this$modules0.length; _i26++){
-	                    var _module7 = _this$modules0[_i26];
+	                for(var _i22 = 0, _this$modules0 = this.modules; _i22 < _this$modules0.length; _i22++){
+	                    var _module7 = _this$modules0[_i22];
 	                    options = _module7.optionsTransformer(options, this);
 	                }
 	                this.options = options;
 	                this.options.xmlFileNames = uniq(this.options.xmlFileNames);
-	                for(var _i28 = 0, _this$options$xmlFile2 = this.options.xmlFileNames; _i28 < _this$options$xmlFile2.length; _i28++){
-	                    var fileName = _this$options$xmlFile2[_i28];
+	                for(var _i24 = 0, _this$options$xmlFile2 = this.options.xmlFileNames; _i24 < _this$options$xmlFile2.length; _i24++){
+	                    var fileName = _this$options$xmlFile2[_i24];
 	                    var content = this.zip.files[fileName].asText();
 	                    this.xmlDocuments[fileName] = str2xml(content);
 	                }
@@ -15112,8 +14146,8 @@ function requireFileTypeConfig () {
 	                    zip: this.zip,
 	                    xmlDocuments: this.xmlDocuments
 	                });
-	                for(var _i30 = 0, _this$modules10 = this.modules; _i30 < _this$modules10.length; _i30++){
-	                    var _module8 = _this$modules10[_i30];
+	                for(var _i26 = 0, _this$modules10 = this.modules; _i26 < _this$modules10.length; _i26++){
+	                    var _module8 = _this$modules10[_i26];
 	                    _module8.xmlDocuments = this.xmlDocuments;
 	                }
 	                this.getTemplatedFiles();
@@ -15121,15 +14155,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 _i32 = 0, _this$templatedFiles2 = this.templatedFiles; _i32 < _this$templatedFiles2.length; _i32++){
-	                    var _fileName = _this$templatedFiles2[_i32];
+	                for(var _i28 = 0, _this$templatedFiles2 = this.templatedFiles; _i28 < _this$templatedFiles2.length; _i28++){
+	                    var _fileName = _this$templatedFiles2[_i28];
 	                    if (this.zip.files[_fileName] != null) {
 	                        this.precompileFile(_fileName);
 	                    }
 	                }
 	                this.sendEvent("after-preparse");
-	                for(var _i34 = 0, _this$templatedFiles4 = this.templatedFiles; _i34 < _this$templatedFiles4.length; _i34++){
-	                    var _fileName2 = _this$templatedFiles4[_i34];
+	                for(var _i30 = 0, _this$templatedFiles4 = this.templatedFiles; _i30 < _this$templatedFiles4.length; _i30++){
+	                    var _fileName2 = _this$templatedFiles4[_i30];
 	                    if (this.zip.files[_fileName2] != null) {
 	                        this.compiled[_fileName2].parse({
 	                            noPostParse: true
@@ -15137,8 +14171,8 @@ function requireFileTypeConfig () {
 	                    }
 	                }
 	                this.sendEvent("after-parse");
-	                for(var _i36 = 0, _this$templatedFiles6 = this.templatedFiles; _i36 < _this$templatedFiles6.length; _i36++){
-	                    var _fileName3 = _this$templatedFiles6[_i36];
+	                for(var _i32 = 0, _this$templatedFiles6 = this.templatedFiles; _i32 < _this$templatedFiles6.length; _i32++){
+	                    var _fileName3 = _this$templatedFiles6[_i32];
 	                    if (this.zip.files[_fileName3] != null) {
 	                        this.compiled[_fileName3].postparse();
 	                    }
@@ -15168,8 +14202,8 @@ function requireFileTypeConfig () {
 	                if (this.zip.files.mimetype) {
 	                    fileType = "odt";
 	                }
-	                for(var _i38 = 0, _this$modules12 = this.modules; _i38 < _this$modules12.length; _i38++){
-	                    var _module9 = _this$modules12[_i38];
+	                for(var _i34 = 0, _this$modules12 = this.modules; _i34 < _this$modules12.length; _i34++){
+	                    var _module9 = _this$modules12[_i34];
 	                    fileType = _module9.getFileType({
 	                        zip: this.zip,
 	                        contentTypes: contentTypes,
@@ -15220,7 +14254,6 @@ function requireFileTypeConfig () {
 	                this.hideDeprecations = true;
 	                var promise = this.resolveData(data);
 	                this.hideDeprecations = false;
-	                this.zip.xtRendered = true;
 	                return promise.then(function() {
 	                    return _this2.render();
 	                });
@@ -15229,7 +14262,6 @@ function requireFileTypeConfig () {
 	        {
 	            key: "render",
 	            value: function render(data) {
-	                this.zip.xtRendered = true;
 	                if (this.rendered) {
 	                    throwRenderTwice();
 	                }
@@ -15263,11 +14295,11 @@ function requireFileTypeConfig () {
 	                    ]);
 	                    delete currentFile.content;
 	                }
-	                for(var _i40 = 0; _i40 < output.length; _i40++){
-	                    var outputPart = output[_i40];
+	                for(var _i36 = 0; _i36 < output.length; _i36++){
+	                    var outputPart = output[_i36];
 	                    var _outputPart = _slicedToArray(outputPart, 3), content = _outputPart[1], _currentFile = _outputPart[2];
-	                    for(var _i42 = 0, _this$modules14 = this.modules; _i42 < _this$modules14.length; _i42++){
-	                        var _module0 = _this$modules14[_i42];
+	                    for(var _i38 = 0, _this$modules14 = this.modules; _i38 < _this$modules14.length; _i38++){
+	                        var _module0 = _this$modules14[_i38];
 	                        if (_module0.preZip) {
 	                            var result = _module0.preZip(content, _currentFile);
 	                            if (typeof result === "string") {
@@ -15276,8 +14308,8 @@ function requireFileTypeConfig () {
 	                        }
 	                    }
 	                }
-	                for(var _i44 = 0; _i44 < output.length; _i44++){
-	                    var _output$_i = _slicedToArray(output[_i44], 2), _to = _output$_i[0], _content = _output$_i[1];
+	                for(var _i40 = 0; _i40 < output.length; _i40++){
+	                    var _output$_i = _slicedToArray(output[_i40], 2), _to = _output$_i[0], _content = _output$_i[1];
 	                    this.zip.file(_to, _content, {
 	                        createFolders: true
 	                    });
@@ -15338,8 +14370,8 @@ function requireFileTypeConfig () {
 	                    "fileType",
 	                    "modules"
 	                ]);
-	                for(var _i46 = 0; _i46 < defaultKeys.length; _i46++){
-	                    var key = defaultKeys[_i46];
+	                for(var _i42 = 0; _i42 < defaultKeys.length; _i42++){
+	                    var key = defaultKeys[_i42];
 	                    xmltOptions[key] = this[key];
 	                }
 	                return new Docxtemplater.XmlTemplater(content, xmltOptions);
@@ -15356,20 +14388,6 @@ 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;
 	            }