@tachybase/plugin-print-template 0.23.8

package/dist/node_modules/docxtemplater/js/modules/loop.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 _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 _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 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 _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 _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 _require = require("../doc-utils.js"),
+  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 = require("../filetypes.js");
+var wrapper = require("../module-wrapper.js");
+var moduleName = "loop";
+function hasContent(parts) {
+  return parts.some(function (part) {
+    return isContent(part);
+  });
+}
+function getFirstMeaningFulPart(parsed) {
+  for (var _i2 = 0; _i2 < parsed.length; _i2++) {
+    var part = parsed[_i2];
+    if (part.type !== "content") {
+      return part;
+    }
+  }
+  return null;
+}
+function isInsideParagraphLoop(part) {
+  var firstMeaningfulPart = getFirstMeaningFulPart(part.subparsed);
+  return firstMeaningfulPart != null && firstMeaningfulPart.tag !== "w:t";
+}
+function getPageBreakIfApplies(part) {
+  return part.hasPageBreak && isInsideParagraphLoop(part) ? '<w:p><w:r><w:br w:type="page"/></w:r></w:p>' : "";
+}
+function isEnclosedByParagraphs(parsed) {
+  return parsed.length && isParagraphStart(parsed[0]) && isParagraphEnd(last(parsed));
+}
+function getOffset(chunk) {
+  return hasContent(chunk) ? 0 : chunk.length;
+}
+function addPageBreakAtEnd(subRendered) {
+  var j = subRendered.parts.length - 1;
+  if (subRendered.parts[j] === "</w:p>") {
+    subRendered.parts.splice(j, 0, '<w:r><w:br w:type="page"/></w:r>');
+  } else {
+    subRendered.parts.push('<w:p><w:r><w:br w:type="page"/></w:r></w:p>');
+  }
+}
+function addPageBreakAtBeginning(subRendered) {
+  subRendered.parts.unshift('<w:p><w:r><w:br w:type="page"/></w:r></w:p>');
+}
+function isContinuous(parts) {
+  return parts.some(function (part) {
+    return isTagStart("w:type", part) && part.value.indexOf("continuous") !== -1;
+  });
+}
+function isNextPage(parts) {
+  return parts.some(function (part) {
+    return isTagStart("w:type", part) && part.value.indexOf('w:val="nextPage"') !== -1;
+  });
+}
+function addSectionBefore(parts, sect) {
+  return pushArray(["<w:p><w:pPr>".concat(sect.map(function (_ref) {
+    var value = _ref.value;
+    return value;
+  }).join(""), "</w:pPr></w:p>")], parts);
+}
+function addContinuousType(parts) {
+  var stop = false;
+  var inSectPr = false;
+  return parts.reduce(function (result, part) {
+    if (stop === false && startsWith(part, "<w:sectPr")) {
+      inSectPr = true;
+    }
+    if (inSectPr) {
+      if (startsWith(part, "<w:type")) {
+        stop = true;
+      }
+      if (stop === false && startsWith(part, "</w:sectPr")) {
+        result.push('<w:type w:val="continuous"/>');
+      }
+    }
+    result.push(part);
+    return result;
+  }, []);
+}
+function dropHeaderFooterRefs(parts) {
+  return parts.filter(function (text) {
+    return !startsWith(text, "<w:headerReference") && !startsWith(text, "<w:footerReference");
+  });
+}
+function hasPageBreak(chunk) {
+  return chunk.some(function (part) {
+    return part.tag === "w:br" && part.value.indexOf('w:type="page"') !== -1;
+  });
+}
+function hasImage(chunk) {
+  return chunk.some(function (_ref2) {
+    var tag = _ref2.tag;
+    return tag === "w:drawing";
+  });
+}
+function getSectPr(chunks) {
+  var collectSectPr = false;
+  var sectPrs = [];
+  for (var _i4 = 0; _i4 < chunks.length; _i4++) {
+    var part = chunks[_i4];
+    if (isTagStart("w:sectPr", part)) {
+      sectPrs.push([]);
+      collectSectPr = true;
+    }
+    if (collectSectPr) {
+      sectPrs[sectPrs.length - 1].push(part);
+    }
+    if (isTagEnd("w:sectPr", part)) {
+      collectSectPr = false;
+    }
+  }
+  return sectPrs;
+}
+function getSectPrHeaderFooterChangeCount(chunks) {
+  var collectSectPr = false;
+  var sectPrCount = 0;
+  for (var _i6 = 0; _i6 < chunks.length; _i6++) {
+    var part = chunks[_i6];
+    if (isTagStart("w:sectPr", part)) {
+      collectSectPr = true;
+    }
+    if (collectSectPr) {
+      if (part.tag === "w:headerReference" || part.tag === "w:footerReference") {
+        sectPrCount++;
+        collectSectPr = false;
+      }
+    }
+    if (isTagEnd("w:sectPr", part)) {
+      collectSectPr = false;
+    }
+  }
+  return sectPrCount;
+}
+function getLastSectPr(parsed) {
+  var sectPr = [];
+  var inSectPr = false;
+  for (var i = parsed.length - 1; i >= 0; i--) {
+    var part = parsed[i];
+    if (isTagEnd("w:sectPr", part)) {
+      inSectPr = true;
+    }
+    if (isTagStart("w:sectPr", part)) {
+      sectPr.unshift(part.value);
+      inSectPr = false;
+    }
+    if (inSectPr) {
+      sectPr.unshift(part.value);
+    }
+    if (isParagraphStart(part)) {
+      if (sectPr.length > 0) {
+        return sectPr.join("");
+      }
+      break;
+    }
+  }
+  return "";
+}
+var LoopModule = /*#__PURE__*/function () {
+  function LoopModule() {
+    _classCallCheck(this, LoopModule);
+    this.name = "LoopModule";
+    this.inXfrm = false;
+    this.totalSectPr = 0;
+    this.prefix = {
+      start: "#",
+      end: "/",
+      dash: /^-([^\s]+)\s(.+)/,
+      inverted: "^"
+    };
+  }
+  return _createClass(LoopModule, [{
+    key: "optionsTransformer",
+    value: function optionsTransformer(opts, docxtemplater) {
+      this.docxtemplater = docxtemplater;
+      return opts;
+    }
+  }, {
+    key: "preparse",
+    value: function preparse(parsed, _ref3) {
+      var contentType = _ref3.contentType;
+      if (filetypes.main.indexOf(contentType) !== -1) {
+        this.sects = getSectPr(parsed);
+      }
+    }
+  }, {
+    key: "matchers",
+    value: function matchers() {
+      var module = moduleName;
+      return [[this.prefix.start, module, {
+        expandTo: "auto",
+        location: "start",
+        inverted: false
+      }], [this.prefix.inverted, module, {
+        expandTo: "auto",
+        location: "start",
+        inverted: true
+      }], [this.prefix.end, module, {
+        location: "end"
+      }], [this.prefix.dash, module, function (_ref4) {
+        var _ref5 = _slicedToArray(_ref4, 3),
+          expandTo = _ref5[1],
+          value = _ref5[2];
+        return {
+          location: "start",
+          inverted: false,
+          expandTo: expandTo,
+          value: value
+        };
+      }]];
+    }
+  }, {
+    key: "getTraits",
+    value: function getTraits(traitName, parsed) {
+      // Stryker disable all : because getTraits should disappear in v4
+      if (traitName !== "expandPair") {
+        return;
+      }
+      // Stryker restore all
+
+      return parsed.reduce(function (tags, part, offset) {
+        if (isModule(part, moduleName) && part.subparsed == null) {
+          tags.push({
+            part: part,
+            offset: offset
+          });
+        }
+        return tags;
+      }, []);
+    }
+  }, {
+    key: "postparse",
+    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;
+        sects.some(function (sect, index) {
+          if (basePart.lIndex < sect[0].lIndex) {
+            if (index + 1 < sects.length && isContinuous(sects[index + 1])) {
+              basePart.addContinuousType = true;
+            }
+            return true;
+          }
+          if (parsed[0].lIndex < sect[0].lIndex && sect[0].lIndex < basePart.lIndex) {
+            if (isNextPage(sects[index])) {
+              basePart.addNextPage = {
+                index: index
+              };
+            }
+            return true;
+          }
+        });
+        basePart.lastParagrapSectPr = getLastSectPr(parsed);
+      }
+      if (!basePart || basePart.expandTo !== "auto" || basePart.module !== moduleName || !isEnclosedByParagraphs(parsed)) {
+        return parsed;
+      }
+      basePart.paragraphLoop = true;
+      var level = 0;
+      var chunks = chunkBy(parsed, function (p) {
+        if (isParagraphStart(p)) {
+          level++;
+          if (level === 1) {
+            return "start";
+          }
+        }
+        if (isParagraphEnd(p)) {
+          level--;
+          if (level === 0) {
+            return "end";
+          }
+        }
+        return null;
+      });
+      var firstChunk = chunks[0];
+      var lastChunk = last(chunks);
+      var firstOffset = getOffset(firstChunk);
+      var lastOffset = getOffset(lastChunk);
+      basePart.hasPageBreakBeginning = hasPageBreak(firstChunk);
+      basePart.hasPageBreak = hasPageBreak(lastChunk);
+      if (hasImage(firstChunk)) {
+        firstOffset = 0;
+      }
+      if (hasImage(lastChunk)) {
+        lastOffset = 0;
+      }
+      return parsed.slice(firstOffset, parsed.length - lastOffset);
+    }
+  }, {
+    key: "resolve",
+    value: function resolve(part, options) {
+      if (!isModule(part, moduleName)) {
+        return null;
+      }
+      var sm = options.scopeManager;
+      var promisedValue = sm.getValueAsync(part.value, {
+        part: part
+      });
+      var promises = [];
+      function loopOver(scope, i, length) {
+        var scopeManager = sm.createSubScopeManager(scope, part.value, i, part, length);
+        promises.push(options.resolve(_objectSpread(_objectSpread({}, options), {}, {
+          compiled: part.subparsed,
+          tags: {},
+          scopeManager: scopeManager
+        })));
+      }
+      var errorList = [];
+      return promisedValue.then(function (values) {
+        return new Promise(function (resolve) {
+          if (values instanceof Array) {
+            Promise.all(values).then(resolve);
+          } else {
+            resolve(values);
+          }
+        }).then(function (values) {
+          sm.loopOverValue(values, loopOver, part.inverted);
+          return Promise.all(promises).then(function (r) {
+            return r.map(function (_ref7) {
+              var resolved = _ref7.resolved,
+                errors = _ref7.errors;
+              errorList.push.apply(errorList, _toConsumableArray(errors));
+              return resolved;
+            });
+          }).then(function (value) {
+            if (errorList.length > 0) {
+              throw errorList;
+            }
+            return value;
+          });
+        });
+      });
+    }
+  }, {
+    key: "render",
+    value: function render(part, options) {
+      if (part.tag === "p:xfrm") {
+        this.inXfrm = part.position === "start";
+      }
+      if (part.tag === "a:ext" && this.inXfrm) {
+        this.lastExt = part;
+        return part;
+      }
+      if (!isModule(part, moduleName)) {
+        return null;
+      }
+      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") {
+        tagHeight = +getSingleAttribute(firstTag.value, "h");
+      }
+      heightOffset -= tagHeight;
+      var a16RowIdOffset = 0;
+      var insideParagraphLoop = isInsideParagraphLoop(part);
+      function loopOver(scope, i, length) {
+        heightOffset += tagHeight;
+        var scopeManager = options.scopeManager.createSubScopeManager(scope, part.value, i, part, length);
+        for (var _i8 = 0, _part$subparsed2 = part.subparsed; _i8 < _part$subparsed2.length; _i8++) {
+          var pp = _part$subparsed2[_i8];
+          if (isTagStart("a16:rowId", pp)) {
+            var val = +getSingleAttribute(pp.value, "val") + a16RowIdOffset;
+            a16RowIdOffset = 1;
+            pp.value = setSingleAttribute(pp.value, "val", val);
+          }
+        }
+        var subRendered = options.render(_objectSpread(_objectSpread({}, options), {}, {
+          compiled: part.subparsed,
+          tags: {},
+          scopeManager: scopeManager
+        }));
+        if (part.hasPageBreak && i === length - 1 && insideParagraphLoop) {
+          addPageBreakAtEnd(subRendered);
+        }
+        var isNotFirst = scopeManager.scopePathItem.some(function (i) {
+          return i !== 0;
+        });
+        if (isNotFirst) {
+          if (part.sectPrCount === 1) {
+            subRendered.parts = dropHeaderFooterRefs(subRendered.parts);
+          }
+          if (part.addContinuousType) {
+            subRendered.parts = addContinuousType(subRendered.parts);
+          }
+        } else if (part.addNextPage) {
+          subRendered.parts = addSectionBefore(subRendered.parts, self.sects[part.addNextPage.index]);
+        }
+        if (part.addNextPage) {
+          addPageBreakAtEnd(subRendered);
+        }
+        if (part.hasPageBreakBeginning && insideParagraphLoop) {
+          addPageBreakAtBeginning(subRendered);
+        }
+        for (var _i10 = 0, _subRendered$parts2 = subRendered.parts; _i10 < _subRendered$parts2.length; _i10++) {
+          var _val = _subRendered$parts2[_i10];
+          totalValue.push(_val);
+        }
+        Array.prototype.push.apply(errors, subRendered.errors);
+      }
+      var result = options.scopeManager.loopOver(part.value, loopOver, part.inverted, {
+        part: part
+      });
+      // if the loop is showing empty content
+      if (result === false) {
+        if (part.lastParagrapSectPr) {
+          if (part.paragraphLoop) {
+            return {
+              value: "<w:p><w:pPr>".concat(part.lastParagrapSectPr, "</w:pPr></w:p>")
+            };
+          }
+          return {
+            value: "</w:t></w:r></w:p><w:p><w:pPr>".concat(part.lastParagrapSectPr, "</w:pPr><w:r><w:t>")
+          };
+        }
+        return {
+          value: getPageBreakIfApplies(part) || "",
+          errors: errors
+        };
+      }
+      if (heightOffset !== 0) {
+        var cy = +getSingleAttribute(this.lastExt.value, "cy");
+        this.lastExt.value = setSingleAttribute(this.lastExt.value, "cy", cy + heightOffset);
+      }
+      return {
+        value: options.joinUncorrupt(totalValue, _objectSpread(_objectSpread({}, options), {}, {
+          basePart: part
+        })),
+        errors: errors
+      };
+    }
+  }]);
+}();
+module.exports = function () {
+  return wrapper(new LoopModule());
+};

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

