@tachybase/plugin-print-template 0.23.8

package/dist/node_modules/docxtemplater/js/lexer.js

@@ -0,0 +1,470 @@
+"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 _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 _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 _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; }
+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 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); }
+var _require = require("./errors.js"),
+  getUnclosedTagException = _require.getUnclosedTagException,
+  getUnopenedTagException = _require.getUnopenedTagException,
+  getDuplicateOpenTagException = _require.getDuplicateOpenTagException,
+  getDuplicateCloseTagException = _require.getDuplicateCloseTagException,
+  throwMalformedXml = _require.throwMalformedXml,
+  throwXmlInvalid = _require.throwXmlInvalid,
+  XTTemplateError = _require.XTTemplateError;
+var _require2 = require("./doc-utils.js"),
+  isTextStart = _require2.isTextStart,
+  isTextEnd = _require2.isTextEnd,
+  wordToUtf8 = _require2.wordToUtf8;
+var DELIMITER_NONE = 0,
+  DELIMITER_EQUAL = 1,
+  DELIMITER_START = 2,
+  DELIMITER_END = 3;
+function inRange(range, match) {
+  return range[0] <= match.offset && match.offset < range[1];
+}
+function updateInTextTag(part, inTextTag) {
+  if (isTextStart(part)) {
+    if (inTextTag) {
+      throwMalformedXml();
+    }
+    return true;
+  }
+  if (isTextEnd(part)) {
+    if (!inTextTag) {
+      throwMalformedXml();
+    }
+    return false;
+  }
+  return inTextTag;
+}
+function getTag(tag) {
+  var position = "";
+  var start = 1;
+  var end = tag.indexOf(" ");
+  if (tag[tag.length - 2] === "/") {
+    position = "selfclosing";
+    if (end === -1) {
+      end = tag.length - 2;
+    }
+  } else if (tag[1] === "/") {
+    start = 2;
+    position = "end";
+    if (end === -1) {
+      end = tag.length - 1;
+    }
+  } else {
+    position = "start";
+    if (end === -1) {
+      end = tag.length - 1;
+    }
+  }
+  return {
+    tag: tag.slice(start, end),
+    position: position
+  };
+}
+function tagMatcher(content, textMatchArray, othersMatchArray) {
+  var cursor = 0;
+  var contentLength = content.length;
+  var allMatches = {};
+  for (var _i2 = 0; _i2 < textMatchArray.length; _i2++) {
+    var m = textMatchArray[_i2];
+    allMatches[m] = true;
+  }
+  for (var _i4 = 0; _i4 < othersMatchArray.length; _i4++) {
+    var _m = othersMatchArray[_i4];
+    allMatches[_m] = false;
+  }
+  var totalMatches = [];
+  while (cursor < contentLength) {
+    cursor = content.indexOf("<", cursor);
+    if (cursor === -1) {
+      break;
+    }
+    var offset = cursor;
+    var nextOpening = content.indexOf("<", cursor + 1);
+    cursor = content.indexOf(">", cursor);
+    if (cursor === -1 || nextOpening !== -1 && cursor > nextOpening) {
+      throwXmlInvalid(content, offset);
+    }
+    var tagText = content.slice(offset, cursor + 1);
+    var _getTag = getTag(tagText),
+      tag = _getTag.tag,
+      position = _getTag.position;
+    var text = allMatches[tag];
+    if (text == null) {
+      continue;
+    }
+    totalMatches.push({
+      type: "tag",
+      position: position,
+      text: text,
+      offset: offset,
+      value: tagText,
+      tag: tag
+    });
+  }
+  return totalMatches;
+}
+function getDelimiterErrors(delimiterMatches, fullText, syntaxOptions) {
+  var errors = [];
+  var inDelimiter = false;
+  var lastDelimiterMatch = {
+    offset: 0
+  };
+  var xtag;
+  var delimiterWithErrors = delimiterMatches.reduce(function (delimiterAcc, currDelimiterMatch) {
+    var position = currDelimiterMatch.position;
+    var delimiterOffset = currDelimiterMatch.offset;
+    var lastDelimiterOffset = lastDelimiterMatch.offset;
+    var lastDelimiterLength = lastDelimiterMatch.length;
+    xtag = fullText.substr(lastDelimiterOffset, delimiterOffset - lastDelimiterOffset);
+    if (inDelimiter && position === "start") {
+      if (lastDelimiterOffset + lastDelimiterLength === delimiterOffset) {
+        xtag = fullText.substr(lastDelimiterOffset, delimiterOffset - lastDelimiterOffset + lastDelimiterLength + 4);
+        if (!syntaxOptions.allowUnclosedTag) {
+          errors.push(getDuplicateOpenTagException({
+            xtag: xtag,
+            offset: lastDelimiterOffset
+          }));
+          lastDelimiterMatch = currDelimiterMatch;
+          delimiterAcc.push(_objectSpread(_objectSpread({}, currDelimiterMatch), {}, {
+            error: true
+          }));
+          return delimiterAcc;
+        }
+      }
+      if (!syntaxOptions.allowUnclosedTag) {
+        errors.push(getUnclosedTagException({
+          xtag: wordToUtf8(xtag),
+          offset: lastDelimiterOffset
+        }));
+        lastDelimiterMatch = currDelimiterMatch;
+        delimiterAcc.push(_objectSpread(_objectSpread({}, currDelimiterMatch), {}, {
+          error: true
+        }));
+        return delimiterAcc;
+      }
+      delimiterAcc.pop();
+    }
+    if (!inDelimiter && position === "end") {
+      if (syntaxOptions.allowUnopenedTag) {
+        return delimiterAcc;
+      }
+      if (lastDelimiterOffset + lastDelimiterLength === delimiterOffset) {
+        xtag = fullText.substr(lastDelimiterOffset - 4, delimiterOffset - lastDelimiterOffset + lastDelimiterLength + 4);
+        errors.push(getDuplicateCloseTagException({
+          xtag: xtag,
+          offset: lastDelimiterOffset
+        }));
+        lastDelimiterMatch = currDelimiterMatch;
+        delimiterAcc.push(_objectSpread(_objectSpread({}, currDelimiterMatch), {}, {
+          error: true
+        }));
+        return delimiterAcc;
+      }
+      errors.push(getUnopenedTagException({
+        xtag: xtag,
+        offset: delimiterOffset
+      }));
+      lastDelimiterMatch = currDelimiterMatch;
+      delimiterAcc.push(_objectSpread(_objectSpread({}, currDelimiterMatch), {}, {
+        error: true
+      }));
+      return delimiterAcc;
+    }
+    inDelimiter = position === "start";
+    lastDelimiterMatch = currDelimiterMatch;
+    delimiterAcc.push(currDelimiterMatch);
+    return delimiterAcc;
+  }, []);
+  if (inDelimiter) {
+    var lastDelimiterOffset = lastDelimiterMatch.offset;
+    xtag = fullText.substr(lastDelimiterOffset, fullText.length - lastDelimiterOffset);
+    if (!syntaxOptions.allowUnclosedTag) {
+      errors.push(getUnclosedTagException({
+        xtag: wordToUtf8(xtag),
+        offset: lastDelimiterOffset
+      }));
+    } else {
+      delimiterWithErrors.pop();
+    }
+  }
+  return {
+    delimiterWithErrors: delimiterWithErrors,
+    errors: errors
+  };
+}
+function compareOffsets(startOffset, endOffset) {
+  if (startOffset === -1 && endOffset === -1) {
+    return DELIMITER_NONE;
+  }
+  if (startOffset === endOffset) {
+    return DELIMITER_EQUAL;
+  }
+  if (startOffset === -1 || endOffset === -1) {
+    return endOffset < startOffset ? DELIMITER_START : DELIMITER_END;
+  }
+  return startOffset < endOffset ? DELIMITER_START : DELIMITER_END;
+}
+function splitDelimiters(inside) {
+  var newDelimiters = inside.split(" ");
+  if (newDelimiters.length !== 2) {
+    var err = new XTTemplateError("New Delimiters cannot be parsed");
+    err.properties = {
+      id: "change_delimiters_invalid",
+      explanation: "Cannot parser delimiters"
+    };
+    throw err;
+  }
+  var _newDelimiters = _slicedToArray(newDelimiters, 2),
+    start = _newDelimiters[0],
+    end = _newDelimiters[1];
+  if (start.length === 0 || end.length === 0) {
+    var _err = new XTTemplateError("New Delimiters cannot be parsed");
+    _err.properties = {
+      id: "change_delimiters_invalid",
+      explanation: "Cannot parser delimiters"
+    };
+    throw _err;
+  }
+  return [start, end];
+}
+function getAllDelimiterIndexes(fullText, delimiters, syntaxOptions) {
+  var indexes = [];
+  var start = delimiters.start,
+    end = delimiters.end;
+  var offset = -1;
+  var insideTag = false;
+  while (true) {
+    var startOffset = fullText.indexOf(start, offset + 1);
+    var endOffset = fullText.indexOf(end, offset + 1);
+    var position = null;
+    var len = void 0;
+    var compareResult = compareOffsets(startOffset, endOffset);
+    if (compareResult === DELIMITER_EQUAL) {
+      compareResult = insideTag ? DELIMITER_END : DELIMITER_START;
+    }
+    switch (compareResult) {
+      case DELIMITER_NONE:
+        return indexes;
+      case DELIMITER_END:
+        insideTag = false;
+        offset = endOffset;
+        position = "end";
+        len = end.length;
+        break;
+      case DELIMITER_START:
+        insideTag = true;
+        offset = startOffset;
+        position = "start";
+        len = start.length;
+        break;
+    }
+    /*
+     * If tag starts with =, such as {=[ ]=}
+     * then the delimiters will change right after that tag.
+     *
+     * For example, with the following template :
+     *
+     * Hello {foo}, {=[ ]=}what's up with [name] ?
+     *
+     * The "foo" tag is a normal tag, the "=[ ]=" is a tag to change the
+     * delimiters to "[" and "]", and the last "name" is a tag with the new
+     * delimiters
+     */
+    if (syntaxOptions.changeDelimiterPrefix && compareResult === DELIMITER_START && fullText[offset + start.length] === syntaxOptions.changeDelimiterPrefix) {
+      indexes.push({
+        offset: startOffset,
+        position: "start",
+        length: start.length,
+        changedelimiter: true
+      });
+      var nextEqual = fullText.indexOf(syntaxOptions.changeDelimiterPrefix, offset + start.length + 1);
+      var nextEndOffset = fullText.indexOf(end, nextEqual + 1);
+      indexes.push({
+        offset: nextEndOffset,
+        position: "end",
+        length: end.length,
+        changedelimiter: true
+      });
+      var _insideTag = fullText.substr(offset + start.length + 1, nextEqual - offset - start.length - 1);
+      var _splitDelimiters = splitDelimiters(_insideTag);
+      var _splitDelimiters2 = _slicedToArray(_splitDelimiters, 2);
+      start = _splitDelimiters2[0];
+      end = _splitDelimiters2[1];
+      offset = nextEndOffset;
+      continue;
+    }
+    indexes.push({
+      offset: offset,
+      position: position,
+      length: len
+    });
+  }
+}
+function parseDelimiters(innerContentParts, delimiters, syntaxOptions) {
+  var full = innerContentParts.map(function (p) {
+    return p.value;
+  }).join("");
+  var delimiterMatches = getAllDelimiterIndexes(full, delimiters, syntaxOptions);
+  var offset = 0;
+  var ranges = innerContentParts.map(function (part) {
+    offset += part.value.length;
+    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 = ranges.map(function (p, i) {
+    var offset = p.offset;
+    var range = [offset, offset + innerContentParts[i].value.length];
+    var partContent = innerContentParts[i].value;
+    var delimitersInOffset = [];
+    while (delimiterIndex < delimiterWithErrors.length && inRange(range, delimiterWithErrors[delimiterIndex])) {
+      delimitersInOffset.push(delimiterWithErrors[delimiterIndex]);
+      delimiterIndex++;
+    }
+    var parts = [];
+    var cursor = 0;
+    if (cutNext > 0) {
+      cursor = cutNext;
+      cutNext = 0;
+    }
+    for (var _i6 = 0; _i6 < delimitersInOffset.length; _i6++) {
+      var delimiterInOffset = delimitersInOffset[_i6];
+      var _value = partContent.substr(cursor, delimiterInOffset.offset - offset - cursor);
+      if (delimiterInOffset.changedelimiter) {
+        if (delimiterInOffset.position === "start") {
+          if (_value.length > 0) {
+            parts.push({
+              type: "content",
+              value: _value
+            });
+          }
+        } else {
+          cursor = delimiterInOffset.offset - offset + delimiterInOffset.length;
+        }
+        continue;
+      }
+      if (_value.length > 0) {
+        parts.push({
+          type: "content",
+          value: _value
+        });
+        cursor += _value.length;
+      }
+      var delimiterPart = {
+        type: "delimiter",
+        position: delimiterInOffset.position,
+        offset: cursor + offset
+      };
+      parts.push(delimiterPart);
+      cursor = delimiterInOffset.offset - offset + delimiterInOffset.length;
+    }
+    cutNext = cursor - partContent.length;
+    var value = partContent.substr(cursor);
+    if (value.length > 0) {
+      parts.push({
+        type: "content",
+        value: value
+      });
+    }
+    return parts;
+  }, this);
+  return {
+    parsed: parsed,
+    errors: errors
+  };
+}
+function isInsideContent(part) {
+  // Stryker disable all : because the part.position === "insidetag" would be enough but we want to make the API future proof
+  return part.type === "content" && part.position === "insidetag";
+  // Stryker restore all
+}
+function getContentParts(xmlparsed) {
+  return xmlparsed.filter(isInsideContent);
+}
+function decodeContentParts(xmlparsed, fileType) {
+  var inTextTag = false;
+  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";
+    }
+    if (fileType !== "text" && isInsideContent(part)) {
+      part.value = part.value.replace(/>/g, "&gt;");
+    }
+  }
+}
+module.exports = {
+  parseDelimiters: parseDelimiters,
+  parse: function parse(xmllexed, delimiters, syntax, fileType) {
+    decodeContentParts(xmllexed, fileType);
+    var _parseDelimiters = parseDelimiters(getContentParts(xmllexed), delimiters, syntax),
+      delimiterParsed = _parseDelimiters.parsed,
+      errors = _parseDelimiters.errors;
+    var lexed = [];
+    var index = 0;
+    var lIndex = 0;
+    for (var _i10 = 0; _i10 < xmllexed.length; _i10++) {
+      var part = xmllexed[_i10];
+      if (isInsideContent(part)) {
+        for (var _i12 = 0, _delimiterParsed$inde2 = delimiterParsed[index]; _i12 < _delimiterParsed$inde2.length; _i12++) {
+          var p = _delimiterParsed$inde2[_i12];
+          if (p.type === "content") {
+            p.position = "insidetag";
+          }
+          p.lIndex = lIndex++;
+        }
+        Array.prototype.push.apply(lexed, delimiterParsed[index]);
+        index++;
+      } else {
+        part.lIndex = lIndex++;
+        lexed.push(part);
+      }
+    }
+    return {
+      errors: errors,
+      lexed: lexed
+    };
+  },
+  xmlparse: function xmlparse(content, xmltags) {
+    var matches = tagMatcher(content, xmltags.text, xmltags.other);
+    var cursor = 0;
+    var parsed = matches.reduce(function (parsed, match) {
+      if (content.length > cursor && match.offset - cursor > 0) {
+        parsed.push({
+          type: "content",
+          value: content.substr(cursor, match.offset - cursor)
+        });
+      }
+      cursor = match.offset + match.value.length;
+      delete match.offset;
+      parsed.push(match);
+      return parsed;
+    }, []);
+    if (content.length > cursor) {
+      parsed.push({
+        type: "content",
+        value: content.substr(cursor)
+      });
+    }
+    return parsed;
+  }
+};

