@tachybase/plugin-print-template 0.23.8

package/dist/node_modules/docxtemplater/js/modules/render.js

@@ -0,0 +1,176 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var wrapper = require("../module-wrapper.js");
+var _require = require("../errors.js"),
+  getScopeCompilationError = _require.getScopeCompilationError;
+var _require2 = require("../doc-utils.js"),
+  utf8ToWord = _require2.utf8ToWord,
+  hasCorruptCharacters = _require2.hasCorruptCharacters;
+var _require3 = require("../errors.js"),
+  getCorruptCharactersException = _require3.getCorruptCharactersException;
+var _require4 = require("../content-types.js"),
+  settingsContentType = _require4.settingsContentType,
+  coreContentType = _require4.coreContentType,
+  appContentType = _require4.appContentType,
+  customContentType = _require4.customContentType;
+var ftprefix = {
+  docx: "w",
+  pptx: "a"
+};
+var Render = /*#__PURE__*/function () {
+  function Render() {
+    _classCallCheck(this, Render);
+    this.name = "Render";
+    this.recordRun = false;
+    this.recordedRun = [];
+  }
+  return _createClass(Render, [{
+    key: "optionsTransformer",
+    value: function optionsTransformer(options, docxtemplater) {
+      this.parser = docxtemplater.parser;
+      this.fileType = docxtemplater.fileType;
+      return options;
+    }
+  }, {
+    key: "set",
+    value: function set(obj) {
+      if (obj.compiled) {
+        this.compiled = obj.compiled;
+      }
+      if (obj.data != null) {
+        this.data = obj.data;
+      }
+    }
+  }, {
+    key: "getRenderedMap",
+    value: function getRenderedMap(mapper) {
+      var _this = this;
+      return Object.keys(this.compiled).reduce(function (mapper, from) {
+        mapper[from] = {
+          from: from,
+          data: _this.data
+        };
+        return mapper;
+      }, mapper);
+    }
+  }, {
+    key: "postparse",
+    value: function postparse(postparsed, options) {
+      var errors = [];
+      for (var _i2 = 0; _i2 < postparsed.length; _i2++) {
+        var p = postparsed[_i2];
+        if (p.type === "placeholder") {
+          var tag = p.value;
+          try {
+            options.cachedParsers[p.lIndex] = this.parser(tag, {
+              tag: p
+            });
+          } catch (rootError) {
+            errors.push(getScopeCompilationError({
+              tag: tag,
+              rootError: rootError,
+              offset: p.offset
+            }));
+          }
+        }
+      }
+      return {
+        postparsed: postparsed,
+        errors: errors
+      };
+    }
+  }, {
+    key: "render",
+    value: function render(part, _ref) {
+      var _value;
+      var contentType = _ref.contentType,
+        scopeManager = _ref.scopeManager,
+        linebreaks = _ref.linebreaks,
+        nullGetter = _ref.nullGetter,
+        fileType = _ref.fileType;
+      if (linebreaks && [settingsContentType, coreContentType, appContentType, customContentType].indexOf(contentType) !== -1) {
+        // Fixes issue tested in #docprops-linebreak
+        linebreaks = false;
+      }
+      if (linebreaks) {
+        this.recordRuns(part);
+      }
+      if (part.type !== "placeholder" || part.module) {
+        return;
+      }
+      var value;
+      try {
+        value = scopeManager.getValue(part.value, {
+          part: part
+        });
+      } catch (e) {
+        return {
+          errors: [e]
+        };
+      }
+      (_value = value) !== null && _value !== void 0 ? _value : value = nullGetter(part);
+      if (hasCorruptCharacters(value)) {
+        return {
+          errors: [getCorruptCharactersException({
+            tag: part.value,
+            value: value,
+            offset: part.offset
+          })]
+        };
+      }
+      if (fileType === "text") {
+        return {
+          value: value
+        };
+      }
+      return {
+        value: linebreaks && typeof value === "string" ? this.renderLineBreaks(value) : utf8ToWord(value)
+      };
+    }
+  }, {
+    key: "recordRuns",
+    value: function recordRuns(part) {
+      if (part.tag === "".concat(ftprefix[this.fileType], ":r")) {
+        this.recordedRun = [];
+      } else if (part.tag === "".concat(ftprefix[this.fileType], ":rPr")) {
+        if (part.position === "start") {
+          this.recordRun = true;
+          this.recordedRun = [part.value];
+        }
+        if (part.position === "end" || part.position === "selfclosing") {
+          this.recordedRun.push(part.value);
+          this.recordRun = false;
+        }
+      } else if (this.recordRun) {
+        this.recordedRun.push(part.value);
+      }
+    }
+  }, {
+    key: "renderLineBreaks",
+    value: function renderLineBreaks(value) {
+      var _this2 = this;
+      var p = ftprefix[this.fileType];
+      var br = this.fileType === "docx" ? "<w:r><w:br/></w:r>" : "<a:br/>";
+      var lines = value.split("\n");
+      var runprops = this.recordedRun.join("");
+      return lines.map(function (line) {
+        return utf8ToWord(line);
+      }).reduce(function (result, line, i) {
+        result.push(line);
+        if (i < lines.length - 1) {
+          result.push("</".concat(p, ":t></").concat(p, ":r>").concat(br, "<").concat(p, ":r>").concat(runprops, "<").concat(p, ":t").concat(_this2.fileType === "docx" ? ' xml:space="preserve"' : "", ">"));
+        }
+        return result;
+      }, []);
+    }
+  }]);
+}();
+module.exports = function () {
+  return wrapper(new Render());
+};