@@ -0,0 +1,109 @@
+"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 traits = require("../traits.js");
+var _require = require("../doc-utils.js"),
+  isContent = _require.isContent;
+var _require2 = require("../errors.js"),
+  throwRawTagShouldBeOnlyTextInParagraph = _require2.throwRawTagShouldBeOnlyTextInParagraph,
+  getInvalidRawXMLValueException = _require2.getInvalidRawXMLValueException;
+var moduleName = "rawxml";
+var wrapper = require("../module-wrapper.js");
+function getInner(_ref) {
+  var part = _ref.part,
+    left = _ref.left,
+    right = _ref.right,
+    postparsed = _ref.postparsed,
+    index = _ref.index;
+  var paragraphParts = postparsed.slice(left + 1, right);
+  for (var i = 0, len = paragraphParts.length; i < len; i++) {
+    if (i === index - left - 1) {
+      continue;
+    }
+    var p = paragraphParts[i];
+    if (isContent(p)) {
+      throwRawTagShouldBeOnlyTextInParagraph({
+        paragraphParts: paragraphParts,
+        part: part
+      });
+    }
+  }
+  return part;
+}
+var RawXmlModule = /*#__PURE__*/function () {
+  function RawXmlModule() {
+    _classCallCheck(this, RawXmlModule);
+    this.name = "RawXmlModule";
+    this.prefix = "@";
+  }
+  return _createClass(RawXmlModule, [{
+    key: "optionsTransformer",
+    value: function optionsTransformer(options, docxtemplater) {
+      this.fileTypeConfig = docxtemplater.fileTypeConfig;
+      return options;
+    }
+  }, {
+    key: "matchers",
+    value: function matchers() {
+      return [[this.prefix, moduleName]];
+    }
+  }, {
+    key: "postparse",
+    value: function postparse(postparsed) {
+      return traits.expandToOne(postparsed, {
+        moduleName: moduleName,
+        getInner: getInner,
+        expandTo: this.fileTypeConfig.tagRawXml,
+        error: {
+          message: "Raw tag not in paragraph",
+          id: "raw_tag_outerxml_invalid",
+          explanation: function explanation(part) {
+            return "The tag \"".concat(part.value, "\" is not inside a paragraph, putting raw tags inside an inline loop is disallowed.");
+          }
+        }
+      });
+    }
+  }, {
+    key: "render",
+    value: function render(part, options) {
+      if (part.module !== moduleName) {
+        return null;
+      }
+      var value;
+      var errors = [];
+      try {
+        var _value;
+        value = options.scopeManager.getValue(part.value, {
+          part: part
+        });
+        (_value = value) !== null && _value !== void 0 ? _value : value = options.nullGetter(part);
+      } catch (e) {
+        errors.push(e);
+        return {
+          errors: errors
+        };
+      }
+      value = value ? value : "";
+      if (typeof value === "string") {
+        return {
+          value: value
+        };
+      }
+      return {
+        errors: [getInvalidRawXMLValueException({
+          tag: part.value,
+          value: value,
+          offset: part.offset
+        })]
+      };
+    }
+  }]);
+}();
+module.exports = function () {
+  return wrapper(new RawXmlModule());
+};