jspdf-dynamo 1.0.0

package/dist/index.cjs

@@ -0,0 +1,2175 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  JsPdfDynamo: () => JsPdfDynamo
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/jsPdfDynamo.ts
+var import_node_fetch = __toESM(require("node-fetch"), 1);
+
+// src/models/jsPdfProcessor.ts
+var import_jspdf = __toESM(require("jspdf"), 1);
+var fs = __toESM(require("fs"), 1);
+
+// src/models/logger.ts
+var AppLogger = class {
+  constructor(logger = null) {
+    this._logLevel = 2;
+    if (logger) {
+      this._logger = logger;
+    } else {
+      this._logger = console;
+    }
+  }
+  trace(message, ...args) {
+    this.canLog(0) ? this._logger.trace(message, args) : null;
+  }
+  debug(message, ...args) {
+    this.canLog(1) ? this._logger.debug(message, args) : null;
+  }
+  info(message, ...args) {
+    this.canLog(2) ? this._logger.info(message, args) : null;
+  }
+  warn(message, ...args) {
+    this.canLog(3) ? this._logger.warn(message, args) : null;
+  }
+  error(message, ...args) {
+    this.canLog(4) ? this._logger.error(message, args) : null;
+  }
+  logLevel(newLevel) {
+    if (typeof newLevel === "string") {
+      const level = newLevel.toLowerCase();
+      switch (level) {
+        case "trace":
+          this._logLevel = 0;
+          break;
+        case "debug":
+          this._logLevel = 1;
+          break;
+        case "info":
+          this._logLevel = 2;
+          break;
+        case "warn":
+          this._logLevel = 3;
+          break;
+        case "error":
+          this._logLevel = 4;
+          break;
+        case "silent":
+          this._logLevel = 5;
+          break;
+      }
+    } else {
+      if (newLevel >= 0 && newLevel <= 5) {
+        this._logLevel = newLevel;
+      }
+    }
+    if (this._logger.logLevel) {
+      this._logger.logLevel(this._logLevel);
+    }
+  }
+  canLog(level) {
+    return level >= this._logLevel;
+  }
+};
+
+// src/utils/utils.ts
+function removeTrailingZeros(numString) {
+  if (!numString.includes(".") || numString.includes("e") || numString.includes("E") || numString.includes("Infinity") || isNaN(Number(numString))) {
+    return numString;
+  }
+  let trimmedString = numString.trim();
+  let decimalIndex = trimmedString.indexOf(".");
+  while (trimmedString.length > decimalIndex && trimmedString.endsWith("0")) {
+    trimmedString = trimmedString.substring(0, trimmedString.length - 1);
+  }
+  if (trimmedString.endsWith(".")) {
+    return trimmedString.substring(0, trimmedString.length - 1);
+  }
+  return trimmedString;
+}
+function getNextNumber(input, maxPlaces = -1) {
+  let first = 0;
+  let rest = "";
+  if (!input) {
+    return { first, rest };
+  }
+  input = input.trimStart();
+  if (input.length === 0) {
+    return { first, rest };
+  }
+  let firstValue;
+  let ix = input.indexOf(" ");
+  if (ix < 0) {
+    firstValue = input;
+  } else {
+    firstValue = input.substring(0, ix);
+    rest = input.slice(ix).trimStart();
+  }
+  if (maxPlaces < 0) {
+    first = Number(firstValue);
+  } else {
+    first = Number(Number(firstValue).toFixed(maxPlaces));
+  }
+  return { first, rest };
+}
+function getNextString(input) {
+  let first = "";
+  let rest = "";
+  input = input.trimStart();
+  if (input.length === 0) {
+    return { first, rest };
+  }
+  let ix = input.indexOf(" ");
+  if (ix < 0) {
+    first = input;
+  } else {
+    first = input.substring(0, ix);
+    rest = input.slice(ix).trimStart();
+  }
+  return { first, rest };
+}
+function isBrowser() {
+  return typeof process === "object" && process + "" === "[object process]" ? false : true;
+}
+function pointsToMm(points) {
+  return points === null || points === void 0 ? points : Number((points * 0.352777778).toFixed(4));
+}
+function mmToPoints(mm) {
+  return mm === null || mm === void 0 ? mm : Number((mm / 0.352777778).toFixed(4));
+}
+function pointsToInches(points) {
+  return points === null || points === void 0 ? points : Number((points * 0.0138888611).toFixed(4));
+}
+function inchesToPoints(inches) {
+  return inches === null || inches === void 0 ? inches : Number((inches / 0.0138888611).toFixed(4));
+}
+function pixelsToMm(pixels, dpi = 96) {
+  return pixels === null || pixels === void 0 || isNaN(pixels) || isNaN(dpi) || dpi <= 0 ? pixels : Number((pixels * 25.4 / dpi).toFixed(4));
+}
+function pixelsToInches(pixels, dpi = 96) {
+  return pixels === null || pixels === void 0 || isNaN(pixels) || isNaN(dpi) || dpi <= 0 ? pixels : Number((pixels / dpi).toFixed(4));
+}
+function pointsToPixels(points, dpi = 96) {
+  return points === null || points === void 0 || isNaN(points) || isNaN(dpi) || dpi <= 0 ? points : Number((points * dpi / 72).toFixed(4));
+}
+function pixelsToPoints(pixels, dpi = 96) {
+  return pixels === null || pixels === void 0 || isNaN(pixels) || isNaN(dpi) || dpi <= 0 ? pixels : Number((pixels * 72 / dpi).toFixed(4));
+}
+
+// src/utils/page.utils.ts
+var pageSizes = {
+  ledger: { width: 1224.7, height: 791 },
+  legal: { width: 612, height: 1008 },
+  "junior-legal": { width: 360, height: 575.5 },
+  letter: { width: 612, height: 792 },
+  "government-letter": { width: 575.5, height: 756.9 },
+  "credit-card": { width: 153, height: 243 },
+  tabloid: { width: 792, height: 1224 },
+  a0: { width: 2383.94, height: 3370.39 },
+  a1: { width: 1683.78, height: 2383.94 },
+  a2: { width: 1190.55, height: 1683.78 },
+  a3: { width: 841.89, height: 1190.55 },
+  a4: { width: 595.28, height: 841.89 },
+  a5: { width: 419.53, height: 595.28 },
+  a6: { width: 297.64, height: 419.53 },
+  a7: { width: 209.76, height: 297.64 },
+  a8: { width: 147.4, height: 209.76 },
+  a9: { width: 104.88, height: 147.4 },
+  a10: { width: 73.7, height: 104.88 },
+  b0: { width: 2834.65, height: 4008.19 },
+  b1: { width: 2004.09, height: 2834.65 },
+  b2: { width: 1417.32, height: 2004.09 },
+  b3: { width: 1000.63, height: 1417.32 },
+  b4: { width: 708.66, height: 1000.63 },
+  b5: { width: 498.9, height: 708.66 },
+  b6: { width: 354.33, height: 498.9 },
+  b7: { width: 249.45, height: 354.33 },
+  b8: { width: 175.75, height: 249.45 },
+  b9: { width: 124.72, height: 175.75 },
+  b10: { width: 87.87, height: 124.72 },
+  c0: { width: 2599.37, height: 3676.54 },
+  c1: { width: 1836.85, height: 2599.37 },
+  c2: { width: 1298.27, height: 1836.85 },
+  c3: { width: 918.43, height: 1298.27 },
+  c4: { width: 649.13, height: 918.43 },
+  c5: { width: 459.21, height: 649.13 },
+  c6: { width: 323.15, height: 459.21 },
+  c7: { width: 229.61, height: 323.15 },
+  c8: { width: 161.57, height: 229.61 },
+  c9: { width: 113.39, height: 161.57 },
+  c10: { width: 79.37, height: 113.39 },
+  dl: { width: 311.81, height: 623.62 }
+};
+function isValidPageSize(pageSize) {
+  return pageSizes.hasOwnProperty(pageSize);
+}
+
+// src/utils/types.ts
+function isValidFontStyle(fontStyle) {
+  return ["bold", "italic", "normal", "bolditalic"].includes(fontStyle);
+}
+
+// src/models/jsPdfOptions.ts
+var JsPdfOptions = class {
+  constructor(options = {}) {
+    var _a, _b, _c;
+    this.pageSize = ((_a = options.pageSize) == null ? void 0 : _a.toLocaleLowerCase()) || "a4";
+    this.orientation = ((_b = options.orientation) == null ? void 0 : _b.toLocaleLowerCase()) || "portrait";
+    this.unit = ((_c = options.unit) == null ? void 0 : _c.toLocaleLowerCase()) || "mm";
+    let defaultMargin;
+    switch (this.unit) {
+      case "mm":
+        defaultMargin = 10;
+        break;
+      case "in":
+        defaultMargin = 0.4;
+        break;
+      case "pt":
+        defaultMargin = 28;
+        break;
+    }
+    this.margins = Object.assign(
+      {
+        top: defaultMargin,
+        bottom: defaultMargin,
+        left: defaultMargin,
+        right: defaultMargin
+      },
+      options.margins
+    );
+  }
+};
+
+// src/models/jsPdfProcessor.ts
+var JsPdfProcessor = class {
+  constructor(options, logger) {
+    this._variables = /* @__PURE__ */ new Map();
+    this._bookmarks = [];
+    this._images = [];
+    this._currentPageNumber = 0;
+    this._currentUom = "mm";
+    this._fillColour = "white";
+    this._fontHeight = 0;
+    this._fontName = "helvetica";
+    this._fontPointSize = 0;
+    this._fontStyle = "normal";
+    this._lastError = "";
+    this._lastImageAdded = "";
+    this._LastImageIndex = -1;
+    this._lastResult = "";
+    this._lineColour = "black";
+    this._lineWidth = 0.5;
+    this._logLevel = 2;
+    this._pageHeight = 0;
+    this._pageWidth = 0;
+    this._pageOrientation = "portrait";
+    this._pageSize = "a4";
+    this._marginBottom = 0;
+    this._marginBottomPt = 0;
+    this._marginTop = 0;
+    this._marginTopPt = 0;
+    this._marginLeft = 0;
+    this._marginLeftPt = 0;
+    this._marginRight = 0;
+    this._marginRightPt = 0;
+    this._lastObjectHeight = 0;
+    this._lastObjectWidth = 0;
+    this._posnX = 0;
+    this._posnY = 0;
+    this._spaceHoz = 0;
+    this._spaceVert = 0;
+    this._textColour = "";
+    this.logAndParseCommand = (command, input) => {
+      const result = this.substitute(input);
+      this._logger.debug(command + " " + result);
+      return result;
+    };
+    this._logger = logger;
+    const optn = new JsPdfOptions(options);
+    this._pdfDocument = new import_jspdf.default(optn);
+    this.pageSize = optn.pageSize;
+    this.pageOrientation = optn.orientation;
+    this.currentUom = optn.unit;
+    this._pdfDocument.setLineHeightFactor(1);
+    this._variables.set(
+      "_TIMEHM",
+      (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+        hour12: false,
+        hour: "2-digit",
+        minute: "2-digit"
+      })
+    );
+    this._variables.set("_DATEDMY", (/* @__PURE__ */ new Date()).toLocaleDateString("en-GB"));
+    this._variables.set("_PAGENO", "1");
+    this._variables.set("_PAGES", "1");
+    this.spaceHoz = 0;
+    this.spaceVert = 0;
+    this.lineWidth = this.pointsToUom(mmToPoints(0.2));
+    this.lineColour = "black";
+    this.fontPointSize = 12;
+    this.fontName = "helvetica";
+    this.textColour = "black";
+    this.fillColour = "white";
+    this.marginTop = this.pixelsToUom(40);
+    this.marginLeft = this.marginTop;
+    this.marginBottom = this.marginTop;
+    this.marginRight = this.marginTop;
+  }
+  get PdfDocument() {
+    return this._pdfDocument;
+  }
+  get currentPageNumber() {
+    return this._currentPageNumber;
+  }
+  set currentPageNumber(value) {
+    if (isNaN(value)) {
+      this.lastResult = "0";
+      this.lastError = "Page number must be a number, received 'NaN'";
+      return;
+    }
+    if (value !== Math.floor(value)) {
+      this.lastResult = "0";
+      this.lastError = "Page number must be an integer";
+      return;
+    }
+    if (value < 0) {
+      this.lastResult = "0";
+      this.lastError = "Page number must be greater than 0";
+      return;
+    }
+    if (value > this.pageCount) {
+      this.lastResult = "0";
+      this.lastError = `Page number ${value} is greater than the number of pages`;
+      return;
+    }
+    this._currentPageNumber = value;
+    this._variables.set("_PAGENO", value.toString());
+    this.calcPageDimensions(this._pdfDocument);
+  }
+  get currentUom() {
+    return this._currentUom;
+  }
+  set currentUom(value) {
+    if (this._currentUom !== value) {
+      this._currentUom = value;
+    }
+  }
+  get fillColour() {
+    return this._fillColour;
+  }
+  set fillColour(value) {
+    this._fillColour = value.toLocaleLowerCase();
+    this._pdfDocument.setFillColor(this._fillColour);
+    this._variables.set("_FILLCOLOUR", this._fillColour);
+  }
+  get fontHeight() {
+    return this._fontHeight;
+  }
+  set fontHeight(value) {
+    this._fontHeight = value;
+    this._variables.set("_FONTHEIGHT", this.setFixedDec(value, 3));
+  }
+  get fontName() {
+    return this._fontName;
+  }
+  set fontName(value) {
+    this._fontName = value;
+    this.setCurrentFont(this.fontName, this.fontStyle);
+    this._variables.set("_FONTNAME", value);
+  }
+  get fontPointSize() {
+    return this._fontPointSize;
+  }
+  set fontPointSize(value) {
+    if (!value) {
+      this.lastError = "Font point size is required";
+      this.lastResult = "0";
+      return;
+    }
+    if (isNaN(Number(value))) {
+      this.lastError = "Font point size must be a number, received 'NaN'";
+      this.lastResult = "0";
+      return;
+    }
+    if (value <= 0) {
+      this.lastError = "Font point size must be greater than 0";
+      this.lastResult = "0";
+      return;
+    }
+    this._fontPointSize = value;
+    this._pdfDocument.setFontSize(value);
+    this.fontHeight = this.pointsToUom(value) * this.lineHeightFactor;
+    this._variables.set("_FONTPOINTSIZE", value.toString());
+  }
+  get lineHeightFactor() {
+    return this._pdfDocument["getLineHeightFactor"] ? this._pdfDocument["getLineHeightFactor"]() : 1.15;
+  }
+  get fontStyle() {
+    return this._fontStyle;
+  }
+  set fontStyle(value) {
+    this._fontStyle = value;
+    this.setCurrentFont(this.fontName, this.fontStyle);
+    this._variables.set("_FONTSTYLE", value);
+  }
+  get lastError() {
+    return this._lastError;
+  }
+  set lastError(value) {
+    this._lastError = value;
+    if (value !== "") {
+      this._logger.warn(value);
+    }
+  }
+  get lastImageAdded() {
+    return this._lastImageAdded;
+  }
+  set lastImageAdded(value) {
+    this._lastImageAdded = value;
+    this._variables.set("_LASTIMAGEADDED", value);
+  }
+  get lastImageIndex() {
+    return this._LastImageIndex;
+  }
+  set lastImageIndex(value) {
+    this._LastImageIndex = value;
+    this._variables.set("_LASTIMAGEINDEX", value.toString());
+  }
+  get lastResult() {
+    return this._lastResult;
+  }
+  set lastResult(value) {
+    this._lastResult = value;
+    this._variables.set("_LASTRESULT", value);
+  }
+  get lineColour() {
+    return this._lineColour;
+  }
+  set lineColour(value) {
+    this._lineColour = value.toLocaleLowerCase();
+    this._pdfDocument.setDrawColor(this._lineColour);
+    this._variables.set("_LINECOLOUR", this._lineColour);
+  }
+  get lineWidth() {
+    return this._lineWidth;
+  }
+  set lineWidth(value) {
+    this._logger.trace(`Setting line width to ${value}`);
+    this._lineWidth = value;
+    this._pdfDocument.setLineWidth(value);
+    this._variables.set("_LINEWIDTH", value.toString());
+  }
+  get pageHeight() {
+    return this._pageHeight;
+  }
+  set pageHeight(value) {
+    this._pageHeight = value;
+    this._variables.set("_PAGEHEIGHT", this.setFixedDec(value));
+  }
+  get pageWidth() {
+    return this._pageWidth;
+  }
+  set pageWidth(value) {
+    this._pageWidth = value;
+    this._variables.set("_PAGEWIDTH", this.setFixedDec(value));
+  }
+  get pageOrientation() {
+    return this._pageOrientation;
+  }
+  set pageOrientation(value) {
+    this._pageOrientation = value;
+    this._variables.set("_CURRENTPAGEORIENTATION", value);
+    this.calcPageDimensions(this.PdfDocument);
+  }
+  get pageSize() {
+    return this._pageSize;
+  }
+  set pageSize(value) {
+    if (!isValidPageSize(value)) {
+      this.lastError = "Invalid page size '" + value + "'";
+      this.lastResult = "0";
+      return;
+    }
+    this._pageSize = value;
+    this._variables.set("_CURRENTPAGESIZE", value);
+    this.calcPageDimensions(this.PdfDocument);
+  }
+  get marginBottom() {
+    return this._marginBottom;
+  }
+  set marginBottom(value) {
+    this._marginBottom = value > 0 ? value : 0;
+    this._marginBottomPt = this.uomToPoints(value);
+    this.calcPageDimensions(this.PdfDocument);
+    this._variables.set("_MARGINBOTTOM", value.toString());
+  }
+  get marginTop() {
+    return this._marginTop;
+  }
+  set marginTop(value) {
+    this._marginTop = value > 0 ? value : 0;
+    this._marginTopPt = this.uomToPoints(value);
+    this.calcPageDimensions(this.PdfDocument);
+    this._variables.set("_MARGINTOP", value.toString());
+  }
+  get marginLeft() {
+    return this._marginLeft;
+  }
+  set marginLeft(value) {
+    this._marginLeft = value > 0 ? value : 0;
+    this._marginLeftPt = this.uomToPoints(value);
+    this.calcPageDimensions(this.PdfDocument);
+    this._variables.set("_MARGINLEFT", value.toString());
+  }
+  get marginRight() {
+    return this._marginRight;
+  }
+  set marginRight(value) {
+    this._marginRight = value > 0 ? value : 0;
+    this._marginRightPt = this.uomToPoints(value);
+    this.calcPageDimensions(this.PdfDocument);
+    this._variables.set("_MARGINRIGHT", value.toString());
+  }
+  get lastObjectHeight() {
+    return this._lastObjectHeight;
+  }
+  set lastObjectHeight(value) {
+    this._lastObjectHeight = value;
+    this._variables.set("_LASTOBJECTHEIGHT", this.setFixedDec(value));
+  }
+  get lastObjectWidth() {
+    return this._lastObjectWidth;
+  }
+  set lastObjectWidth(value) {
+    this._lastObjectWidth = value;
+    this._variables.set("_LASTOBJECTWIDTH", this.setFixedDec(value));
+  }
+  get posnX() {
+    return this._posnX;
+  }
+  set posnX(value) {
+    this._posnX = value > 0 ? value : 0;
+    this._variables.set("_CURRENTX", this.setFixedDec(this.posnX));
+  }
+  get posnY() {
+    return this._posnY;
+  }
+  set posnY(value) {
+    this._posnY = value > 0 ? value : 0;
+    this._variables.set("_CURRENTY", this.setFixedDec(this._posnY));
+  }
+  get spaceHoz() {
+    return this._spaceHoz;
+  }
+  set spaceHoz(value) {
+    this._spaceHoz = value > 0 ? value : 0;
+    this._variables.set("_SPACEHOZ", this.setFixedDec(value));
+  }
+  get spaceVert() {
+    return this._spaceVert;
+  }
+  set spaceVert(value) {
+    this._spaceVert = value > 0 ? value : 0;
+    this._variables.set("_SPACEVERT", this.setFixedDec(value, 3));
+  }
+  get textColour() {
+    return this._textColour;
+  }
+  set textColour(value) {
+    this._textColour = value.toLocaleLowerCase();
+    this._variables.set("_TEXTCOLOUR", this._textColour);
+    this._pdfDocument.setTextColor(this._textColour);
+  }
+  get pageCount() {
+    return this._pdfDocument ? this._pdfDocument.internal.getNumberOfPages() : -1;
+  }
+  addBookmark(input) {
+    const subs = this.logAndParseCommand(".addBookmark", input);
+    const { first: parent, rest: rest1 } = getNextNumber(subs);
+    const { first: page, rest: title } = getNextNumber(rest1);
+    if (title === "") {
+      this.lastError = "A bookmark title is required.";
+      this.lastResult = "0";
+      return;
+    }
+    if (parent && isNaN(parent)) {
+      this.lastError = `The parent Id '${parent}' must be a number.`;
+      this.lastResult = "0";
+      return;
+    }
+    if (parent < 0 || this._bookmarks.length > 0 && parent > this._bookmarks.length - 1) {
+      this.lastError = `The parent Id is out of range of 0 to ${this._bookmarks.length - 1}`;
+      this.lastResult = "0";
+      return;
+    }
+    if (isNaN(page)) {
+      this.lastError = "Page must be a number";
+      this.lastResult = "0";
+      return;
+    }
+    if (this._bookmarks.length === 0) {
+      this._bookmarks.push({ title: "Root", options: {}, children: [] });
+    }
+    const outlineParent = parent === 0 ? null : this._bookmarks[parent];
+    const bookmark = this._pdfDocument.outline.add(
+      outlineParent,
+      title,
+      { pageNumber: page }
+    );
+    if (bookmark === null) {
+      this.lastError = "Error adding bookmark";
+      this.lastResult = "0";
+      return;
+    }
+    this.lastResult = this._bookmarks.length.toString();
+    this._bookmarks.push(bookmark);
+    if (!outlineParent && this._bookmarks[0]) {
+      this._bookmarks[0].children.push(bookmark);
+    }
+  }
+  addPage(input = "") {
+    let subs = this.logAndParseCommand(".addPage", input);
+    let { first: pageSize, rest: rest1 } = getNextString(subs);
+    let { first: pageOrientation } = getNextString(rest1);
+    pageSize = pageSize.toLocaleLowerCase();
+    pageOrientation = pageOrientation.toLocaleLowerCase();
+    if (pageSize !== "") {
+      this.setPageSize(pageSize);
+      if (this.lastResult === "0") {
+        return;
+      }
+    }
+    if (pageOrientation !== "") {
+      this.setPageOrientation(pageOrientation);
+      if (this.lastResult === "0") {
+        return;
+      }
+    }
+    this._pdfDocument.addPage(this.pageSize, this.pageOrientation);
+    this.posnX = 0;
+    this.posnY = 0;
+    this._variables.set("_PAGES", this.pageCount.toString());
+    this.currentPageNumber = this.pageCount;
+    this.calcPageDimensions(this._pdfDocument);
+  }
+  calcPageDimensions(document) {
+    if (!document) {
+      this.pageHeight = 0;
+      this.pageWidth = 0;
+    } else {
+      this.pageHeight = document.internal.pageSize.height - this._marginTop - this._marginBottom;
+      this.pageWidth = document.internal.pageSize.width - this._marginLeft - this._marginRight;
+    }
+  }
+  addImageFromFile(input) {
+    const subs = this.logAndParseCommand(".addImageFromFile", input);
+    let fileName = subs;
+    if (!fileName) {
+      this.lastError = "A file name is required.";
+      this.lastResult = "0";
+      return;
+    }
+    if (!fs.existsSync(fileName)) {
+      this.lastError = "File '" + fileName + "' cannot be found or accessed.";
+      this.lastResult = "0";
+      return;
+    }
+    try {
+      const image = fs.readFileSync(fileName);
+      this.saveImage(image, this.getContentType(fileName));
+      this.lastResult = "1";
+    } catch (ex) {
+      this.lastError = "Error reading file '" + fileName + "'.";
+      this.lastResult = "0";
+    }
+  }
+  addImageFromUrl(input) {
+    return __async(this, null, function* () {
+      const subs = this.logAndParseCommand(".addImageFromUrl", input);
+      let url = subs;
+      if (!url) {
+        this.lastError = "A URL is required.";
+        this.lastResult = "0";
+        return;
+      }
+      try {
+        const response = yield fetch(url, {
+          headers: { Accept: "image/*, */*;q=0.8" }
+        });
+        if (!response.ok) {
+          this.lastError = "Error reading image '" + url + "'.";
+          this.lastResult = "0";
+          return;
+        }
+        const arrayBuffer = yield response.arrayBuffer();
+        const imageBuffer = Buffer.from(arrayBuffer);
+        const mediaType = response.headers.get("content-type") || "image/png";
+        this.saveImage(imageBuffer, mediaType);
+        this.lastResult = "1";
+      } catch (ex) {
+        this.lastError = "Error reading file '" + url + "'";
+        this.lastResult = "0";
+      }
+    });
+  }
+  saveImage(imageBuffer, mediaType) {
+    const base64Image = imageBuffer.toString("base64");
+    const image = "data:" + mediaType + ";base64," + base64Image;
+    this.lastImageAdded = this._images.length.toString();
+    this._images.push(image);
+    const info = this._pdfDocument.getImageProperties(image);
+    this._variables.set(
+      "_IMAGEWIDTH",
+      this.setFixedDec(this.pixelsToUom(info.width), 3)
+    );
+    this._variables.set("_IMAGEWIDTHPX", info.width.toString());
+    this._variables.set(
+      "_IMAGEHEIGHT",
+      this.setFixedDec(this.pixelsToUom(info.height), 3)
+    );
+    this._variables.set("_IMAGEHEIGHTPX", info.height.toString());
+  }
+  getContentType(fileName) {
+    const mediaType = fileName.split(".").pop();
+    return mediaType ? "image/" + mediaType : "";
+  }
+  checkPage(jsPdfDynamo, input) {
+    return __async(this, null, function* () {
+      const subs = this.logAndParseCommand(".checkPage", input);
+      const { first: overflow, rest } = getNextNumber(subs);
+      if (this.posnY > this._pageHeight - overflow) {
+        this._logger.debug(
+          `* End of page detected at PosnVert: ${this.posnY}, PageHeight: ${this._pageHeight} Overflow: ${overflow}`
+        );
+        if (rest.length === 0) {
+          this.addPage();
+        } else {
+          yield jsPdfDynamo.processGroups(this, rest, false);
+        }
+      }
+    });
+  }
+  drawBox(input) {
+    const subs = this.logAndParseCommand(".drawBox", input);
+    const { first: left, rest: rest1 } = getNextNumber(subs);
+    const { first: top, rest: rest2 } = getNextNumber(rest1);
+    const { first: width, rest: rest3 } = getNextNumber(rest2);
+    const { first: height, rest: rest4 } = getNextNumber(rest3);
+    const { first: boxType } = getNextNumber(rest4);
+    if (!this.checkPosition(left, top)) {
+      return;
+    }
+    this.posnX = left;
+    this.posnY = top;
+    let lineWidthAdjustment = this._lineWidth;
+    let linePosnAdjustment = lineWidthAdjustment * 0.5;
+    const x = this.posnX - linePosnAdjustment + this._marginLeft;
+    const y = this.posnY - linePosnAdjustment + this._marginTop;
+    const w = width + lineWidthAdjustment * 2;
+    const h = height + lineWidthAdjustment * 2;
+    let style = "S";
+    switch (boxType) {
+      case 0:
+        break;
+      case 1:
+        style = "F";
+        this._pdfDocument.setFillColor(this.fillColour);
+        break;
+      case 2:
+        style = "FD";
+        this._pdfDocument.setFillColor(this.fillColour);
+        break;
+    }
+    this._pdfDocument.rect(x, y, w, h, style);
+    this.posnX = this.posnX + width + this.spaceHoz;
+    this.posnY = this.posnY + height + this.spaceVert;
+    this.lastObjectHeight = height;
+    this.lastObjectWidth = width;
+    this.lastResult = "1";
+  }
+  drawDebugGrid(input) {
+    const subs = this.logAndParseCommand(".drawDebugGrid", input);
+    const savedLineColour = this.lineColour;
+    const savedLineWidth = this.lineWidth;
+    const mm = 0.1;
+    const pts = mmToPoints(mm);
+    const lineWidth = this.pointsToUom(pts);
+    this.lineWidth = lineWidth;
+    this.lineColour = "lightgrey";
+    let offsetLeft = this._marginLeft;
+    let offsetTop = this._marginTop;
+    let offsetRight = this._marginRight;
+    let offsetBottom = this._marginBottom;
+    if (subs.toLocaleUpperCase().startsWith("P")) {
+      offsetLeft = 0;
+      offsetTop = 0;
+      offsetRight = 0;
+      offsetBottom = 0;
+    } else {
+      this.drawBox(`0 0 ${this._pageWidth} ${this._pageHeight} 0`);
+    }
+    let step = 30;
+    switch (this.currentUom) {
+      case "in" /* in */:
+        step = 0.5;
+        break;
+      case "mm" /* mm */:
+        step = 10;
+        break;
+    }
+    let width = this._pdfDocument.internal.pageSize.width - offsetLeft - offsetRight;
+    let height = this._pdfDocument.internal.pageSize.height - offsetTop - offsetBottom;
+    let currX = step;
+    let counter = 0;
+    while (currX < width) {
+      counter++;
+      this.lineWidth = this.currentUom === "in" /* in */ && counter % 2 === 0 ? lineWidth * 4 : lineWidth;
+      this._pdfDocument.line(
+        currX + offsetLeft,
+        offsetTop,
+        currX + offsetLeft,
+        height + offsetTop
+      );
+      currX = counter * step;
+    }
+    let currY = step;
+    counter = 0;
+    while (currY < height) {
+      counter++;
+      this.lineWidth = this.currentUom === "in" /* in */ && counter % 2 === 0 ? lineWidth * 4 : lineWidth;
+      this._pdfDocument.line(
+        offsetLeft,
+        currY + offsetTop,
+        width + offsetLeft,
+        currY + offsetTop
+      );
+      currY = counter * step;
+    }
+    this.lineColour = savedLineColour;
+    this.lineWidth = savedLineWidth;
+  }
+  drawLine(input) {
+    const subs = this.logAndParseCommand(".drawLine", input);
+    const { first: left, rest: rest1 } = getNextNumber(subs);
+    const { first: top, rest: rest2 } = getNextNumber(rest1);
+    const { first: right, rest: rest3 } = getNextNumber(rest2);
+    const { first: bottom } = getNextNumber(rest3);
+    if (!this.checkPosition(left, top) && !this.checkPosition(right, bottom)) {
+      return;
+    }
+    this._pdfDocument.line(
+      left + this._marginLeft,
+      top + this._marginTop,
+      right + this._marginLeft,
+      bottom + this._marginTop
+    );
+    this.lastObjectHeight = bottom - top;
+    this.lastObjectWidth = right - left;
+    this.lastResult = "1";
+  }
+  drawImage(input) {
+    const subs = this.logAndParseCommand(".drawImage", input);
+    const { first: imageNo, rest: rest1 } = getNextNumber(subs);
+    const { first: left, rest: rest2 } = getNextNumber(rest1);
+    const { first: top, rest: rest3 } = getNextNumber(rest2);
+    let { first: width, rest: rest4 } = getNextNumber(rest3);
+    let { first: height, rest: rest5 } = getNextNumber(rest4);
+    let { first: scale } = getNextNumber(rest5);
+    if (!subs) {
+      this.lastError = "An image number must be supplied";
+      this.lastResult = "0";
+      return;
+    }
+    if (this._images.length === 0) {
+      this.lastError = "No images have been loaded yet";
+      this.lastResult = "0";
+      return;
+    }
+    if (isNaN(imageNo) || imageNo < 0 || imageNo > this._images.length - 1) {
+      this.lastError = this._images.length ? "The image number must be in the range of 0 to " + (this._images.length - 1).toString() : "Only one image has been loaded, the image number can only be 0";
+      this.lastResult = "0";
+      return;
+    }
+    if (!this.checkPosition(left, top)) {
+      return;
+    }
+    const currentImage = this._images[imageNo];
+    if (!currentImage) {
+      this.lastError = "The image number is not valid!";
+      this.lastResult = "0";
+      return;
+    }
+    const info = this._pdfDocument.getImageProperties(currentImage);
+    if (scale === 0 && (width === 0 && height > 0 || width > 0 && height === 0)) {
+      scale = width === 0 ? this.pixelsToUom(info.height) / height : this.pixelsToUom(info.width) / width;
+      height = height === 0 ? this.pixelsToUom(info.height) / scale : height;
+      width = width === 0 ? this.pixelsToUom(info.width) / scale : width;
+    } else {
+      scale = scale === 0 ? 1 : scale;
+      height = height === 0 ? this.pixelsToUom(info.height) : height;
+      width = width === 0 ? this.pixelsToUom(info.width) : width;
+      height = height * scale;
+      width = width * scale;
+    }
+    if (width + left > this._pageWidth) {
+      this.lastError = `The image width ${width} plus the left position ${left} is greater than the page width ${this._pageWidth}`;
+      this.lastResult = "0";
+      return;
+    }
+    if (height + top > this._pageHeight) {
+      this.lastError = `The image height ${height} plus the top position ${top} is greater than the page height ${this._pageHeight}`;
+      this.lastResult = "0";
+      return;
+    }
+    this._pdfDocument.addImage(
+      currentImage,
+      info.format,
+      left + this._marginLeft,
+      top + this._marginTop,
+      width,
+      height
+    );
+    this.posnX = left + width + this.spaceHoz;
+    this.posnY = top + height + this.spaceVert;
+    this.lastImageIndex = imageNo;
+    this.lastObjectHeight = height;
+    this.lastObjectWidth = width;
+    this.lastResult = "1";
+  }
+  drawText(input) {
+    const subs = this.logAndParseCommand(".drawText", input);
+    const { first: left, rest: rest1 } = getNextNumber(subs);
+    const { first: top, rest: rest2 } = getNextNumber(rest1);
+    if (!this.checkPosition(left, top)) {
+      return;
+    }
+    const maxWidth = this.pageWidth - left;
+    const lines = this._pdfDocument.splitTextToSize(rest2, maxWidth);
+    this.lastObjectWidth = 0;
+    this.lastResult = "1";
+    if (lines.length > 1) {
+      this.lastError = "Text was truncated to fit within the available width";
+      this.lastResult = "0";
+      if (lines[0]) {
+        if (this._pdfDocument.getTextWidth(lines[0]) < maxWidth) {
+          lines[0] += "...";
+        } else if (lines[0].length > 3) {
+          lines[0] = lines[0].substring(0, lines[0].length - 3) + "...";
+        }
+      }
+    }
+    if (lines.length > 0) {
+      this._pdfDocument.text(
+        lines[0] ? lines[0].trimEnd() : "",
+        left + this._marginLeft,
+        top + this._marginTop + this.fontHeight * 0.5 / this.lineHeightFactor,
+        { baseline: "middle" }
+      );
+      this.lastObjectWidth = this._pdfDocument.getTextWidth(
+        lines[0] ? lines[0].trimEnd() : ""
+      );
+    }
+    this.lastObjectHeight = this.fontHeight * this.lineHeightFactor;
+    this.posnX = left + this.lastObjectWidth + this.spaceHoz;
+    this.posnY = top + this.lastObjectHeight + this.spaceVert;
+  }
+  checkPosition(left, top) {
+    if (isNaN(left)) {
+      this.lastError = `Horizontal position '${left}' is not a number`;
+      this.lastResult = "0";
+      return false;
+    }
+    if (isNaN(top)) {
+      this.lastError = `Vertical position '${top}' is not a number`;
+      this.lastResult = "0";
+      return false;
+    }
+    if (left < 0 || top < 0) {
+      this.lastError = "Neither the horizontal nor vertical positions can be negative";
+      this.lastResult = "0";
+      return false;
+    }
+    if (left > this._pageWidth) {
+      this.lastError = `Horizontal position ${left} is greater than the available page width ${this._pageWidth}`;
+      this.lastResult = "0";
+      return false;
+    }
+    if (top > this._pageHeight) {
+      this.lastError = `Vertical position ${top} is greater than the page height ${this._pageHeight}`;
+      this.lastResult = "0";
+      return false;
+    }
+    return true;
+  }
+  drawTextBox(input) {
+    const subs = this.logAndParseCommand(".drawTextBox", input);
+    const { first: left, rest: rest1 } = getNextNumber(subs);
+    const { first: top, rest: rest2 } = getNextNumber(rest1);
+    const { first: width, rest: rest3 } = getNextNumber(rest2);
+    const { first: height, rest: rest4 } = getNextNumber(rest3);
+    let { first: alignH, rest: rest5 } = getNextString(rest4);
+    let { first: alignV, rest: text } = getNextString(rest5);
+    if (!this.checkPosition(left, top)) {
+      return;
+    }
+    if (width <= 0) {
+      this.lastError = "Width must be greater than 0.";
+      this.lastResult = "0";
+      return;
+    }
+    if (height <= 0) {
+      this.lastError = "Height must be greater than 0.";
+      this.lastResult = "0";
+      return;
+    }
+    if (left + width > this.pageWidth) {
+      this.lastError = `Left position (${left}) plus width (${width}) is greater than the page width (${this.pageWidth}).`;
+      this.lastResult = "0";
+      return;
+    }
+    if (top + height > this.pageHeight) {
+      this.lastError = `Top position (${top}) plus height (${height}) is greater than the page height (${this.pageHeight}).`;
+      this.lastResult = "0";
+      return;
+    }
+    alignH = alignH.toLocaleLowerCase().trim();
+    if (alignH === "") {
+      this.lastError = "Horizontal alignment is required.";
+      this.lastResult = "0";
+      return;
+    }
+    alignV = alignV.toLocaleLowerCase().trim();
+    if (alignV === "") {
+      this.lastError = "Vertical alignment is required";
+      this.lastResult = "0";
+      return;
+    }
+    if (text === "") {
+      this.lastError = "Text is required.";
+      this.lastResult = "0";
+      return;
+    }
+    let horzAlign = "center";
+    let horzAdjust = 0;
+    let vertAlign = "top";
+    switch (alignH.substring(0, 1)) {
+      case "l":
+        horzAlign = "left";
+        break;
+      case "r":
+        horzAlign = "right";
+        horzAdjust = width;
+        break;
+      case "c":
+        horzAlign = "center";
+        horzAdjust = width * 0.5;
+        break;
+      default:
+        this.lastError = `Invalid horizontal alignment value '${alignH}'.`;
+        this.lastResult = "0";
+        return;
+    }
+    switch (alignV.substring(0, 1)) {
+      case "t":
+        vertAlign = "top";
+        break;
+      case "c":
+        vertAlign = "center";
+        break;
+      case "b":
+        vertAlign = "bottom";
+        break;
+      default:
+        this.lastError = `Invalid vertical alignment value '${alignV}'.`;
+        this.lastResult = "0";
+        return;
+    }
+    const lines = this._pdfDocument.splitTextToSize(text, width);
+    let textHeight = this.fontHeight * lines.length;
+    while (textHeight > height) {
+      this._logger.warn(
+        `Text does not fit within the box, dropped '${lines[lines.length - 1]}'`
+      );
+      lines.pop();
+      textHeight = this.fontHeight * lines.length * this.lineHeightFactor;
+    }
+    if (lines.length === 0) {
+      this.lastError = "Text cannot fit within the box";
+      this.lastResult = "0";
+      return;
+    }
+    let adjustTop = 0;
+    if (vertAlign === "center") {
+      adjustTop = (height - textHeight) / 2;
+    } else if (vertAlign === "bottom") {
+      adjustTop = height - textHeight;
+    }
+    this._pdfDocument.text(
+      lines,
+      left + this._marginLeft + horzAdjust,
+      top + this._marginTop + adjustTop + this.fontHeight * 0.5 / this.lineHeightFactor,
+      { align: horzAlign, baseline: "middle" }
+    );
+    this.lastObjectHeight = height;
+    this.lastObjectWidth = width;
+    this.posnX = left + this.lastObjectWidth + this.spaceHoz;
+    this.posnY = top + this.lastObjectHeight + this.spaceVert;
+    this.lastResult = "1";
+  }
+  drawTextWrapped(jsPdfDynamo, input) {
+    return __async(this, null, function* () {
+      const subs = this.logAndParseCommand(".drawTextWrapped", input);
+      const { first: left, rest: rest1 } = getNextNumber(subs);
+      const { first: top, rest: rest2 } = getNextNumber(rest1);
+      const { first: maxWidth, rest: rest3 } = getNextNumber(rest2);
+      let { first: cmdGroup, rest: text } = getNextString(rest3);
+      if (!this.checkPosition(left, top)) {
+        return;
+      }
+      if (maxWidth <= 0) {
+        this.lastError = "Maximum width must be greater than 0";
+        this.lastResult = "0";
+        return;
+      }
+      if (text === "") {
+        this.lastError = "No text has been provided";
+        this.lastResult = "0";
+        return;
+      }
+      let lastObjectHeight = 0;
+      text = text.replace("\\n", " \n").replace("\\N", " \n") + " ";
+      this.posnY = top;
+      const lines = this._pdfDocument.splitTextToSize(text, maxWidth) || [];
+      this._logger.trace(`Text was wrapped into ${lines.length} lines`, lines);
+      while (lines.length > 0) {
+        if (!cmdGroup.startsWith("*")) {
+          yield jsPdfDynamo.processGroups(this, cmdGroup, false);
+        }
+        this.drawText(
+          `${left.toFixed(2)} ${this.posnY.toFixed(2)} ${lines[0] ? lines[0].trimEnd() : ""}`
+        );
+        lines.shift();
+        lastObjectHeight += this.fontHeight * this.lineHeightFactor;
+        if (this.posnY > this.pageHeight && text !== "" && cmdGroup.startsWith("*")) {
+          this.addPage();
+          this.posnY = 0;
+        }
+      }
+      this.posnX = left + maxWidth + this.spaceHoz;
+      this.lastObjectHeight = lastObjectHeight;
+      this.lastObjectWidth = maxWidth;
+    });
+  }
+  forEachPage(jsPdfDynamo, input) {
+    return __async(this, null, function* () {
+      const subs = this.logAndParseCommand(".forEachPage", input);
+      for (let ix = 1; ix <= this.pageCount; ix++) {
+        this._pdfDocument.setPage(ix);
+        this.currentPageNumber = ix;
+        yield jsPdfDynamo.processGroups(this, subs);
+      }
+      this.lastResult = "1";
+    });
+  }
+  ifBlank(jsPdfDynamo, input) {
+    return __async(this, null, function* () {
+      let { first: variable, rest } = getNextString(input);
+      let subs = this.substitute(rest.trim());
+      this._logger.debug(".ifBlank " + variable + " " + subs);
+      let value = this._variables.get(variable.toLocaleUpperCase()) || "";
+      this.lastResult = "-1";
+      if (value.trim() === "") {
+        yield jsPdfDynamo.processDot(this, rest);
+      }
+    });
+  }
+  ifEq(jsPdfDynamo, input) {
+    return __async(this, null, function* () {
+      const { first: value1, rest: rest1 } = getNextString(input);
+      const { first: value2, rest: rest2 } = getNextString(rest1);
+      const subs = this.substitute(rest2.trim());
+      this._logger.debug(`.ifEq ${value1} ${value2} ${subs}`);
+      const variable1 = this.substitute(value1);
+      const variable2 = this.substitute(value2);
+      this.lastResult = "0";
+      if (!Number(variable1) || !Number(variable2)) {
+        let compareResult = variable1.localeCompare(variable2);
+        if (compareResult === 0) {
+          yield jsPdfDynamo.processDot(this, subs);
+        }
+      } else {
+        if (Number(variable1) === Number(variable2)) {
+          yield jsPdfDynamo.processDot(this, subs);
+        }
+      }
+    });
+  }
+  ifNe(jsPdfDynamo, input) {
+    return __async(this, null, function* () {
+      const { first: value1, rest: rest1 } = getNextString(input);
+      const { first: value2, rest: rest2 } = getNextString(rest1);
+      const subs = this.substitute(rest2.trim());
+      this._logger.debug(`.ifNe ${value1} ${value2} ${subs}`);
+      const variable1 = this.substitute(value1);
+      const variable2 = this.substitute(value2);
+      this.lastResult = "0";
+      if (!Number(variable1) || !Number(variable2)) {
+        let compareResult = variable1.localeCompare(variable2);
+        if (compareResult !== 0) {
+          yield jsPdfDynamo.processDot(this, subs);
+        }
+      } else {
+        if (Number(variable1) !== Number(variable2)) {
+          yield jsPdfDynamo.processDot(this, subs);
+        }
+      }
+    });
+  }
+  ifGt(jsPdfDynamo, input) {
+    return __async(this, null, function* () {
+      const { first: value1, rest: rest1 } = getNextString(input);
+      const { first: value2, rest: rest2 } = getNextString(rest1);
+      const subs = this.substitute(rest2.trim());
+      this._logger.debug(`.ifGt ${value1} ${value2} ${subs}`);
+      const variable1 = this.substitute(value1);
+      const variable2 = this.substitute(value2);
+      this.lastResult = "0";
+      if (!Number(variable1) || !Number(variable2)) {
+        let compareResult = variable1.localeCompare(variable2);
+        if (compareResult > 0) {
+          yield jsPdfDynamo.processDot(this, rest2);
+        }
+      } else {
+        if (Number(variable1) > Number(variable2)) {
+          yield jsPdfDynamo.processDot(this, rest2);
+        }
+      }
+    });
+  }
+  ifNotBlank(jsPdfDynamo, input) {
+    return __async(this, null, function* () {
+      let { first: variable, rest } = getNextString(input);
+      const subs = this.substitute(rest.trim());
+      this._logger.debug(".ifNotBlank " + variable + " " + subs);
+      let value = this._variables.get(variable.toLocaleUpperCase()) || "";
+      this.lastResult = "-1";
+      if (value.trim() !== "") {
+        yield jsPdfDynamo.processDot(this, rest);
+      }
+    });
+  }
+  incCurrentX(input) {
+    let subs = this.logAndParseCommand(".incCurrentX", input);
+    while (subs.length > 0) {
+      const { first: value, rest } = getNextNumber(subs);
+      subs = rest;
+      if (!Number.isNaN(value)) {
+        this.posnX = this.posnX + value;
+      }
+    }
+    this.lastResult = "1";
+    if (this.posnX < 0) {
+      this.posnX = 0;
+      this.lastError = "X Position resulted in negative value, adjusted to 0";
+    }
+    if (this.posnX > this._pageWidth) {
+      this.posnX = this._pageWidth;
+      this.lastError = "X Position exceeded page width, adjusted to page width";
+    }
+  }
+  incCurrentY(input) {
+    let subs = this.logAndParseCommand(".incCurrentY", input);
+    while (subs.length > 0) {
+      const { first: value, rest } = getNextNumber(subs);
+      subs = rest;
+      if (!Number.isNaN(value)) {
+        this.posnY += value;
+      }
+    }
+    this.lastResult = "1";
+    if (this.posnY < 0) {
+      this.posnY = 0;
+      this.lastError = "Y Position resulted in negative value, adjusted to 0";
+    }
+    if (this.posnY > this._pageHeight) {
+      this.posnY = this._pageHeight;
+      this.lastError = "Y Position exceeded page height, adjusted to page height";
+    }
+  }
+  incVar(input) {
+    const subs = this.logAndParseCommand(".incVar", input);
+    let { first: varName, rest } = getNextString(subs.toLocaleUpperCase());
+    if (varName === "") {
+      this.lastResult = "0";
+      this.lastError = "IncVar must reference a variable";
+      return;
+    }
+    if (varName.startsWith("_")) {
+      this.lastResult = "0";
+      this.lastError = "IncVar can not be used to update system maintained variables";
+      return;
+    }
+    let varValue = this._variables.get(varName);
+    if (!varValue) {
+      this.lastResult = "0";
+      this.lastError = "Variable '" + varName + "' is not defined";
+      return;
+    }
+    if (isNaN(Number(varValue))) {
+      this._variables.set(varName, "0");
+    }
+    while (rest.length > 0) {
+      const { first: nextOp, rest: remainder } = getNextNumber(rest, 4);
+      rest = remainder;
+      let varValue2 = this._variables.get(varName);
+      if (!isNaN(Number(varValue2)) && !isNaN(Number(nextOp))) {
+        this._variables.set(
+          varName,
+          removeTrailingZeros((Number(varValue2) + nextOp).toFixed(4))
+        );
+      }
+    }
+    this.lastResult = "1";
+    this._logger.trace(
+      "Variable " + varName + " incremented to " + this._variables.get(varName)
+    );
+  }
+  multVar(input) {
+    let subs = this.substitute(input.trim());
+    this._logger.debug(".multVar " + subs);
+    let { first: varName, rest } = getNextString(subs.toLocaleUpperCase());
+    if (varName === "") {
+      this.lastResult = "0";
+      this.lastError = "MultVar must reference a variable";
+      return;
+    }
+    if (varName.startsWith("_")) {
+      this.lastResult = "0";
+      this.lastError = "MultVar can not be used to update system maintained variables";
+      return;
+    }
+    let varValue = this._variables.get(varName);
+    if (!varValue) {
+      this.lastResult = "0";
+      this.lastError = "Variable '" + varName + "' is not defined";
+      return;
+    }
+    if (isNaN(Number(varValue))) {
+      this._variables.set(varName, "0");
+    }
+    while (rest.length > 0) {
+      const { first: nextOp, rest: remainder } = getNextNumber(rest, 4);
+      rest = remainder;
+      let varValue2 = this._variables.get(varName);
+      if (!isNaN(Number(varValue2)) && !isNaN(Number(nextOp))) {
+        this._variables.set(
+          varName,
+          removeTrailingZeros((Number(varValue2) * Number(nextOp)).toFixed(4))
+        );
+      }
+      varValue2 = this._variables.get(varName);
+    }
+    this.lastResult = "1";
+    this._logger.trace(
+      "Variable " + varName + " incremented to " + this._variables.get(varName)
+    );
+  }
+  savePdf(input) {
+    let subs = this.logAndParseCommand(".savePdf", input.trim());
+    if (isBrowser()) {
+      this.lastError = "SavePdf is not supported in the browser";
+      this.lastResult = "0";
+      return;
+    }
+    if (subs.length === 0) {
+      subs = "Document";
+    }
+    if (!subs.toLocaleUpperCase().endsWith(".PDF")) {
+      subs = subs + ".pdf";
+    }
+    try {
+      this._pdfDocument.save(subs);
+      this.lastResult = "1";
+    } catch (ex) {
+      this._logger.error("Problem saving to " + subs);
+      this.lastResult = "0";
+    }
+  }
+  selectPage(input) {
+    const subs = this.logAndParseCommand(".selectPage", input);
+    const { first: pageNo } = getNextNumber(subs);
+    if (!subs) {
+      this.lastError = "A page number must be supplied";
+      this.lastResult = "0";
+      return;
+    }
+    if (isNaN(pageNo) || pageNo <= 0 || pageNo > this.pageCount) {
+      this.lastError = "The page number must be in the range of 1 to " + this.pageCount;
+      this.lastResult = "0";
+      return;
+    }
+    this._pdfDocument.setPage(pageNo);
+    this.currentPageNumber = pageNo;
+    this.lastResult = pageNo.toString();
+    this.posnX = 0;
+    this.posnY = 0;
+  }
+  setCurrentFont(fontName, fontStyle) {
+    this._pdfDocument.setFont(fontName, fontStyle);
+  }
+  setCurrentX(input) {
+    const subs = this.logAndParseCommand(".setCurrentX", input);
+    const { first: x } = getNextNumber(subs);
+    this.posnX = x;
+    this.lastResult = "1";
+  }
+  setCurrentY(input) {
+    const subs = this.logAndParseCommand(".setCurrentY", input);
+    const { first: y } = getNextNumber(subs);
+    this.posnY = y;
+    this.lastResult = "1";
+  }
+  setDocumentInfo(input) {
+    let subs = this.substitute(input);
+    this._logger.debug(".setDocumentInfo " + subs);
+    let { first, rest } = getNextString(subs);
+    this.lastResult = "1";
+    switch (first.toLocaleLowerCase()) {
+      case "application":
+        this._pdfDocument.setProperties({ application: rest });
+        break;
+      case "author":
+        this._pdfDocument.setProperties({ author: rest });
+        break;
+      case "creator":
+        this._pdfDocument.setProperties({ creator: rest });
+        break;
+      case "keywords":
+        this._pdfDocument.setProperties({ keywords: rest });
+        break;
+      case "subject":
+        this._pdfDocument.setProperties({ subject: rest });
+        break;
+      case "title":
+        this._pdfDocument.setProperties({ title: rest });
+        break;
+      default:
+        this.lastResult = "0";
+        this.lastError = "Unknown document info field " + first;
+        break;
+    }
+  }
+  setFillColour(input) {
+    let subs = this.substitute(input);
+    this._logger.debug(".setFillColour " + subs);
+    this.fillColour = subs;
+    this.lastResult = "1";
+  }
+  setFontName(input) {
+    const subs = this.logAndParseCommand(".setFontName", input);
+    const { first: fontName } = getNextString(subs);
+    if (fontName === "") {
+      this.lastResult = "0";
+      this.lastError = "A font name must be specified";
+      return;
+    }
+    this.fontName = fontName;
+    this.lastResult = "1";
+  }
+  setFontSize(input) {
+    const subs = this.logAndParseCommand(".setFontSize", input);
+    let { first: size } = getNextNumber(subs);
+    if (size > 0) {
+      this.fontPointSize = size;
+      this.lastResult = "1";
+    } else {
+      this.lastResult = "0";
+      this.lastError = "Invalid font size " + size;
+    }
+  }
+  setFontStyle(input) {
+    const subs = this.logAndParseCommand(".setFontStyle", input);
+    const { first: fontStyle } = getNextString(subs.toLocaleLowerCase());
+    if (fontStyle === "") {
+      this.lastResult = "0";
+      this.lastError = "A font style must be specified";
+      return;
+    }
+    if (!isValidFontStyle(fontStyle)) {
+      this.lastResult = "0";
+      this.lastError = "Invalid font style " + fontStyle;
+      return;
+    }
+    this.fontStyle = fontStyle;
+    this.lastResult = "1";
+  }
+  setLineColour(input) {
+    let subs = this.substitute(input);
+    this._logger.debug(".setLineColour " + subs);
+    this.lineColour = subs;
+    this.lastResult = "1";
+  }
+  setLineWidth(input) {
+    const subs = this.logAndParseCommand(".setLineWidth", input);
+    const { first: width } = getNextNumber(subs);
+    if (!Number.isNaN(width) && width > 0) {
+      this.lineWidth = width;
+      this.lastResult = "1";
+    } else {
+      this.lastResult = "0";
+      this.lastError = `Invalid line width 'width'`;
+    }
+  }
+  setLogLevel(input) {
+    const subs = this.logAndParseCommand(".setLogLevel", input);
+    const { first: logLevel } = getNextString(subs);
+    if (!this._logger.logLevel) {
+      this.lastResult = "0";
+      this.lastError = "The logger does not support setting the log level.";
+      return;
+    }
+    if (logLevel === "") {
+      this.lastResult = "0";
+      this.lastError = "A log level must be specified.";
+      return;
+    }
+    if (Number.isNaN(Number(logLevel))) {
+      this._logger.logLevel(logLevel);
+    } else {
+      this._logger.logLevel(Number(logLevel));
+    }
+    this.lastResult = "1";
+  }
+  setMargin(input) {
+    this.lastResult = "1";
+    let subs = this.substitute(input);
+    this._logger.debug(".setMargin " + subs);
+    const { first: marginType, rest } = getNextString(subs.toLocaleUpperCase());
+    const { first: size } = getNextNumber(rest);
+    if (marginType.startsWith("A")) {
+      this.marginLeft = size;
+      this.marginRight = size;
+      this.marginTop = size;
+      this.marginBottom = size;
+    } else if (marginType.startsWith("H")) {
+      this.marginLeft = size;
+      this.marginRight = size;
+    } else if (marginType.startsWith("V")) {
+      this.marginTop = size;
+      this.marginBottom = size;
+    } else if (marginType.startsWith("L")) {
+      this.marginLeft = size;
+    } else if (marginType.startsWith("R")) {
+      this.marginRight = size;
+    } else if (marginType.startsWith("T")) {
+      this.marginTop = size;
+    } else if (marginType.startsWith("B")) {
+      this.marginBottom = size;
+    } else {
+      this.lastResult = "0";
+    }
+  }
+  setPageOrientation(input) {
+    let subs = this.substitute(input);
+    const { first: orientation } = getNextString(subs.toLocaleLowerCase());
+    this.lastResult = "1";
+    if (orientation.startsWith("l")) {
+      this.pageOrientation = "landscape";
+    } else if (orientation.startsWith("p")) {
+      this.pageOrientation = "portrait";
+    } else {
+      this.lastResult = "0";
+      this.lastError = `Invalid page orientation '${orientation}'.`;
+    }
+  }
+  setPageSize(input) {
+    let subs = this.substitute(input);
+    const { first: ps } = getNextString(subs.toLocaleLowerCase());
+    if (ps === "") {
+      this.lastResult = "0";
+      this.lastError = "A page size must be specified";
+      return;
+    }
+    if (isValidPageSize(ps)) {
+      this.pageSize = ps;
+      this.lastResult = "1";
+    } else {
+      this.lastResult = "0";
+      this.lastError = "Invalid page size " + ps;
+    }
+  }
+  setSpaceHoz(input) {
+    const subs = this.logAndParseCommand(".setSpaceHoz", input);
+    const { first: size } = getNextNumber(subs);
+    this.spaceHoz = size;
+    this.lastResult = "1";
+  }
+  setSpaceVert(input) {
+    const subs = this.logAndParseCommand(".setSpaceVert", input);
+    const { first: size } = getNextNumber(subs);
+    this.spaceVert = size;
+    this.lastResult = "1";
+  }
+  setTextColour(input) {
+    const subs = this.logAndParseCommand(".setTextColour", input);
+    this.textColour = subs;
+    this.lastResult = "1";
+  }
+  copyVar(input) {
+    let subs = this.substitute(input);
+    this._logger.debug(".copyVar " + subs);
+    const { first: varName, rest: fromVar } = getNextString(
+      subs.toLocaleUpperCase()
+    );
+    if (varName === "" || fromVar === "") {
+      this.lastResult = "0";
+      this.lastError = "The CopyVar command requires two variable names to be specified";
+    } else if (varName.startsWith("_")) {
+      this.lastError = "The CopyVar command can not be used to update system maintained variables";
+      this.lastResult = "0";
+    } else {
+      let value = this._variables.get(fromVar);
+      if (value) {
+        this._variables.set(varName, value);
+        this.lastResult = "1";
+      } else {
+        this._variables.set(varName, "");
+        this.lastResult = "0";
+        this.lastError = "Variable '" + fromVar + "' is not defined";
+      }
+    }
+  }
+  getVar(variableName) {
+    const value = this._variables.get(variableName.toLocaleUpperCase());
+    this.lastResult = value ? "1" : "0";
+    this.lastError = value ? this.lastError : "Variable '" + variableName + "' is not defined";
+    return value || "";
+  }
+  setVar(input) {
+    let subs = this.substitute(input);
+    this._logger.debug(".setVar " + subs);
+    let { first: varName, rest } = getNextString(subs);
+    varName = varName.toLocaleUpperCase();
+    if (varName === "") {
+      this.lastError = "The SetVar command requires a variable name to be specified";
+      this.lastResult = "0";
+      return;
+    }
+    if (varName.startsWith("_")) {
+      this.lastError = "The SetVar command can not be used to modify system maintained variables";
+      this.lastResult = "0";
+      return;
+    }
+    this._variables.set(varName, rest);
+    this.lastResult = "1";
+  }
+  substitute(input) {
+    let result = input;
+    let upperInput = input.toUpperCase();
+    let subsDelimiter = "%";
+    let ix = upperInput.indexOf(subsDelimiter);
+    do {
+      if (ix === upperInput.length - 1) {
+        break;
+      }
+      let iy = upperInput.indexOf(subsDelimiter, ix + 1);
+      if (iy === -1) {
+        break;
+      }
+      if (iy === ix + 1) {
+        upperInput = upperInput.slice(0, ix) + upperInput.slice(ix + 1);
+        result = result.slice(0, ix) + result.slice(ix + 1);
+        if (ix === upperInput.length - 1) {
+          break;
+        }
+        ix++;
+        ix = upperInput.indexOf(subsDelimiter, ix);
+        continue;
+      }
+      let valueName = upperInput.substring(ix + 1, iy).trim();
+      let value = this._variables.get(valueName) || "";
+      result = result.slice(0, ix) + result.slice(iy + 1);
+      if (ix === upperInput.length - 1) {
+        result = result + value;
+        break;
+      }
+      result = result.slice(0, ix) + value + result.slice(ix);
+      upperInput = result.toUpperCase();
+      ix = ix + value.length;
+      ix = upperInput.indexOf(subsDelimiter, ix);
+    } while (ix > -1);
+    return result;
+  }
+  writeLog(input) {
+    const result = this.substitute(input);
+    const { first: level, rest } = getNextString(result);
+    switch (level.toLocaleLowerCase()) {
+      case "0":
+      case "trace":
+        this._logger.trace(rest);
+        break;
+      case "1":
+      case "debug":
+        this._logger.debug(rest);
+        break;
+      case "2":
+      case "info":
+        this._logger.info(rest);
+        break;
+      case "3":
+      case "warn":
+        this._logger.warn(rest);
+        break;
+      case "4":
+      case "error":
+        this._logger.error(rest);
+        break;
+    }
+  }
+  pixelsToUom(value) {
+    switch (this.currentUom) {
+      case "mm":
+        return pixelsToMm(value);
+      case "in":
+        return pixelsToInches(value);
+      case "pt":
+        return pixelsToPoints(value);
+    }
+    return value;
+  }
+  pointsToUom(points) {
+    switch (this.currentUom) {
+      case "mm":
+        return pointsToMm(points);
+      case "in":
+        return pointsToInches(points);
+      case "pt":
+        return pointsToPixels(points);
+    }
+    return points;
+  }
+  uomToPoints(value) {
+    switch (this.currentUom) {
+      case "mm":
+        return mmToPoints(value);
+      case "in":
+        return inchesToPoints(value);
+    }
+    return value;
+  }
+  setFixedDec(value, places = 2) {
+    return value.toFixed(places);
+  }
+};
+
+// src/jsPdfDynamo.ts
+var _groups, _appLogger;
+var JsPdfDynamo = class {
+  constructor(options = {}, logger = null) {
+    __privateAdd(this, _groups, {});
+    __privateAdd(this, _appLogger);
+    __privateSet(this, _appLogger, new AppLogger(logger));
+    this._processor = this.prepareNewPdf(options, __privateGet(this, _appLogger));
+  }
+  toBlob() {
+    try {
+      const result = this._processor.PdfDocument.output("blob");
+      return result;
+    } catch (e) {
+      __privateGet(this, _appLogger).warn(
+        "Attempt to generate a blob from an empty PDF stream."
+      );
+      return null;
+    }
+  }
+  toBlobUrl() {
+    try {
+      const result = this._processor.PdfDocument.output(
+        "bloburi",
+        "application/pdf"
+      );
+      return result;
+    } catch (e) {
+      __privateGet(this, _appLogger).warn(
+        "Attempt to generate a URL from an empty PDF stream."
+      );
+      return null;
+    }
+  }
+  getVar(variableName) {
+    var _a;
+    return this._processor ? (_a = this._processor.getVar(variableName)) != null ? _a : null : null;
+  }
+  prepareNewPdf(options, logger) {
+    return new JsPdfProcessor(options, logger);
+  }
+  prepareWrappedString(input) {
+    if (!input) {
+      return "";
+    }
+    return input.replace("%", "%%").replace("\\", "\\\\").replace(/\r?\n/g, "\\n");
+  }
+  processCommands(commands) {
+    return __async(this, null, function* () {
+      if (this._processor && commands && commands.length > 0) {
+        yield this.processTemplate(this._processor, commands);
+      }
+    });
+  }
+  processTemplate(processor, input) {
+    return __async(this, null, function* () {
+      let inGroupProcessing = false;
+      let grpName = "";
+      let currGroup = [];
+      for (let ix = 0; ix < input.length; ix++) {
+        let currLine = input[ix];
+        if (!currLine || currLine.length === 0 || currLine.startsWith(";")) {
+          continue;
+        }
+        if (currLine.startsWith("[")) {
+          if (inGroupProcessing) {
+            inGroupProcessing = false;
+            __privateGet(this, _appLogger).debug(
+              `Finished loading group ${grpName}   (${currLine})
+`
+            );
+          } else {
+            if (currLine.length === 1) continue;
+            grpName = currLine.substring(1);
+            const iy = grpName.indexOf("]");
+            if (iy >= 0) {
+              grpName = grpName.substring(0, iy);
+            }
+            grpName = grpName.trim().toLocaleUpperCase();
+            inGroupProcessing = true;
+            __privateGet(this, _appLogger).debug(`Loading group ${grpName}   (${currLine})
+`);
+            currGroup = [];
+            __privateGet(this, _groups)[grpName] = currGroup;
+          }
+          continue;
+        }
+        if (inGroupProcessing) {
+          currGroup.push(currLine);
+          __privateGet(this, _appLogger).trace(`  ${currLine}`);
+          continue;
+        }
+        if (currLine.length > 5 && currLine.substring(0, 6).toLocaleLowerCase() === ".dump ") {
+          continue;
+        }
+        if (currLine.startsWith(".")) {
+          yield this.processDot(processor, currLine);
+          continue;
+        }
+      }
+    });
+  }
+  processDot(processor, currLine) {
+    return __async(this, null, function* () {
+      const input = currLine.substring(1);
+      let { first, rest: parameters } = getNextString(input);
+      first = first.toLowerCase();
+      switch (first) {
+        case "AddBookmark".toLowerCase():
+          processor.addBookmark(parameters);
+          return;
+        case "AddImageFromFile".toLowerCase():
+          processor.addImageFromFile(parameters);
+          return;
+        case "AddImageFromUrl".toLowerCase():
+          yield processor.addImageFromUrl(parameters);
+          return;
+        case "AddPage".toLowerCase():
+          processor.addPage(parameters);
+          return;
+        case "CheckPage".toLowerCase():
+          yield processor.checkPage(this, parameters);
+          return;
+        case "CopyVar".toLowerCase():
+          processor.copyVar(parameters);
+          return;
+        case "Do".toLowerCase():
+          yield this.processGroups(processor, parameters);
+          return;
+        case "DoRepeat".toLowerCase():
+          yield this.processGroupsRepeat(processor, parameters);
+          return;
+        case "DrawBox".toLowerCase():
+          processor.drawBox(parameters);
+          return;
+        case "DrawDebugGrid".toLowerCase():
+          processor.drawDebugGrid(parameters);
+          return;
+        case "DrawImage".toLowerCase():
+          processor.drawImage(parameters);
+          return;
+        case "DrawLine".toLowerCase():
+          processor.drawLine(parameters);
+          return;
+        case "DrawText".toLowerCase():
+          processor.drawText(parameters);
+          return;
+        case "DrawTextBox".toLowerCase():
+          processor.drawTextBox(parameters);
+          return;
+        case "DrawTextWrapped".toLowerCase():
+          yield processor.drawTextWrapped(this, parameters);
+          return;
+        case "ForEachPage".toLowerCase():
+          yield processor.forEachPage(this, parameters);
+          return;
+        case "IfEq".toLowerCase():
+          yield processor.ifEq(this, parameters);
+          return;
+        case "IfBlank".toLowerCase():
+          yield processor.ifBlank(this, parameters);
+          return;
+        case "IfGt".toLowerCase():
+          yield processor.ifGt(this, parameters);
+          return;
+        case "IfNe".toLowerCase():
+          yield processor.ifNe(this, parameters);
+          return;
+        case "IfNotBlank".toLowerCase():
+          yield processor.ifNotBlank(this, parameters);
+          return;
+        case "incCurrentY".toLowerCase():
+          processor.incCurrentY(parameters);
+          return;
+        case "incCurrentX".toLowerCase():
+          processor.incCurrentX(parameters);
+          return;
+        case "Include".toLowerCase():
+          yield this.includeFile(processor, parameters);
+          return;
+        case "IncludeUri".toLowerCase():
+          yield this.includeUri(processor, parameters);
+          return;
+        case "IncVar".toLowerCase():
+          processor.incVar(parameters);
+          return;
+        case "MultVar".toLowerCase():
+          processor.multVar(parameters);
+          return;
+        case "SavePdf".toLowerCase():
+          processor.savePdf(parameters);
+          return;
+        case "SelectPage".toLowerCase():
+          processor.selectPage(parameters);
+          return;
+        case "setCurrentX".toLowerCase():
+          processor.setCurrentX(parameters);
+          return;
+        case "setCurrentY".toLowerCase():
+          processor.setCurrentY(parameters);
+          return;
+        case "SetDocumentInfo".toLowerCase():
+          processor.setDocumentInfo(parameters);
+          return;
+        case "SetFillColor".toLowerCase():
+        case "SetFillColour".toLowerCase():
+          processor.setFillColour(parameters);
+          return;
+        case "SetFontName".toLowerCase():
+          processor.setFontName(parameters);
+          return;
+        case "SetFontSize".toLowerCase():
+          processor.setFontSize(parameters);
+          return;
+        case "SetFontStyle".toLowerCase():
+          processor.setFontStyle(parameters);
+          return;
+        case "SetLineColor".toLowerCase():
+        case "SetLineColour".toLowerCase():
+          processor.setLineColour(parameters);
+          return;
+        case "SetLineWidth".toLowerCase():
+          processor.setLineWidth(parameters);
+          return;
+        case "SetLogLevel".toLowerCase():
+          processor.setLogLevel(parameters);
+          return;
+        case "SetMargin".toLowerCase():
+          processor.setMargin(parameters);
+          return;
+        case "SetSpaceHoz".toLowerCase():
+          processor.setSpaceHoz(parameters);
+          return;
+        case "SetSpaceVert".toLowerCase():
+          processor.setSpaceVert(parameters);
+          return;
+        case "SetTextColour".toLowerCase():
+        case "SetTextColor".toLowerCase():
+          processor.setTextColour(parameters);
+          return;
+        case "SetVar".toLowerCase():
+          processor.setVar(parameters);
+          return;
+        case "WriteLog".toLowerCase():
+          processor.writeLog(parameters);
+          return;
+        default:
+          __privateGet(this, _appLogger).error(`Unknown command: ${input}`);
+      }
+    });
+  }
+  processGroups(processor, input, log = true) {
+    return __async(this, null, function* () {
+      let subs = processor.substitute(input.toLocaleUpperCase());
+      if (log) {
+        __privateGet(this, _appLogger).debug(`.Do ${subs}`);
+      }
+      processor.lastResult = "0";
+      while (subs.length > 0) {
+        let { first: group, rest } = getNextString(subs);
+        subs = rest;
+        __privateGet(this, _appLogger).debug(`
+[${group}]`);
+        if (__privateGet(this, _groups)[group]) {
+          yield this.processTemplate(processor, __privateGet(this, _groups)[group]);
+        } else {
+          __privateGet(this, _appLogger).warn(`Group ${group} was not found.`);
+          processor.lastResult = "0";
+        }
+      }
+    });
+  }
+  processGroupsRepeat(processor, input, log = true) {
+    return __async(this, null, function* () {
+      let subs = processor.substitute(input).toUpperCase();
+      if (log) {
+        __privateGet(this, _appLogger).debug(`.DoRepeat ${subs}`);
+      }
+      processor.lastResult = "0";
+      let { first: count, rest } = getNextNumber(subs);
+      while (count > 0) {
+        count--;
+        let groups = rest;
+        while (groups.length > 0) {
+          let { first: group, rest: remainder } = getNextString(groups);
+          groups = remainder;
+          __privateGet(this, _appLogger).debug(`
+[${group}]`);
+          if (__privateGet(this, _groups)[group]) {
+            yield this.processTemplate(processor, __privateGet(this, _groups)[group]);
+          } else {
+            __privateGet(this, _appLogger).warn(`Group ${group} was not found.`);
+            processor.lastResult = "0";
+          }
+        }
+      }
+    });
+  }
+  includeFile(processor, input) {
+    return __async(this, null, function* () {
+      const subs = processor.substitute(input);
+      __privateGet(this, _appLogger).debug(`.include ${subs}`);
+      try {
+        const fs2 = require("fs");
+        let incArray = fs2.readFileSync(subs).toString().split("\n");
+        let incList = incArray.map((line) => line.trim());
+        yield this.processTemplate(processor, incList);
+        __privateGet(this, _appLogger).debug(`${incList.length} lines included from ${subs}`);
+        processor.lastResult = "1";
+      } catch (ex) {
+        let message = "";
+        if (ex instanceof Error && ex.message) {
+          message = `: ${ex.message}`;
+        }
+        __privateGet(this, _appLogger).error(`Unable to load or process file ${subs}${message}`);
+        processor.lastResult = "0";
+      }
+    });
+  }
+  includeUri(processor, input) {
+    return __async(this, null, function* () {
+      const subs = processor.substitute(input);
+      __privateGet(this, _appLogger).debug(`.includeUri ${subs}`);
+      try {
+        const response = yield (0, import_node_fetch.default)(subs, {
+          headers: { Accept: "text/plain;q=0.9, text/*;q=0.8, */*;q=0.7" }
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP status ${response.status}.`);
+        }
+        const body = yield response.text();
+        let incArray = body.split("\n");
+        let incList = incArray.map((line) => line.trim());
+        yield this.processTemplate(processor, incList);
+        __privateGet(this, _appLogger).debug(`${incList.length} lines included from ${subs}`);
+        processor.lastResult = "1";
+      } catch (ex) {
+        let message = "";
+        if (ex instanceof Error && ex.message) {
+          message = `: ${ex.message}`;
+        }
+        __privateGet(this, _appLogger).error(`Unable to load or process URI ${subs}${message}`);
+        processor.lastResult = "0";
+      }
+    });
+  }
+};
+_groups = new WeakMap();
+_appLogger = new WeakMap();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsPdfDynamo
+});