package/dist/node_modules/docxtemplater/js/modules/space-preserve.js

@@ -0,0 +1,107 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var wrapper = require("../module-wrapper.js");
+var _require = require("../doc-utils.js"),
+  isTextStart = _require.isTextStart,
+  isTextEnd = _require.isTextEnd,
+  endsWith = _require.endsWith,
+  startsWith = _require.startsWith;
+var wTpreserve = '<w:t xml:space="preserve">';
+var wTpreservelen = wTpreserve.length;
+var wtEnd = "</w:t>";
+var wtEndlen = wtEnd.length;
+function isWtStart(part) {
+  return isTextStart(part) && part.tag === "w:t";
+}
+function addXMLPreserve(chunk, index) {
+  var tag = chunk[index].value;
+  if (chunk[index + 1].value === "</w:t>") {
+    return tag;
+  }
+  if (tag.indexOf('xml:space="preserve"') !== -1) {
+    return tag;
+  }
+  return tag.substr(0, tag.length - 1) + ' xml:space="preserve">';
+}
+function isInsideLoop(meta, chunk) {
+  return meta && meta.basePart && chunk.length > 1;
+}
+var SpacePreserve = /*#__PURE__*/function () {
+  function SpacePreserve() {
+    _classCallCheck(this, SpacePreserve);
+    this.name = "SpacePreserveModule";
+  }
+  return _createClass(SpacePreserve, [{
+    key: "postparse",
+    value: function postparse(postparsed, meta) {
+      var chunk = [],
+        inTextTag = false,
+        endLindex = 0,
+        lastTextTag = 0;
+      function isStartingPlaceHolder(part, chunk) {
+        return part.type === "placeholder" && chunk.length > 1;
+      }
+      var result = postparsed.reduce(function (postparsed, part) {
+        if (isWtStart(part)) {
+          inTextTag = true;
+          lastTextTag = chunk.length;
+        }
+        if (!inTextTag) {
+          postparsed.push(part);
+          return postparsed;
+        }
+        chunk.push(part);
+        if (isInsideLoop(meta, chunk)) {
+          endLindex = meta.basePart.endLindex;
+          chunk[0].value = addXMLPreserve(chunk, 0);
+        }
+        if (isStartingPlaceHolder(part, chunk)) {
+          chunk[lastTextTag].value = addXMLPreserve(chunk, lastTextTag);
+          endLindex = part.endLindex;
+        }
+        if (isTextEnd(part) && part.lIndex > endLindex) {
+          if (endLindex !== 0) {
+            chunk[lastTextTag].value = addXMLPreserve(chunk, lastTextTag);
+          }
+          Array.prototype.push.apply(postparsed, chunk);
+          chunk = [];
+          inTextTag = false;
+          endLindex = 0;
+          lastTextTag = 0;
+        }
+        return postparsed;
+      }, []);
+      Array.prototype.push.apply(result, chunk);
+      return result;
+    }
+  }, {
+    key: "postrender",
+    value: function postrender(parts) {
+      var lastNonEmpty = "";
+      var lastNonEmptyIndex = 0;
+      for (var i = 0, len = parts.length; i < len; i++) {
+        var p = parts[i];
+        if (p === "") {
+          continue;
+        }
+        if (endsWith(lastNonEmpty, wTpreserve) && startsWith(p, wtEnd)) {
+          parts[lastNonEmptyIndex] = lastNonEmpty.substr(0, lastNonEmpty.length - wTpreservelen) + "<w:t/>";
+          p = p.substr(wtEndlen);
+        }
+        lastNonEmpty = p;
+        lastNonEmptyIndex = i;
+        parts[i] = p;
+      }
+      return parts;
+    }
+  }]);
+}();
+module.exports = function () {
+  return wrapper(new SpacePreserve());
+};