package/dist/node_modules/docxtemplater/js/memory-test.js

@@ -0,0 +1,38 @@
+"use strict";
+
+var PizZip = require("pizzip");
+var Docxtemplater = require("./docxtemplater.js");
+var fs = require("fs");
+var zip = new PizZip(fs.readFileSync("examples/memory-stress.docx"));
+var doc = new Docxtemplater(zip, {
+  paragraphLoop: true
+});
+var a = [];
+for (var i = 0, len = 500; i < len; i++) {
+  var b = [];
+  for (var j = 0, len2 = 500; j < len2; j++) {
+    b.push({
+      title: i + j,
+      c: [{
+        content: "Hi"
+      }, {
+        content: "Ho"
+      }]
+    });
+  }
+  a.push({
+    b: b
+  });
+}
+doc.render({
+  a: a
+});
+var buf = doc.getZip().generate({
+  type: "nodebuffer"
+});
+var minSize = 500;
+if (buf.length < minSize * 1000 * 1000) {
+  throw new Error("The output document should be at least ${minSize} MB");
+}
+// eslint-disable-next-line no-console
+console.log("memory-test buffer length : ", buf.length);

package/dist/node_modules/docxtemplater/js/merge-sort.js

@@ -0,0 +1,32 @@
+"use strict";
+
+function getMinFromArrays(arrays, state) {
+  var minIndex = -1;
+  for (var i = 0, l = arrays.length; i < l; i++) {
+    if (state[i] >= arrays[i].length) {
+      continue;
+    }
+    if (minIndex === -1 || arrays[i][state[i]].offset < arrays[minIndex][state[minIndex]].offset) {
+      minIndex = i;
+    }
+  }
+  return minIndex;
+}
+module.exports = function (arrays) {
+  var totalLength = arrays.reduce(function (sum, array) {
+    return sum + array.length;
+  }, 0);
+  arrays = arrays.filter(function (array) {
+    return array.length > 0;
+  });
+  var resultArray = new Array(totalLength);
+  var state = arrays.map(function () {
+    return 0;
+  });
+  for (var i = 0; i < totalLength; i++) {
+    var arrayIndex = getMinFromArrays(arrays, state);
+    resultArray[i] = arrays[arrayIndex][state[arrayIndex]];
+    state[arrayIndex]++;
+  }
+  return resultArray;
+};

