@tachybase/plugin-print-template 0.23.8

package/dist/node_modules/docxtemplater/js/doc-utils.js

@@ -0,0 +1,450 @@
+"use strict";
+
+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; }
+var _require = require("@xmldom/xmldom"),
+  DOMParser = _require.DOMParser,
+  XMLSerializer = _require.XMLSerializer;
+var _require2 = require("./errors.js"),
+  throwXmlTagNotFound = _require2.throwXmlTagNotFound;
+var _require3 = require("./utils.js"),
+  last = _require3.last,
+  first = _require3.first;
+function isWhiteSpace(value) {
+  return /^[ \n\r\t]+$/.test(value);
+}
+function parser(tag) {
+  return {
+    get: function get(scope) {
+      if (tag === ".") {
+        return scope;
+      }
+      if (scope) {
+        return scope[tag];
+      }
+      return scope;
+    }
+  };
+}
+var attrToRegex = {};
+function setSingleAttribute(partValue, attr, attrValue) {
+  var regex;
+  // Stryker disable next-line all : because this is an optimisation
+  if (attrToRegex[attr]) {
+    regex = attrToRegex[attr];
+  } else {
+    regex = new RegExp("(<.* ".concat(attr, "=\")([^\"]*)(\".*)$"));
+    attrToRegex[attr] = regex;
+  }
+  if (regex.test(partValue)) {
+    return partValue.replace(regex, "$1".concat(attrValue, "$3"));
+  }
+  var end = partValue.lastIndexOf("/>");
+  if (end === -1) {
+    end = partValue.lastIndexOf(">");
+  }
+  return partValue.substr(0, end) + " ".concat(attr, "=\"").concat(attrValue, "\"") + partValue.substr(end);
+}
+function getSingleAttribute(value, attributeName) {
+  var index = value.indexOf(" ".concat(attributeName, "=\""));
+  if (index === -1) {
+    return null;
+  }
+  var startIndex = value.substr(index).search(/["']/) + index;
+  var endIndex = value.substr(startIndex + 1).search(/["']/) + startIndex;
+  return value.substr(startIndex + 1, endIndex - startIndex);
+}
+function endsWith(str, suffix) {
+  return str.indexOf(suffix, str.length - suffix.length) !== -1;
+}
+function startsWith(str, prefix) {
+  return str.substring(0, prefix.length) === prefix;
+}
+function getDuplicates(arr) {
+  var duplicates = [];
+  var hash = {},
+    result = [];
+  for (var i = 0, l = arr.length; i < l; ++i) {
+    if (!hash[arr[i]]) {
+      hash[arr[i]] = true;
+      result.push(arr[i]);
+    } else {
+      duplicates.push(arr[i]);
+    }
+  }
+  return duplicates;
+}
+function uniq(arr) {
+  var hash = {},
+    result = [];
+  for (var i = 0, l = arr.length; i < l; ++i) {
+    if (!hash[arr[i]]) {
+      hash[arr[i]] = true;
+      result.push(arr[i]);
+    }
+  }
+  return result;
+}
+function chunkBy(parsed, f) {
+  var chunks = [[]];
+  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") {
+      chunks.push([p]);
+    } else if (res === "end") {
+      currentChunk.push(p);
+      chunks.push([]);
+    } else {
+      currentChunk.push(p);
+    }
+  } // Remove empty chunks
+  var result = [];
+  for (var _i4 = 0; _i4 < chunks.length; _i4++) {
+    var chunk = chunks[_i4];
+    if (chunk.length > 0) {
+      result.push(chunk);
+    }
+  }
+  return result;
+}
+function getDefaults() {
+  return {
+    errorLogging: "json",
+    paragraphLoop: false,
+    nullGetter: function nullGetter(part) {
+      return part.module ? "" : "undefined";
+    },
+    xmlFileNames: ["[Content_Types].xml"],
+    parser: parser,
+    linebreaks: false,
+    fileTypeConfig: null,
+    delimiters: {
+      start: "{",
+      end: "}"
+    },
+    syntax: {
+      changeDelimiterPrefix: "="
+    }
+  };
+}
+function xml2str(xmlNode) {
+  return new XMLSerializer().serializeToString(xmlNode).replace(/xmlns(:[a-z0-9]+)?="" ?/g, "");
+}
+function str2xml(str) {
+  if (str.charCodeAt(0) === 65279) {
+    // BOM sequence
+    str = str.substr(1);
+  }
+  return new DOMParser().parseFromString(str, "text/xml");
+}
+var charMap = [["&", "&amp;"], ["<", "&lt;"], [">", "&gt;"], ['"', "&quot;"], ["'", "&apos;"]];
+var charMapRegexes = charMap.map(function (_ref) {
+  var _ref2 = _slicedToArray(_ref, 2),
+    endChar = _ref2[0],
+    startChar = _ref2[1];
+  return {
+    rstart: new RegExp(startChar, "g"),
+    rend: new RegExp(endChar, "g"),
+    start: startChar,
+    end: endChar
+  };
+});
+function wordToUtf8(string) {
+  for (var i = charMapRegexes.length - 1; i >= 0; i--) {
+    var r = charMapRegexes[i];
+    string = string.replace(r.rstart, r.end);
+  }
+  return string;
+}
+function utf8ToWord(string) {
+  // To make sure that the object given is a string (this is a noop for strings).
+  string = string.toString();
+  var r;
+  for (var i = 0, l = charMapRegexes.length; i < l; i++) {
+    r = charMapRegexes[i];
+    string = string.replace(r.rend, r.start);
+  }
+  return string;
+}
+
+// This function is written with for loops for performance
+function concatArrays(arrays) {
+  var result = [];
+  for (var _i6 = 0; _i6 < arrays.length; _i6++) {
+    var array = arrays[_i6];
+    for (var _i8 = 0; _i8 < array.length; _i8++) {
+      var el = array[_i8];
+      result.push(el);
+    }
+  }
+  return result;
+}
+function pushArray(array1, array2) {
+  if (!array2) {
+    return array1;
+  }
+  for (var i = 0, len = array2.length; i < len; i++) {
+    array1.push(array2[i]);
+  }
+  return array1;
+}
+var spaceRegexp = new RegExp(String.fromCharCode(160), "g");
+function convertSpaces(s) {
+  return s.replace(spaceRegexp, " ");
+}
+function pregMatchAll(regex, content) {
+  /* regex is a string, content is the content. It returns an array of all matches with their offset, for example:
+  		regex=la
+  	content=lolalolilala
+  		returns:
+  		[
+  			{array: {0: 'la'}, offset: 2},
+  			{array: {0: 'la'}, offset: 8},
+  			{array: {0: 'la'}, offset: 10}
+  		]
+  */
+  var matchArray = [];
+  var match;
+  while ((match = regex.exec(content)) != null) {
+    matchArray.push({
+      array: match,
+      offset: match.index
+    });
+  }
+  return matchArray;
+}
+function isEnding(value, element) {
+  return value === "</" + element + ">";
+}
+function isStarting(value, element) {
+  return value.indexOf("<" + element) === 0 && [">", " ", "/"].indexOf(value[element.length + 1]) !== -1;
+}
+function getRight(parsed, element, index) {
+  var val = getRightOrNull(parsed, element, index);
+  if (val !== null) {
+    return val;
+  }
+  throwXmlTagNotFound({
+    position: "right",
+    element: element,
+    parsed: parsed,
+    index: index
+  });
+}
+function getRightOrNull(parsed, elements, index) {
+  if (typeof elements === "string") {
+    elements = [elements];
+  }
+  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];
+      if (isEnding(part.value, element)) {
+        level--;
+      }
+      if (isStarting(part.value, element)) {
+        level++;
+      }
+      if (level === 0) {
+        return i;
+      }
+    }
+  }
+  return null;
+}
+function getLeft(parsed, element, index) {
+  var val = getLeftOrNull(parsed, element, index);
+  if (val !== null) {
+    return val;
+  }
+  throwXmlTagNotFound({
+    position: "left",
+    element: element,
+    parsed: parsed,
+    index: index
+  });
+}
+function getLeftOrNull(parsed, elements, index) {
+  if (typeof elements === "string") {
+    elements = [elements];
+  }
+  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];
+      if (isStarting(part.value, element)) {
+        level--;
+      }
+      if (isEnding(part.value, element)) {
+        level++;
+      }
+      if (level === 0) {
+        return i;
+      }
+    }
+  }
+  return null;
+}
+
+// Stryker disable all : because those are functions that depend on the parsed
+// structure based and we don't want minimal code here, but rather code that
+// makes things clear.
+function isTagStart(tagType, _ref3) {
+  var type = _ref3.type,
+    tag = _ref3.tag,
+    position = _ref3.position;
+  return type === "tag" && tag === tagType && (position === "start" || position === "selfclosing");
+}
+function isTagEnd(tagType, _ref4) {
+  var type = _ref4.type,
+    tag = _ref4.tag,
+    position = _ref4.position;
+  return type === "tag" && tag === tagType && position === "end";
+}
+function isParagraphStart(_ref5) {
+  var type = _ref5.type,
+    tag = _ref5.tag,
+    position = _ref5.position;
+  return ["w:p", "a:p"].indexOf(tag) !== -1 && type === "tag" && position === "start";
+}
+function isParagraphEnd(_ref6) {
+  var type = _ref6.type,
+    tag = _ref6.tag,
+    position = _ref6.position;
+  return ["w:p", "a:p"].indexOf(tag) !== -1 && type === "tag" && position === "end";
+}
+function isTextStart(_ref7) {
+  var type = _ref7.type,
+    position = _ref7.position,
+    text = _ref7.text;
+  return text && type === "tag" && position === "start";
+}
+function isTextEnd(_ref8) {
+  var type = _ref8.type,
+    position = _ref8.position,
+    text = _ref8.text;
+  return text && type === "tag" && position === "end";
+}
+function isContent(_ref9) {
+  var type = _ref9.type,
+    position = _ref9.position;
+  return type === "placeholder" || type === "content" && position === "insidetag";
+}
+function isModule(_ref10, modules) {
+  var module = _ref10.module,
+    type = _ref10.type;
+  if (!(modules instanceof Array)) {
+    modules = [modules];
+  }
+  return type === "placeholder" && modules.indexOf(module) !== -1;
+}
+// Stryker restore all
+
+var corruptCharacters = /[\x00-\x08\x0B\x0C\x0E-\x1F]/;
+// 00    NUL '\0' (null character)
+// 01    SOH (start of heading)
+// 02    STX (start of text)
+// 03    ETX (end of text)
+// 04    EOT (end of transmission)
+// 05    ENQ (enquiry)
+// 06    ACK (acknowledge)
+// 07    BEL '\a' (bell)
+// 08    BS  '\b' (backspace)
+// 0B    VT  '\v' (vertical tab)
+// 0C    FF  '\f' (form feed)
+// 0E    SO  (shift out)
+// 0F    SI  (shift in)
+// 10    DLE (data link escape)
+// 11    DC1 (device control 1)
+// 12    DC2 (device control 2)
+// 13    DC3 (device control 3)
+// 14    DC4 (device control 4)
+// 15    NAK (negative ack.)
+// 16    SYN (synchronous idle)
+// 17    ETB (end of trans. blk)
+// 18    CAN (cancel)
+// 19    EM  (end of medium)
+// 1A    SUB (substitute)
+// 1B    ESC (escape)
+// 1C    FS  (file separator)
+// 1D    GS  (group separator)
+// 1E    RS  (record separator)
+// 1F    US  (unit separator)
+function hasCorruptCharacters(string) {
+  return corruptCharacters.test(string);
+}
+function invertMap(map) {
+  var invertedMap = {};
+  for (var key in map) {
+    var value = map[key];
+    invertedMap[value] || (invertedMap[value] = []);
+    invertedMap[value].push(key);
+  }
+  return invertedMap;
+}
+// This ensures that the sort is stable. The default Array.sort of the browser
+// is not stable in firefox, as the JS spec does not enforce the sort to be
+// stable.
+function stableSort(arr, compare) {
+  // Stryker disable all : in previous versions of Chrome, sort was not stable by itself, so we had to add this. This is to support older versions of JS runners.
+  return arr.map(function (item, index) {
+    return {
+      item: item,
+      index: index
+    };
+  }).sort(function (a, b) {
+    return compare(a.item, b.item) || a.index - b.index;
+  }).map(function (_ref11) {
+    var item = _ref11.item;
+    return item;
+  });
+  // Stryker restore all
+}
+module.exports = {
+  endsWith: endsWith,
+  startsWith: startsWith,
+  isContent: isContent,
+  isParagraphStart: isParagraphStart,
+  isParagraphEnd: isParagraphEnd,
+  isTagStart: isTagStart,
+  isTagEnd: isTagEnd,
+  isTextStart: isTextStart,
+  isTextEnd: isTextEnd,
+  isStarting: isStarting,
+  isEnding: isEnding,
+  isModule: isModule,
+  uniq: uniq,
+  getDuplicates: getDuplicates,
+  chunkBy: chunkBy,
+  last: last,
+  first: first,
+  xml2str: xml2str,
+  str2xml: str2xml,
+  getRightOrNull: getRightOrNull,
+  getRight: getRight,
+  getLeftOrNull: getLeftOrNull,
+  getLeft: getLeft,
+  pregMatchAll: pregMatchAll,
+  convertSpaces: convertSpaces,
+  charMapRegexes: charMapRegexes,
+  hasCorruptCharacters: hasCorruptCharacters,
+  getDefaults: getDefaults,
+  wordToUtf8: wordToUtf8,
+  utf8ToWord: utf8ToWord,
+  concatArrays: concatArrays,
+  pushArray: pushArray,
+  invertMap: invertMap,
+  charMap: charMap,
+  getSingleAttribute: getSingleAttribute,
+  setSingleAttribute: setSingleAttribute,
+  isWhiteSpace: isWhiteSpace,
+  stableSort: stableSort
+};