package/dist/node_modules/docxtemplater/js/parser.js

@@ -0,0 +1,203 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var _require = require("./doc-utils.js"),
+  wordToUtf8 = _require.wordToUtf8;
+var _require2 = require("./prefix-matcher.js"),
+  match = _require2.match,
+  getValue = _require2.getValue,
+  getValues = _require2.getValues;
+function getMatchers(modules, options) {
+  var matchers = [];
+  for (var _i2 = 0; _i2 < modules.length; _i2++) {
+    var _module = modules[_i2];
+    if (_module.matchers) {
+      var mmm = _module.matchers(options);
+      if (!(mmm instanceof Array)) {
+        throw new Error("module matcher returns a non array");
+      }
+      matchers.push.apply(matchers, _toConsumableArray(mmm));
+    }
+  }
+  return matchers;
+}
+function getMatches(matchers, placeHolderContent, options) {
+  var matches = [];
+  for (var _i4 = 0; _i4 < matchers.length; _i4++) {
+    var matcher = matchers[_i4];
+    var _matcher = _slicedToArray(matcher, 2),
+      prefix = _matcher[0],
+      _module2 = _matcher[1];
+    var properties = matcher[2] || {};
+    if (options.match(prefix, placeHolderContent)) {
+      var values = options.getValues(prefix, placeHolderContent);
+      if (typeof properties === "function") {
+        properties = properties(values);
+      }
+      if (!properties.value) {
+        var _values = _slicedToArray(values, 2);
+        properties.value = _values[1];
+      }
+      matches.push(_objectSpread({
+        type: "placeholder",
+        prefix: prefix,
+        module: _module2,
+        onMatch: properties.onMatch,
+        priority: properties.priority
+      }, properties));
+    }
+  }
+  return matches;
+}
+function moduleParse(placeHolderContent, options) {
+  var modules = options.modules;
+  var startOffset = options.startOffset;
+  var endLindex = options.lIndex;
+  var moduleParsed;
+  options.offset = startOffset;
+  options.match = match;
+  options.getValue = getValue;
+  options.getValues = getValues;
+  var matchers = getMatchers(modules, options);
+  var matches = getMatches(matchers, placeHolderContent, options);
+  if (matches.length > 0) {
+    var bestMatch = null;
+    for (var _i6 = 0; _i6 < matches.length; _i6++) {
+      var _match = matches[_i6];
+      _match.priority || (_match.priority = -_match.value.length);
+      if (!bestMatch || _match.priority > bestMatch.priority) {
+        bestMatch = _match;
+      }
+    }
+    bestMatch.offset = startOffset;
+    delete bestMatch.priority;
+    bestMatch.endLindex = endLindex;
+    bestMatch.lIndex = endLindex;
+    bestMatch.raw = placeHolderContent;
+    if (bestMatch.onMatch) {
+      bestMatch.onMatch(bestMatch);
+    }
+    delete bestMatch.onMatch;
+    delete bestMatch.prefix;
+    return bestMatch;
+  }
+  for (var _i8 = 0; _i8 < modules.length; _i8++) {
+    var _module3 = modules[_i8];
+    moduleParsed = _module3.parse(placeHolderContent, options);
+    if (moduleParsed) {
+      moduleParsed.offset = startOffset;
+      moduleParsed.endLindex = endLindex;
+      moduleParsed.lIndex = endLindex;
+      moduleParsed.raw = placeHolderContent;
+      return moduleParsed;
+    }
+  }
+  return {
+    type: "placeholder",
+    value: placeHolderContent,
+    offset: startOffset,
+    endLindex: endLindex,
+    lIndex: endLindex
+  };
+}
+var parser = {
+  preparse: function preparse(parsed, modules, options) {
+    function preparse(parsed, options) {
+      for (var _i10 = 0; _i10 < modules.length; _i10++) {
+        var _module4 = modules[_i10];
+        _module4.preparse(parsed, options);
+      }
+    }
+    return {
+      preparsed: preparse(parsed, options)
+    };
+  },
+  parse: function parse(lexed, modules, options) {
+    var inPlaceHolder = false;
+    var placeHolderContent = "";
+    var startOffset;
+    var tailParts = [];
+    var droppedTags = options.fileTypeConfig.droppedTagsInsidePlaceholder || [];
+    return lexed.reduce(function (parsed, token) {
+      if (token.type === "delimiter") {
+        inPlaceHolder = token.position === "start";
+        if (token.position === "end") {
+          options.parse = function (placeHolderContent) {
+            return moduleParse(placeHolderContent, _objectSpread(_objectSpread(_objectSpread({}, options), token), {}, {
+              startOffset: startOffset,
+              modules: modules
+            }));
+          };
+          parsed.push(options.parse(wordToUtf8(placeHolderContent)));
+          Array.prototype.push.apply(parsed, tailParts);
+          tailParts = [];
+        }
+        if (token.position === "start") {
+          tailParts = [];
+          startOffset = token.offset;
+        }
+        placeHolderContent = "";
+        return parsed;
+      }
+      if (!inPlaceHolder) {
+        parsed.push(token);
+        return parsed;
+      }
+      if (token.type !== "content" || token.position !== "insidetag") {
+        if (droppedTags.indexOf(token.tag) !== -1) {
+          return parsed;
+        }
+        tailParts.push(token);
+        return parsed;
+      }
+      placeHolderContent += token.value;
+      return parsed;
+    }, []);
+  },
+  postparse: function postparse(postparsed, modules, options) {
+    function getTraits(traitName, postparsed) {
+      return modules.map(function (module) {
+        return module.getTraits(traitName, postparsed);
+      });
+    }
+    var errors = [];
+    function _postparse(postparsed, options) {
+      return modules.reduce(function (postparsed, module) {
+        var r = module.postparse(postparsed, _objectSpread(_objectSpread({}, options), {}, {
+          postparse: function postparse(parsed, opts) {
+            return _postparse(parsed, _objectSpread(_objectSpread({}, options), opts));
+          },
+          getTraits: getTraits
+        }));
+        if (r == null) {
+          return postparsed;
+        }
+        if (r.errors) {
+          Array.prototype.push.apply(errors, r.errors);
+          return r.postparsed;
+        }
+        return r;
+      }, postparsed);
+    }
+    return {
+      postparsed: _postparse(postparsed, options),
+      errors: errors
+    };
+  }
+};
+module.exports = parser;