package/dist/node_modules/docxtemplater/js/module-wrapper.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _require = require("./errors.js"),
+  XTInternalError = _require.XTInternalError;
+function emptyFun() {}
+function identity(i) {
+  return i;
+}
+module.exports = function (module) {
+  var defaults = {
+    set: emptyFun,
+    matchers: function matchers() {
+      return [];
+    },
+    parse: emptyFun,
+    render: emptyFun,
+    getTraits: emptyFun,
+    getFileType: emptyFun,
+    nullGetter: emptyFun,
+    optionsTransformer: identity,
+    postrender: identity,
+    errorsTransformer: identity,
+    getRenderedMap: identity,
+    preparse: identity,
+    postparse: identity,
+    on: emptyFun,
+    resolve: emptyFun,
+    preResolve: emptyFun
+  };
+  if (Object.keys(defaults).every(function (key) {
+    return !module[key];
+  })) {
+    var err = new XTInternalError("This module cannot be wrapped, because it doesn't define any of the necessary functions");
+    err.properties = {
+      id: "module_cannot_be_wrapped",
+      explanation: "This module cannot be wrapped, because it doesn't define any of the necessary functions"
+    };
+    throw err;
+  }
+  for (var key in defaults) {
+    module[key] || (module[key] = defaults[key]);
+  }
+  return module;
+};

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