package/dist/node_modules/docxtemplater/js/docxtemplater.d.ts

@@ -0,0 +1,140 @@
+declare namespace DXT {
+  type integer = number;
+
+  interface SimplePart {
+    type: string;
+    value: string;
+    module?: string;
+    [x: string]: any;
+  }
+
+  interface Part {
+    type: string;
+    value: string;
+    module: string;
+    raw: string;
+    offset: integer;
+    lIndex: integer;
+    num: integer;
+    inverted?: boolean;
+    endLindex?: integer;
+    expanded?: Part[];
+    subparsed?: Part[];
+    position?: string;
+    tag?: string;
+  }
+
+  interface ScopeManager {
+    scopeList: any[];
+    scopeLindex: integer[];
+    scopePath: string[];
+    scopePathItem: integer[];
+    scopePathLength: integer[];
+    resolved: any;
+    cachedParsers: Record<string, (scope: any, context: ParserContext) => any>;
+    parser(tag: string): Parser;
+  }
+
+  interface Rendered {
+    value: string;
+    errors: any[];
+  }
+
+  type Error = any;
+
+  interface Module {
+    set?(options: any): void;
+    parse?(placeHolderContent: string): SimplePart | null;
+    matchers?(): [
+      string,
+      string,
+      { [x: string]: any } | ((part: SimplePart) => { [x: string]: any }),
+    ][];
+    render?(part: Part): Rendered | null;
+    getTraits?(traitName: string, parsed: any): any;
+    getFileType?(opts: any): string | void;
+    nullGetter?(part: Part, scopeManager: any): any;
+    optionsTransformer?(options: Options): Options;
+    postrender?(parts: string[], options: any): string[];
+    errorsTransformer?(errors: Error[]): Error[];
+    getRenderedMap?(map: any): any;
+    preparse?(parsed: any, options: any): any;
+    postparse?(postparsed: Part[], modules: Module[], options: any): Part[];
+    on?(event: string): void;
+    resolve?(part: Part, options: any): null | Promise<any>;
+    [x: string]: any;
+  }
+
+  interface ParserContext {
+    meta: {
+      part: Part;
+    };
+    scopeList: any[];
+    scopePath: string[];
+    scopePathItem: integer[];
+    scopePathLength: integer[];
+    num: integer;
+  }
+
+  interface Parser {
+    get(scope: any, context: ParserContext): any;
+  }
+
+  interface Syntax {
+    allowUnopenedTag?: boolean;
+    allowUnclosedTag?: boolean;
+    changeDelimiterPrefix?: string | null;
+  }
+
+  interface Options {
+    delimiters?: { start: string; end: string };
+    paragraphLoop?: boolean;
+    parser?(tag: string): Parser;
+    errorLogging?: boolean | string;
+    linebreaks?: boolean;
+    nullGetter?(part: Part): any;
+    syntax?: Syntax;
+  }
+
+  interface ConstructorOptions extends Options {
+    modules?: Module[];
+  }
+}
+
+declare class Docxtemplater<TZip = any> {
+  static default: typeof Docxtemplater;
+  /**
+   * Create Docxtemplater instance (and compile it on the fly)
+   *
+   * @param zip Serialized zip archive
+   * @param options `modules` and other options
+   */
+  constructor(zip: TZip, options?: DXT.ConstructorOptions);
+  /**
+   * Create Docxtemplater instance, without options
+   */
+  constructor();
+
+  setData(data: any): this;
+  resolveData(data: any): Promise<any>;
+  render(data?: any): this;
+  renderAsync(data?: any): Promise<any>;
+  getZip(): TZip;
+
+  loadZip(zip: TZip): this;
+  setOptions(options: DXT.Options): this;
+  attachModule(module: DXT.Module): this;
+  compile(): this;
+  getFullText(path?: string): string;
+  targets: string[]; // used to know which files are templated
+  replaceFirstSection?: boolean; // used for the subsection module
+  replaceLastSection?: boolean; // used for the subsection module
+  includeSections?: boolean; // used for the subsection module
+  keepStyles?: boolean; // used for the subtemplate module
+}
+
+declare namespace Docxtemplater {
+  export { DXT };
+}
+
+export = Docxtemplater;