package/dist/node_modules/docxtemplater/js/postrender.js

@@ -0,0 +1,110 @@
+"use strict";
+
+// convert string to array (typed, when possible)
+// Stryker disable all : because this is a utility function that was copied
+// from
+// https://github.com/open-xml-templating/pizzip/blob/34a840553c604980859dc6d0dcd1f89b6e5527b3/es6/utf8.js#L33
+function string2buf(str) {
+  var c,
+    c2,
+    mPos,
+    i,
+    bufLen = 0;
+  var strLen = str.length;
+
+  // count binary size
+  for (mPos = 0; mPos < strLen; mPos++) {
+    c = str.charCodeAt(mPos);
+    if ((c & 0xfc00) === 0xd800 && mPos + 1 < strLen) {
+      c2 = str.charCodeAt(mPos + 1);
+      if ((c2 & 0xfc00) === 0xdc00) {
+        c = 0x10000 + (c - 0xd800 << 10) + (c2 - 0xdc00);
+        mPos++;
+      }
+    }
+    bufLen += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
+  }
+
+  // allocate buffer
+  var buf = new Uint8Array(bufLen);
+
+  // convert
+  for (i = 0, mPos = 0; i < bufLen; mPos++) {
+    c = str.charCodeAt(mPos);
+    if ((c & 0xfc00) === 0xd800 && mPos + 1 < strLen) {
+      c2 = str.charCodeAt(mPos + 1);
+      if ((c2 & 0xfc00) === 0xdc00) {
+        c = 0x10000 + (c - 0xd800 << 10) + (c2 - 0xdc00);
+        mPos++;
+      }
+    }
+    if (c < 0x80) {
+      /* one byte */
+      buf[i++] = c;
+    } else if (c < 0x800) {
+      /* two bytes */
+      buf[i++] = 0xc0 | c >>> 6;
+      buf[i++] = 0x80 | c & 0x3f;
+    } else if (c < 0x10000) {
+      /* three bytes */
+      buf[i++] = 0xe0 | c >>> 12;
+      buf[i++] = 0x80 | c >>> 6 & 0x3f;
+      buf[i++] = 0x80 | c & 0x3f;
+    } else {
+      /* four bytes */
+      buf[i++] = 0xf0 | c >>> 18;
+      buf[i++] = 0x80 | c >>> 12 & 0x3f;
+      buf[i++] = 0x80 | c >>> 6 & 0x3f;
+      buf[i++] = 0x80 | c & 0x3f;
+    }
+  }
+  return buf;
+}
+// Stryker restore all
+
+function postrender(parts, options) {
+  for (var _i2 = 0, _options$modules2 = options.modules; _i2 < _options$modules2.length; _i2++) {
+    var _module = _options$modules2[_i2];
+    parts = _module.postrender(parts, options);
+  }
+  var fullLength = 0;
+  var newParts = options.joinUncorrupt(parts, options);
+  var longStr = "";
+  var lenStr = 0;
+  var maxCompact = 65536;
+  var uintArrays = [];
+  for (var i = 0, len = newParts.length; i < len; i++) {
+    var part = newParts[i];
+
+    // This condition should be hit in the integration test at :
+    // it("should not regress with long file (hit maxCompact value of 65536)", function () {
+    // Stryker disable all : because this is an optimisation that won't make any tests fail
+    if (part.length + lenStr > maxCompact) {
+      var _arr = string2buf(longStr);
+      fullLength += _arr.length;
+      uintArrays.push(_arr);
+      longStr = "";
+    }
+    // Stryker restore all
+
+    longStr += part;
+    lenStr += part.length;
+    delete newParts[i];
+  }
+  var arr = string2buf(longStr);
+  fullLength += arr.length;
+  uintArrays.push(arr);
+  var array = new Uint8Array(fullLength);
+  var j = 0;
+
+  // Stryker disable all : because this is an optimisation that won't make any tests fail
+  for (var _i4 = 0; _i4 < uintArrays.length; _i4++) {
+    var buf = uintArrays[_i4];
+    for (var _i5 = 0; _i5 < buf.length; ++_i5) {
+      array[_i5 + j] = buf[_i5];
+    }
+    j += buf.length;
+  } // Stryker restore all
+  return array;
+}
+module.exports = postrender;