@@ -0,0 +1,69 @@
+"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 filetypes = require("../filetypes.js");
+var _require = require("../content-types.js"),
+  settingsContentType = _require.settingsContentType,
+  coreContentType = _require.coreContentType,
+  appContentType = _require.appContentType,
+  customContentType = _require.customContentType,
+  diagramDataContentType = _require.diagramDataContentType,
+  diagramDrawingContentType = _require.diagramDrawingContentType;
+var commonContentTypes = [settingsContentType, coreContentType, appContentType, customContentType, diagramDataContentType, diagramDrawingContentType];
+var Common = /*#__PURE__*/function () {
+  function Common() {
+    _classCallCheck(this, Common);
+    this.name = "Common";
+  }
+  return _createClass(Common, [{
+    key: "getFileType",
+    value: function getFileType(_ref) {
+      var doc = _ref.doc;
+      var invertedContentTypes = doc.invertedContentTypes;
+      if (!invertedContentTypes) {
+        return;
+      }
+      for (var _i2 = 0; _i2 < commonContentTypes.length; _i2++) {
+        var ct = commonContentTypes[_i2];
+        if (invertedContentTypes[ct]) {
+          Array.prototype.push.apply(doc.targets, invertedContentTypes[ct]);
+        }
+      }
+      var keys = ["docx", "pptx"];
+      var ftCandidate;
+      for (var _i4 = 0; _i4 < keys.length; _i4++) {
+        var key = keys[_i4];
+        var contentTypes = filetypes[key];
+        for (var _i6 = 0; _i6 < contentTypes.length; _i6++) {
+          var _ct = contentTypes[_i6];
+          if (invertedContentTypes[_ct]) {
+            for (var _i8 = 0, _invertedContentTypes2 = invertedContentTypes[_ct]; _i8 < _invertedContentTypes2.length; _i8++) {
+              var target = _invertedContentTypes2[_i8];
+              if (doc.relsTypes[target] && ["http://purl.oclc.org/ooxml/officeDocument/relationships/officeDocument", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"].indexOf(doc.relsTypes[target]) === -1) {
+                continue;
+              }
+              ftCandidate = key;
+              if (filetypes.main.indexOf(_ct) !== -1 || _ct === filetypes.pptx[0]) {
+                doc.textTarget || (doc.textTarget = target);
+              }
+              doc.targets.push(target);
+            }
+          }
+        }
+        if (ftCandidate) {
+          return ftCandidate;
+        }
+      }
+      return ftCandidate;
+    }
+  }]);
+}();
+module.exports = function () {
+  return wrapper(new Common());
+};