package/dist/node_modules/docxtemplater/js/prefix-matcher.js

@@ -0,0 +1,48 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var nbspRegex = new RegExp(String.fromCharCode(160), "g");
+function replaceNbsps(str) {
+  return str.replace(nbspRegex, " ");
+}
+function match(condition, placeHolderContent) {
+  var type = _typeof(condition);
+  if (type === "string") {
+    return replaceNbsps(placeHolderContent.substr(0, condition.length)) === condition;
+  }
+  if (condition instanceof RegExp) {
+    return condition.test(replaceNbsps(placeHolderContent));
+  }
+  if (type === "function") {
+    return !!condition(placeHolderContent);
+  }
+}
+function getValue(condition, placeHolderContent) {
+  var type = _typeof(condition);
+  if (type === "string") {
+    return replaceNbsps(placeHolderContent).substr(condition.length);
+  }
+  if (condition instanceof RegExp) {
+    return replaceNbsps(placeHolderContent).match(condition)[1];
+  }
+  if (type === "function") {
+    return condition(placeHolderContent);
+  }
+}
+function getValues(condition, placeHolderContent) {
+  var type = _typeof(condition);
+  if (type === "string") {
+    return [placeHolderContent, replaceNbsps(placeHolderContent).substr(condition.length)];
+  }
+  if (condition instanceof RegExp) {
+    return replaceNbsps(placeHolderContent).match(condition);
+  }
+  if (type === "function") {
+    return [placeHolderContent, condition(placeHolderContent)];
+  }
+}
+module.exports = {
+  match: match,
+  getValue: getValue,
+  getValues: getValues
+};

package/dist/node_modules/docxtemplater/js/proof-state-module.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _require = require("./content-types.js"),
+  settingsContentType = _require.settingsContentType;
+module.exports = {
+  name: "ProofStateModule",
+  on: function on(eventName) {
+    if (eventName === "attached") {
+      this.attached = false;
+    }
+  },
+  postparse: function postparse(postparsed, _ref) {
+    var contentType = _ref.contentType;
+    if (contentType !== settingsContentType) {
+      return null;
+    }
+    return postparsed.map(function (part) {
+      if (part.type === "tag" && part.tag === "w:proofState") {
+        return {
+          type: "content",
+          value: ""
+        };
+      }
+      return part;
+    });
+  }
+};