'use strict';

var fs = require('fs');
var nodeUtil = require('util');
var promises = require('fs/promises');
var events = require('events');
var path = require('path');
var url = require('url');
var { Blob } = require('buffer');
var xmldom = require('@xmldom/xmldom');
var DOMParser = xmldom.DOMParser;
var stream = require('stream');

var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
const kColors = [
   '#000000',		// 0
   '#ffffff',		// 1
   '#4c4c4c',		// 2
   '#808080',		// 3
   '#999999',		// 4
   '#c0c0c0',		// 5
   '#cccccc',		// 6
   '#e5e5e5',		// 7
   '#f2f2f2',		// 8
   '#008000',		// 9
   '#00ff00',		// 10
   '#bfffa0',		// 11
   '#ffd629',		// 12
   '#ff99cc',		// 13
   '#004080',		// 14
   '#9fc0e1',		// 15
   '#5580ff',		// 16
   '#a9c9fa',		// 17
   '#ff0080',		// 18
   '#800080',		// 19
   '#ffbfff',		// 20
   '#e45b21',		// 21
   '#ffbfaa',		// 22
   '#008080',		// 23
   '#ff0000',		// 24
   '#fdc59f',		// 25
   '#808000',		// 26
   '#bfbf00',		// 27
   '#824100',		// 28
   '#007256',		// 29
   '#008000',		// 30
   '#000080',		// Last + 1
   '#008080',		// Last + 2
   '#800080',		// Last + 3
   '#ff0000',		// Last + 4
   '#0000ff',		// Last + 5
   '#008000'		// Last + 6
];

const kFontFaces = [
   "quicktype,arial,helvetica,sans-serif",							// 00 - QuickType - sans-serif variable font
   "quicktype condensed,arial narrow,arial,helvetica,sans-serif",	// 01 - QuickType Condensed - thin sans-serif variable font
   "quicktypepi,quicktypeiipi",									// 02 - QuickType Pi
   "quicktype mono,courier new,courier,monospace",					// 03 - QuickType Mono - san-serif fixed font
   "ocr-a,courier new,courier,monospace",							// 04 - OCR-A - OCR readable san-serif fixed font
   "ocr b mt,courier new,courier,monospace"						// 05 - OCR-B MT - OCR readable san-serif fixed font
];

const kFontStyles = [
   // Face		Size	Bold	Italic		StyleID(Comment)
   // -----	----	----	-----		-----------------
   [0, 6, 0, 0],			//00
   [0, 8, 0, 0],			//01
   [0, 10, 0, 0],			//02
   [0, 12, 0, 0],			//03
   [0, 14, 0, 0],			//04
   [0, 18, 0, 0],			//05
   [0, 6, 1, 0],			//06
   [0, 8, 1, 0],			//07
   [0, 10, 1, 0],			//08
   [0, 12, 1, 0],			//09
   [0, 14, 1, 0],			//10
   [0, 18, 1, 0],			//11
   [0, 6, 0, 1],			//12
   [0, 8, 0, 1],			//13
   [0, 10, 0, 1],			//14
   [0, 12, 0, 1],			//15
   [0, 14, 0, 1],			//16
   [0, 18, 0, 1],			//17
   [0, 6, 1, 1],			//18
   [0, 8, 1, 1],			//19
   [0, 10, 1, 1],			//20
   [0, 12, 1, 1],			//21
   [0, 14, 1, 1],			//22
   [0, 18, 1, 1],			//23
   [1, 6, 0, 0],			//24
   [1, 8, 0, 0],			//25
   [1, 10, 0, 0],			//26
   [1, 12, 0, 0],			//27
   [1, 14, 0, 0],			//28
   [1, 18, 0, 0],			//29
   [1, 6, 1, 0],			//30
   [1, 8, 1, 0],			//31
   [1, 10, 1, 0],			//32
   [1, 12, 1, 0],			//33
   [1, 14, 1, 0],			//34
   [1, 18, 1, 0],			//35
   [1, 6, 0, 1],			//36
   [1, 8, 0, 1],			//37
   [1, 10, 0, 1],			//38
   [1, 12, 0, 1],			//39
   [1, 14, 0, 1],			//40
   [1, 18, 0, 1],			//41
   [2, 8, 0, 0],			//42
   [2, 10, 0, 0],			//43
   [2, 12, 0, 0],			//44
   [2, 14, 0, 0],			//45
   [2, 18, 0, 0],			//46
   [3, 8, 0, 0],			//47
   [3, 10, 0, 0],			//48
   [3, 12, 0, 0],			//49
   [4, 12, 0, 0],			//50
   [0, 9, 0, 0],			//51
   [0, 9, 1, 0],			//52
   [0, 9, 0, 1],			//53
   [0, 9, 1, 1],			//54
   [1, 9, 0, 0],			//55
   [1, 9, 1, 0],			//56
   [1, 9, 1, 1],			//57
   [4, 10, 0, 0],			//58
   [5, 10, 0, 0],			//59
   [5, 12, 0, 0]			//60
];

const dpi = 96.0;
const gridXPerInch = 4.0;
const gridYPerInch = 4.0;

const _pixelXPerGrid = dpi / gridXPerInch;
const _pixelYPerGrid = dpi / gridYPerInch;
const _pixelPerPoint = dpi / 72;

class PDFUnit {
   static toFixedFloat(fNum) {
      return parseFloat(fNum.toFixed(3));
   }

   static colorCount() {
      return kColors.length;
   }

   static toPixelX(formX) {
      return Math.round(formX * _pixelXPerGrid);
   }

   static toPixelY(formY) {
      return Math.round(formY * _pixelYPerGrid);
   }

   static pointToPixel(point) {// Point unit (1/72 an inch) to pixel units
      return point * _pixelPerPoint;
   }

   static getColorByIndex(clrId) {
      return kColors[clrId];
   }

   static toFormPoint(viewportX, viewportY) {
      return [(viewportX / _pixelXPerGrid), (viewportY / _pixelYPerGrid)];
   }

   static toFormX(viewportX) {
      return PDFUnit.toFixedFloat(viewportX / _pixelXPerGrid);
   }

   static toFormY(viewportY) {
      return PDFUnit.toFixedFloat(viewportY / _pixelYPerGrid);
   }

   static findColorIndex(color) {
      if (color.length === 4)
         color += "000";
      //MQZ. 07/29/2013: if color is not in dictionary, just return -1. The caller (pdffont, pdffill) will set the actual color
      return kColors.indexOf(color);
   }

   static dateToIso8601(date) {
      // PDF spec p.160
      if (date.slice(0, 2) === 'D:') { // D: prefix is optional
         date = date.slice(2);
      }
      let tz = 'Z';
      let idx = date.search(/[Z+-]/); // timezone is optional
      if (idx >= 0) {
         tz = date.slice(idx);
         if (tz !== 'Z') { // timezone format OHH'mm'
            tz = tz.slice(0, 3) + ':' + tz.slice(4, 6);
         }
         date = date.slice(0, idx);
      }
      let yr = date.slice(0, 4); // everything after year is optional
      let mth = date.slice(4, 6) || '01';
      let day = date.slice(6, 8) || '01';
      let hr = date.slice(8, 10) || '00';
      let min = date.slice(10, 12) || '00';
      let sec = date.slice(12, 14) || '00';
      return yr + '-' + mth + '-' + day + 'T' + hr + ':' + min + ':' + sec + tz;
   }
}

class PDFLine {
   constructor(x1, y1, x2, y2, lineWidth, color, dashed) {
      this.x1 = x1;
      this.y1 = y1;
      this.x2 = x2;
      this.y2 = y2;
      this.lineWidth = lineWidth || 1.0;
      this.color = color;
      this.dashed = dashed;
   }

   #setStartPoint(oneLine, x, y) {
      oneLine.x = PDFUnit.toFormX(x);
      oneLine.y = PDFUnit.toFormY(y);
   }

   processLine(targetData) {
      const xDelta = Math.abs(this.x2 - this.x1);
      const yDelta = Math.abs(this.y2 - this.y1);
      const minDelta = this.lineWidth;

      let oneLine = { x: 0, y: 0, w: PDFUnit.toFixedFloat(this.lineWidth), l: 0 };

      //MQZ Aug.28.2013, adding color support, using color dictionary and default to black
      const clrId = PDFUnit.findColorIndex(this.color);
      const colorObj = (clrId > 0 && clrId < PDFUnit.colorCount()) ? { clr: clrId } : { oc: this.color };
      oneLine = { ...oneLine, ...colorObj };

      //MQZ Aug.29 dashed line support
      if (this.dashed) {
         oneLine = oneLine = { ...oneLine, dsh: 1 };
      }

      if ((yDelta < this.lineWidth) && (xDelta > minDelta)) { //HLine
         if (this.lineWidth < 4 && (xDelta / this.lineWidth < 4)) {
            nodeUtil.p2jinfo("Skipped: short thick HLine: lineWidth = " + this.lineWidth + ", xDelta = " + xDelta);
            return; //skip short thick lines, like PA SPP lines behinds checkbox
         }

         oneLine.l = PDFUnit.toFormX(xDelta);
         if (this.x1 > this.x2)
            this.#setStartPoint(oneLine, this.x2, this.y2);
         else
            this.#setStartPoint(oneLine, this.x1, this.y1);
         targetData.HLines.push(oneLine);
      }
      else if ((xDelta < this.lineWidth) && (yDelta > minDelta)) {//VLine
         if (this.lineWidth < 4 && (yDelta / this.lineWidth < 4)) {
            nodeUtil.p2jinfo("Skipped: short thick VLine: lineWidth = " + this.lineWidth + ", yDelta = " + yDelta);
            return; //skip short think lines, like PA SPP lines behinds checkbox
         }

         oneLine.l = PDFUnit.toFormY(yDelta);
         if (this.y1 > this.y2)
            this.#setStartPoint(oneLine, this.x2, this.y2);
         else
            this.#setStartPoint(oneLine, this.x1, this.y1);
         targetData.VLines.push(oneLine);
      }
   }
}

class PDFFill {
   // constructor
   constructor(x, y, width, height, color) {
      this.x = x;
      this.y = y;
      this.width = width;
      this.height = height;
      this.color = color;
   }

   processFill(targetData) {
      //MQZ.07/29/2013: when color is not in color dictionary, set the original color (oc)
      const clrId = PDFUnit.findColorIndex(this.color);
      const colorObj = (clrId > 0 && clrId < PDFUnit.colorCount()) ? { clr: clrId } : { oc: this.color };

      const oneFill = {
         x: PDFUnit.toFormX(this.x),
         y: PDFUnit.toFormY(this.y),
         w: PDFUnit.toFormX(this.width),
         h: PDFUnit.toFormY(this.height),
         ...colorObj
      };


      if (oneFill.w < 2 && oneFill.h < 2) {
         nodeUtil.p2jinfo("Skipped: tiny fill: " + oneFill.w + " x " + oneFill.h);
         return; //skip short thick lines, like PA SPP lines behinds checkbox
      }

      targetData.Fills.push(oneFill);
   }
}

const _boldSubNames = ['bd', 'bold', 'demi', 'black'];
const _stdFonts = [
   'arial',
   'helvetica',
   'sans-serif ',
   'courier ',
   'monospace ',
   'ocr ',
];
const DISTANCE_DELTA = 0.1;

class PDFFont {
   #initTypeName() {
      let typeName = this.fontObj.name || this.fontObj.fallbackName;
      if (!typeName) {
         typeName = kFontFaces[0]; //default font family name
      }
      typeName = typeName.toLowerCase();
      return typeName;
   }

   #initSubType() {
      let subType = this.typeName;
      let bold = false;

      let nameArray = this.typeName.split('+');
      if (Array.isArray(nameArray) && nameArray.length > 1) {
         subType = nameArray[1].split('-');
         if (Array.isArray(subType) && subType.length > 1) {
            let subName = subType[1].toLowerCase();
            bold = _boldSubNames.indexOf(subName) >= 0;
            subType = subType[0];
         }
      }
      return { subType, bold };
   }

   #initSymbol() {
      let isSymbol =
         this.typeName.indexOf('symbol') > 0 ||
         kFontFaces[2].indexOf(this.subType) >= 0;
      if (this.fontObj.isSymbolicFont) {
         let mFonts = _stdFonts.filter(
            (oneName) => this.typeName.indexOf(oneName) >= 0
         );

         if (mFonts.length > 0) {
            this.fontObj.isSymbolicFont = false; //lots of Arial-based font is detected as symbol in VA forms (301, 76-c, etc.) reset the flag for now
            nodeUtil.p2jinfo(
               'Reset: isSymbolicFont (false) for ' + this.fontObj.name
            );
         }
      } else {
         if (isSymbol) {
            this.fontObj.isSymbolicFont = true; //text pdf: va_ind_760c
            nodeUtil.p2jinfo(
               'Reset: isSymbolicFont (true) for ' + this.fontObj.name
            );
         }
      }
      return isSymbol;
   }

   #initSpaceWidth() {
      let spaceWidth = this.fontObj.spaceWidth;
      if (!spaceWidth) {
         var spaceId = Array.isArray(this.fontObj.toFontChar)
            ? this.fontObj.toFontChar.indexOf(32)
            : -1;
         spaceWidth =
            spaceId >= 0 && Array.isArray(this.fontObj.widths)
               ? this.fontObj.widths[spaceId]
               : 250;
      }
      spaceWidth = PDFUnit.toFormX(spaceWidth) / 32;
      return spaceWidth;
   }

   // constructor
   constructor(fontObj) {
      this.fontObj = fontObj;

      this.typeName = this.#initTypeName();

      const { subType, bold } = this.#initSubType();
      this.subType = subType;
      this.bold = bold;

      this.isSymbol = this.#initSymbol();
      this.spaceWidth = this.#initSpaceWidth();

      this.fontSize = 1;
      this.faceIdx = 0;
      this.italic = false;
      this.fontStyleId = -1;
   }

   /** sort text blocks by y then x */
   static compareBlockPos(t1, t2) {
      if (t1.y < t2.y - DISTANCE_DELTA) {
         return -1;
      }
      if (Math.abs(t1.y - t2.y) <= DISTANCE_DELTA) {
         if (t1.x < t2.x - DISTANCE_DELTA) {
            return -1;
         }
         if (Math.abs(t1.x - t2.x) <= DISTANCE_DELTA) {
            return 0;
         }
      }
      return 1;
   }

   static haveSameStyle(t1, t2) {
      let retVal = t1.R[0].S === t2.R[0].S;
      if (retVal && t1.R[0].S < 0) {
         for (let i = 0; i < t1.R[0].TS.length; i++) {
            if (t1.R[0].TS[i] !== t2.R[0].TS[i]) {
               retVal = false;
               break;
            }
         }
      }
      if (retVal) {
         // make sure both block are not rotated
         retVal =
            typeof t1.R[0].RA === 'undefined' &&
            typeof t2.R[0].RA === 'undefined';
      }

      return retVal;
   }

   static getSpaceThreshHold(t1) {
      return (PDFFont.getFontSize(t1) / 12) * t1.sw;
   }

   static areAdjacentBlocks(t1, t2) {
      const isInSameLine = Math.abs(t1.y - t2.y) <= DISTANCE_DELTA;
      const isDistanceSmallerThanASpace =
         t2.x - t1.x - t1.w < PDFFont.getSpaceThreshHold(t1);

      return isInSameLine && isDistanceSmallerThanASpace;
   }

   static getFontSize(textBlock) {
      const sId = textBlock.R[0].S;
      return sId < 0 ? textBlock.R[0].TS[1] : kFontStyles[sId][1];
   }

   static areDuplicateBlocks(t1, t2) {
      return (
         t1.x == t2.x &&
         t1.y == t2.y &&
         t1.R[0].T == t2.R[0].T &&
         PDFFont.haveSameStyle(t1, t2)
      );
   }

   // private
   #setFaceIndex() {
      const fontObj = this.fontObj;

      this.bold = fontObj.bold;
      if (!this.bold) {
         this.bold =
            this.typeName.indexOf('bold') >= 0 ||
            this.typeName.indexOf('black') >= 0;
      }
      this.italic = fontObj.italic; // fix https://github.com/modesty/pdf2json/issues/42
      // Extended the fix for https://github.com/modesty/pdf2json/issues/42
      if (!this.italic) {
         this.italic =
            this.typeName.indexOf('italic') >= 0 ||
            this.typeName.indexOf('oblique') >= 0;
      }
      // Added detection of hybrid dual bolditalic fonts
      if (
         (!this.bold || !this.italic) &&
         this.typeName.indexOf('boldobl') >= 0
      ) {
         this.bold = true;
         this.italic = true;
      }

      let typeName = this.subType;
      if (fontObj.isSerifFont) {
         if (kFontFaces[1].indexOf(typeName) >= 0) this.faceIdx = 1;
      } else if (kFontFaces[2].indexOf(this.subType) >= 0) {
         this.faceIdx = 2;
      } else if (fontObj.isMonospace) {
         this.faceIdx = 3;

         if (kFontFaces[4].indexOf(typeName) >= 0) this.faceIdx = 4;
         else if (kFontFaces[5].indexOf(typeName) >= 0) this.faceIdx = 5;
      } else if (fontObj.isSymbolicFont) {
         this.faceIdx = 2;
      }

      if (this.faceIdx == 0) {
         if (this.typeName.indexOf('narrow') > 0) this.faceIdx = 1;
      }

      //        nodeUtil.p2jinfo"typeName = " + typeName + " => faceIdx = " + this.faceIdx);
   }

   #getFontStyleIndex(fontSize) {
      this.#setFaceIndex();

      //MQZ Feb.28.2013. Adjust bold text fontsize to work around word spacing issue
      this.fontSize = this.bold && fontSize > 12 ? fontSize + 1 : fontSize;

      let fsa = [
         this.faceIdx,
         this.fontSize,
         this.bold ? 1 : 0,
         this.italic ? 1 : 0,
      ];
      let retVal = -1;

      kFontStyles.forEach(function (element, index, list) {
         if (retVal === -1) {
            if (
               element[0] === fsa[0] &&
               element[1] === fsa[1] &&
               element[2] === fsa[2] &&
               element[3] === fsa[3]
            ) {
               retVal = index;
            }
         }
      });

      return retVal;
   }

   #processSymbolicFont(str) {
      let retVal = str;

      if (!str || str.length !== 1) return retVal;

      if (!this.fontObj.isSymbolicFont || !this.isSymbol) {
         if (retVal == 'C' || retVal == 'G') {
            //prevent symbolic encoding from the client
            retVal = ' ' + retVal + ' '; //sample: va_ind_760c
         }
         return retVal;
      }

      switch (str.charCodeAt(0)) {
         case 20:
            retVal = '\u2713';
            break; //check mark
         case 70:
            retVal = this.fontObj.type === 'CIDFontType0' ? '\u26A0' : '\u007D';
            break; //exclaimation in triangle OR right curly bracket
         case 71:
            retVal = '\u25b6';
            break; //right triangle
         case 97:
            retVal = '\u25b6';
            break; //right triangle
         case 99:
            retVal = this.isSymbol ? '\u2022' : '\u25b2';
            break; //up triangle. set to Bullet Dot for VA SchSCR
         case 100:
            retVal = '\u25bc';
            break; //down triangle
         case 103:
            retVal = '\u27A8';
            break; //right arrow. sample: va_ind_760pff and pmt
         case 106:
            retVal = '';
            break; //VA 301: string j character by the checkbox, hide it for now
         case 114:
            retVal = '\u2022';
            break; //Bullet dot
         case 115:
            retVal = '\u25b2';
            break; //up triangle
         case 116:
            retVal = '\u2022';
            break; //Bullet dot
         case 118:
            retVal = '\u2022';
            break; //Bullet dot
         default:
            nodeUtil.p2jinfo(
               this.fontObj.type +
               ' - SymbolicFont - (' +
               this.fontObj.name +
               ') : ' +
               str.charCodeAt(0) +
               '::' +
               str.charCodeAt(1) +
               ' => ' +
               retVal
            );
      }

      return retVal;
   }

   #textRotationAngle(matrix2D) {
      let retVal = 0;
      if (matrix2D[0][0] === 0 && matrix2D[1][1] === 0) {
         if (matrix2D[0][1] != 0 && matrix2D[1][0] != 0) {
            if (matrix2D[0][1] / matrix2D[1][0] + 1 < 0.0001) retVal = 90;
         }
      } else if (matrix2D[0][0] !== 0 && matrix2D[1][1] !== 0) {
         let r1 = Math.atan(-matrix2D[0][1] / matrix2D[0][0]);
         let r2 = Math.atan(matrix2D[1][0] / matrix2D[1][1]);
         if (Math.abs(r1) > 0.0001 && r1 - r2 < 0.0001) {
            retVal = (r1 * 180) / Math.PI;
         }
      }
      return retVal;
   }

   // public instance methods
   processText(p, str, maxWidth, color, fontSize, targetData, matrix2D) {
      const text = this.#processSymbolicFont(str);
      if (!text) {
         return;
      }
      this.fontStyleId = this.#getFontStyleIndex(fontSize);

      // when this.fontStyleId === -1, it means the text style doesn't match any entry in the dictionary
      // adding TS to better describe text style [fontFaceId, fontSize, 1/0 for bold, 1/0 for italic];
      const TS = [
         this.faceIdx,
         this.fontSize,
         this.bold ? 1 : 0,
         this.italic ? 1 : 0,
      ];

      const clrId = PDFUnit.findColorIndex(color);
      const colorObj =
         clrId >= 0 && clrId < PDFUnit.colorCount()
            ? { clr: clrId }
            : { oc: color };

      let textRun = {
         T: this.flash_encode(text),
         S: this.fontStyleId,
         TS: TS,
      };
      const rAngle = this.#textRotationAngle(matrix2D);
      if (rAngle != 0) {
         nodeUtil.p2jinfo(str + ': rotated ' + rAngle + ' degree.');
         textRun = { ...textRun, RA: rAngle };
      }

      const oneText = {
         x: PDFUnit.toFormX(p.x) - 0.25,
         y: PDFUnit.toFormY(p.y) - 0.75,
         w: PDFUnit.toFixedFloat(maxWidth),
         ...colorObj, //MQZ.07/29/2013: when color is not in color dictionary, set the original color (oc)
         sw: this.spaceWidth, //font space width, use to merge adjacent text blocks
         A: 'left',
         R: [textRun],
      };

      targetData.Texts.push(oneText);
   }

   flash_encode(str) {
      let retVal = encodeURIComponent(str);
      retVal = retVal.replace('%C2%96', '-');
      retVal = retVal.replace('%C2%91', '%27');
      retVal = retVal.replace('%C2%92', '%27');
      retVal = retVal.replace('%C2%82', '%27');
      retVal = retVal.replace('%C2%93', '%22');
      retVal = retVal.replace('%C2%94', '%22');
      retVal = retVal.replace('%C2%84', '%22');
      retVal = retVal.replace('%C2%8B', '%C2%AB');
      retVal = retVal.replace('%C2%9B', '%C2%BB');

      return retVal;
   }

   clean() {
      this.fontObj = null;
      delete this.fontObj;
   }
}

// alias some functions to make (compiled) code shorter
const { round: mr, sin: ms, cos: mc, abs, sqrt } = Math;

// precompute "00" to "FF"
const dec2hex = [];
for (let i = 0; i < 16; i++) {
   for (let j = 0; j < 16; j++) {
      dec2hex[i * 16 + j] = i.toString(16) + j.toString(16);
   }
}

function createMatrixIdentity() {
   return [
      [1, 0, 0],
      [0, 1, 0],
      [0, 0, 1],
   ];
}

function matrixMultiply(m1, m2) {
   let result = createMatrixIdentity();

   for (let x = 0; x < 3; x++) {
      for (let y = 0; y < 3; y++) {
         let sum = 0;

         for (let z = 0; z < 3; z++) {
            sum += m1[x][z] * m2[z][y];
         }

         result[x][y] = sum;
      }
   }
   return result;
}

function copyState(o1, o2) {
   o2.fillStyle = o1.fillStyle;
   o2.lineCap = o1.lineCap;
   o2.lineJoin = o1.lineJoin;
   o2.lineWidth = o1.lineWidth;
   o2.miterLimit = o1.miterLimit;
   o2.shadowBlur = o1.shadowBlur;
   o2.shadowColor = o1.shadowColor;
   o2.shadowOffsetX = o1.shadowOffsetX;
   o2.shadowOffsetY = o1.shadowOffsetY;
   o2.strokeStyle = o1.strokeStyle;
   o2.globalAlpha = o1.globalAlpha;
   o2.arcScaleX_ = o1.arcScaleX_;
   o2.arcScaleY_ = o1.arcScaleY_;
   o2.lineScale_ = o1.lineScale_;
   o2.dashArray = o1.dashArray;
}

function processStyle(styleString) {
   let str,
      alpha = 1;

   styleString = String(styleString);
   if (styleString.substring(0, 3) == 'rgb') {
      let start = styleString.indexOf('(', 3);
      let end = styleString.indexOf(')', start + 1);
      let guts = styleString.substring(start + 1, end).split(',');

      str = '#';
      for (let i = 0; i < 3; i++) {
         str += dec2hex[Number(guts[i])];
      }

      if (guts.length == 4 && styleString.substring(3, 4) == 'a') {
         alpha = guts[3];
      }
   } else {
      str = styleString;
   }

   return { color: str, alpha: alpha };
}

function processLineCap(lineCap) {
   switch (lineCap) {
      case 'butt':
         return 'flat';
      case 'round':
         return 'round';
      case 'square':
      default:
         return 'square';
   }
}

// Helper function that takes the already fixed cordinates.
function bezierCurveToHelper(self, cp1, cp2, p) {
   self.currentPath_.push({
      type: 'bezierCurveTo',
      cp1x: cp1.x,
      cp1y: cp1.y,
      cp2x: cp2.x,
      cp2y: cp2.y,
      x: p.x,
      y: p.y,
   });
   self.currentX_ = p.x;
   self.currentY_ = p.y;
}

function matrixIsFinite(m) {
   for (let j = 0; j < 3; j++) {
      for (let k = 0; k < 2; k++) {
         if (!isFinite(m[j][k]) || isNaN(m[j][k])) {
            return false;
         }
      }
   }
   return true;
}

function setM(ctx, m, updateLineScale) {
   if (!matrixIsFinite(m)) {
      return;
   }
   ctx.m_ = m;

   if (updateLineScale) {
      // Get the line scale.
      // Determinant of this.m_ means how much the area is enlarged by the
      // transformation. So its square root can be used as a scale factor
      // for width.
      let det = m[0][0] * m[1][1] - m[0][1] * m[1][0];
      ctx.lineScale_ = sqrt(abs(det));
   }
}

class CanvasPattern_ {
   constructor() { }
}

// Gradient / Pattern Stubs
class CanvasGradient_ {
   constructor(aType) {
      this.type_ = aType;
      this.x0_ = 0;
      this.y0_ = 0;
      this.r0_ = 0;
      this.x1_ = 0;
      this.y1_ = 0;
      this.r1_ = 0;
      this.colors_ = [];
   }
   addColorStop(aOffset, aColor) {
      aColor = processStyle(aColor);
      this.colors_.push({
         offset: aOffset,
         color: aColor.color,
         alpha: aColor.alpha,
      });
   }
}

/**
 * This class implements CanvasRenderingContext2D interface as described by
 * the WHATWG.
 * @param {HTMLElement} surfaceElement The element that the 2D context should
 * be associated with
 */
class CanvasRenderingContext2D_ {
   constructor(canvasTarget, scaledWidth, scaledHeight) {
      this.m_ = createMatrixIdentity();

      this.mStack_ = [];
      this.aStack_ = [];
      this.currentPath_ = [];

      // Canvas context properties
      this.strokeStyle = '#000';
      this.fillStyle = '#000';

      this.lineWidth = 1;
      this.lineJoin = 'miter';
      this.lineCap = 'butt';
      this.dashArray = [];
      this.miterLimit = 1;
      this.globalAlpha = 1;

      if (!('HLines' in canvasTarget) || !Array.isArray(canvasTarget.HLines))
         canvasTarget.HLines = [];
      if (!('VLines' in canvasTarget) || !Array.isArray(canvasTarget.VLines))
         canvasTarget.VLines = [];
      if (!('Fills' in canvasTarget) || !Array.isArray(canvasTarget.Fills))
         canvasTarget.Fills = [];
      if (!('Texts' in canvasTarget) || !Array.isArray(canvasTarget.Texts))
         canvasTarget.Texts = [];

      this.canvas = canvasTarget;

      this.width = scaledWidth;
      this.height = scaledHeight;

      this.arcScaleX_ = 1;
      this.arcScaleY_ = 1;
      this.lineScale_ = 1;

      this.currentFont = null;
   }

   //private helper methods
   #drawPDFLine(p1, p2, lineWidth, color) {
      let dashedLine =
         Array.isArray(this.dashArray) && this.dashArray.length > 1;
      let pL = new PDFLine(
         p1.x,
         p1.y,
         p2.x,
         p2.y,
         lineWidth,
         color,
         dashedLine
      );
      pL.processLine(this.canvas);
   }

   #drawPDFFill(cp, min, max, color) {
      let width = max.x - min.x;
      let height = max.y - min.y;
      let pF = new PDFFill(cp.x, cp.y, width, height, color);
      pF.processFill(this.canvas);
   }

   #needRemoveRect(x, y, w, h) {
      let retVal = Math.abs(w - Math.abs(h)) < 1 && w < 13;
      if (retVal) {
         nodeUtil.p2jinfo('Skipped: tiny rect: w=' + w + ', h=' + h);
      }
      return retVal;
   }

   getContext(ctxType) {
      return ctxType === '2d' ? this : null;
   }

   setLineDash(lineDash) {
      this.dashArray = lineDash;
   }

   getLineDash() {
      return this.dashArray;
   }

   fillText(text, x, y, maxWidth, fontSize) {
      if (!text || (!text.length === 1 && text.trim().length < 1)) return;
      let p = this.getCoords_(x, y);

      let a = processStyle(this.fillStyle || this.strokeStyle);
      let color = !!a ? a.color : '#000000';

      this.currentFont.processText(
         p,
         text,
         maxWidth,
         color,
         fontSize,
         this.canvas,
         this.m_
      );
   }

   strokeText(text, x, y, maxWidth) {
      //MQZ. 10/23/2012, yeah, no hollow text for now
      this.fillText(text, x, y, maxWidth);
   }

   measureText(text) {
      console.warn('to be implemented: contextPrototype.measureText - ', text);
      let chars = text.length || 1;
      return { width: chars * (this.currentFont.spaceWidth || 5) };
   }

   setFont(fontObj) {
      if (!!this.currentFont && typeof this.currentFont.clean === 'function') {
         this.currentFont.clean();
         this.currentFont = null;
      }

      this.currentFont = new PDFFont(fontObj);
   }

   clearRect() {
      console.warn('to be implemented: contextPrototype.clearRect');
   }

   beginPath() {
      // TODO: Branch current matrix so that save/restore has no effect
      //       as per safari docs.
      this.currentPath_ = [];
   }

   moveTo(aX, aY) {
      let p = this.getCoords_(aX, aY);
      this.currentPath_.push({ type: 'moveTo', x: p.x, y: p.y });
      this.currentX_ = p.x;
      this.currentY_ = p.y;
   }

   lineTo(aX, aY) {
      let p = this.getCoords_(aX, aY);
      this.currentPath_.push({ type: 'lineTo', x: p.x, y: p.y });

      this.currentX_ = p.x;
      this.currentY_ = p.y;
   }

   bezierCurveTo(aCP1x, aCP1y, aCP2x, aCP2y, aX, aY) {
      let p = this.getCoords_(aX, aY);
      let cp1 = this.getCoords_(aCP1x, aCP1y);
      let cp2 = this.getCoords_(aCP2x, aCP2y);
      bezierCurveToHelper(this, cp1, cp2, p);
   }

   quadraticCurveTo(aCPx, aCPy, aX, aY) {
      // the following is lifted almost directly from
      // http://developer.mozilla.org/en/docs/Canvas_tutorial:Drawing_shapes

      let cp = this.getCoords_(aCPx, aCPy);
      let p = this.getCoords_(aX, aY);

      let cp1 = {
         x: this.currentX_ + (2.0 / 3.0) * (cp.x - this.currentX_),
         y: this.currentY_ + (2.0 / 3.0) * (cp.y - this.currentY_),
      };
      let cp2 = {
         x: cp1.x + (p.x - this.currentX_) / 3.0,
         y: cp1.y + (p.y - this.currentY_) / 3.0,
      };

      bezierCurveToHelper(this, cp1, cp2, p);
   }

   arc(aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise) {
      let arcType = aClockwise ? 'at' : 'wa';

      let xStart = aX + mc(aStartAngle) * aRadius;
      let yStart = aY + ms(aStartAngle) * aRadius;

      let xEnd = aX + mc(aEndAngle) * aRadius;
      let yEnd = aY + ms(aEndAngle) * aRadius;

      // IE won't render arches drawn counter clockwise if xStart == xEnd.
      if (xStart == xEnd && !aClockwise) {
         xStart += 0.125; // Offset xStart by 1/80 of a pixel. Use something
         // that can be represented in binary
      }

      let p = this.getCoords_(aX, aY);
      let pStart = this.getCoords_(xStart, yStart);
      let pEnd = this.getCoords_(xEnd, yEnd);

      this.currentPath_.push({
         type: arcType,
         x: p.x,
         y: p.y,
         radius: aRadius,
         xStart: pStart.x,
         yStart: pStart.y,
         xEnd: pEnd.x,
         yEnd: pEnd.y,
      });
   }

   rect(aX, aY, aWidth, aHeight) {
      if (this.#needRemoveRect(aX, aY, aWidth, aHeight)) {
         return; //try to remove the rectangle behind radio buttons and checkboxes
      }

      this.moveTo(aX, aY);
      this.lineTo(aX + aWidth, aY);
      this.lineTo(aX + aWidth, aY + aHeight);
      this.lineTo(aX, aY + aHeight);
      this.closePath();
   }

   strokeRect(aX, aY, aWidth, aHeight) {
      if (this.#needRemoveRect(aX, aY, aWidth, aHeight)) {
         return; //try to remove the rectangle behind radio buttons and checkboxes
      }

      let oldPath = this.currentPath_;
      this.beginPath();

      this.moveTo(aX, aY);
      this.lineTo(aX + aWidth, aY);
      this.lineTo(aX + aWidth, aY + aHeight);
      this.lineTo(aX, aY + aHeight);
      this.closePath();
      this.stroke();

      this.currentPath_ = oldPath;
   }

   fillRect(aX, aY, aWidth, aHeight) {
      if (this.#needRemoveRect(aX, aY, aWidth, aHeight)) {
         return; //try to remove the rectangle behind radio buttons and checkboxes
      }

      let oldPath = this.currentPath_;
      this.beginPath();

      this.moveTo(aX, aY);
      this.lineTo(aX + aWidth, aY);
      this.lineTo(aX + aWidth, aY + aHeight);
      this.lineTo(aX, aY + aHeight);
      this.closePath();
      this.fill();

      this.currentPath_ = oldPath;
   }

   createLinearGradient(aX0, aY0, aX1, aY1) {
      let gradient = new CanvasGradient_('gradient');
      gradient.x0_ = aX0;
      gradient.y0_ = aY0;
      gradient.x1_ = aX1;
      gradient.y1_ = aY1;
      return gradient;
   }

   createRadialGradient(aX0, aY0, aR0, aX1, aY1, aR1) {
      let gradient = new CanvasGradient_('gradientradial');
      gradient.x0_ = aX0;
      gradient.y0_ = aY0;
      gradient.r0_ = aR0;
      gradient.x1_ = aX1;
      gradient.y1_ = aY1;
      gradient.r1_ = aR1;
      return gradient;
   }

   drawImage(image, var_args) {
      //MQZ. no image drawing support for now
   }

   getImageData(x, y, w, h) {
      //MQZ. returns empty data buffer for now
      return {
         width: w,
         height: h,
         data: new Uint8Array(w * h * 4),
      };
   }

   stroke(aFill) {
      if (this.currentPath_.length < 2) {
         return;
      }

      let a = processStyle(aFill ? this.fillStyle : this.strokeStyle);
      let color = a.color;
      //        let opacity = a.alpha * this.globalAlpha;
      let lineWidth = this.lineScale_ * this.lineWidth;

      let min = { x: null, y: null };
      let max = { x: null, y: null };

      for (let i = 0; i < this.currentPath_.length; i++) {
         let p = this.currentPath_[i];

         switch (p.type) {
            case 'moveTo':
               break;
            case 'lineTo':
               if (!aFill) {
                  //lines
                  if (i > 0) {
                     this.#drawPDFLine(
                        this.currentPath_[i - 1],
                        p,
                        lineWidth,
                        color
                     );
                  }
               }
               break;
            case 'close':
               if (!aFill) {
                  //lines
                  if (i > 0) {
                     this.#drawPDFLine(
                        this.currentPath_[i - 1],
                        this.currentPath_[0],
                        lineWidth,
                        color
                     );
                  }
               }
               p = null;
               break;
            case 'bezierCurveTo':
               break;
            case 'at':
            case 'wa':
               break;
         }

         // Figure out dimensions so we can set fills' coordinates correctly
         if (aFill && p) {
            if (min.x == null || p.x < min.x) {
               min.x = p.x;
            }
            if (max.x == null || p.x > max.x) {
               max.x = p.x;
            }
            if (min.y == null || p.y < min.y) {
               min.y = p.y;
            }
            if (max.y == null || p.y > max.y) {
               max.y = p.y;
            }
         }
      }

      if (aFill) {
         //fill
         this.#drawPDFFill(min, min, max, color);
      }
   }

   fill() {
      this.stroke(true);
   }

   closePath() {
      this.currentPath_.push({ type: 'close' });
   }

   /**
    * @private
    */
   getCoords_(aX, aY) {
      let m = this.m_;
      return {
         x: aX * m[0][0] + aY * m[1][0] + m[2][0],
         y: aX * m[0][1] + aY * m[1][1] + m[2][1],
      };
   }

   save() {
      let o = {};
      copyState(this, o);
      this.aStack_.push(o);
      this.mStack_.push(this.m_);
      this.m_ = matrixMultiply(createMatrixIdentity(), this.m_);
   }

   restore() {
      copyState(this.aStack_.pop(), this);
      this.m_ = this.mStack_.pop();
   }

   translate(aX, aY) {
      let m1 = [
         [1, 0, 0],
         [0, 1, 0],
         [aX, aY, 1],
      ];

      setM(this, matrixMultiply(m1, this.m_), false);
   }

   rotate(aRot) {
      let c = mc(aRot);
      let s = ms(aRot);

      let m1 = [
         [c, s, 0],
         [-s, c, 0],
         [0, 0, 1],
      ];

      setM(this, matrixMultiply(m1, this.m_), false);
   }

   scale(aX, aY) {
      this.arcScaleX_ *= aX;
      this.arcScaleY_ *= aY;
      let m1 = [
         [aX, 0, 0],
         [0, aY, 0],
         [0, 0, 1],
      ];

      setM(this, matrixMultiply(m1, this.m_), true);
   }

   transform(m11, m12, m21, m22, dx, dy) {
      let m1 = [
         [m11, m12, 0],
         [m21, m22, 0],
         [dx, dy, 1],
      ];

      setM(this, matrixMultiply(m1, this.m_), true);
   }

   setTransform(m11, m12, m21, m22, dx, dy) {
      let m = [
         [m11, m12, 0],
         [m21, m22, 0],
         [dx, dy, 1],
      ];

      setM(this, m, true);
   }

   /******** STUBS ********/
   clip() {
      // TODO: Implement
   }

   arcTo() {
      // TODO: Implement
   }

   createPattern() {
      return new CanvasPattern_();
   }
}

const kFBANotOverridable = 0x00000400; // indicates the field is read only by the user
const kFBARequired = 0x00000010; // indicates the field is required
const kMinHeight = 20;

class PDFField {
   static tabIndex = 0;

   static isWidgetSupported(field) {
      let retVal = false;

      switch (field.fieldType) {
         case 'Tx': retVal = true; break; //text input
         case 'Btn':
            if (field.fieldFlags & 32768) {
               field.fieldType = 'Rd'; //radio button
            }
            else if (field.fieldFlags & 65536) {
               field.fieldType = 'Btn'; //push button
            }
            else {
               field.fieldType = 'Cb'; //checkbox
            }
            retVal = true;
            break;
         case 'Ch': retVal = true; break; //drop down
         case 'Sig': retVal = true; break; //signature
         default:
            nodeUtil.p2jwarn("Unsupported: field.fieldType of " + field.fieldType);
            break;
      }

      return retVal;
   }

   static isFormElement(field) {
      let retVal = false;
      switch (field.subtype) {
         case 'Widget': retVal = PDFField.isWidgetSupported(field); break;
         default:
            nodeUtil.p2jwarn("Unsupported: field.type of " + field.subtype);
            break;
      }
      return retVal;
   }

   // constructor
   constructor(field, viewport, Fields, Boxsets) {
      this.field = field;
      this.viewport = viewport;
      this.Fields = Fields;
      this.Boxsets = Boxsets;
   }

   // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)
   // For coordinate systems whose origin lies in the bottom-left, this
   // means normalization to (BL,TR) ordering. For systems with origin in the
   // top-left, this means (TL,BR) ordering.
   static #normalizeRect(rect) {
      const r = rect.slice(0); // clone rect
      if (rect[0] > rect[2]) {
         r[0] = rect[2];
         r[2] = rect[0];
      }
      if (rect[1] > rect[3]) {
         r[1] = rect[3];
         r[3] = rect[1];
      }
      return r;
   }

   #getFieldPosition(field) {
      let viewPort = this.viewport;
      let fieldRect = viewPort.convertToViewportRectangle(field.rect);
      let rect = PDFField.#normalizeRect(fieldRect);

      let height = rect[3] - rect[1];
      if (field.fieldType === 'Tx') {
         if (height > kMinHeight + 2) {
            rect[1] += 2;
            height -= 2;
         }
      }
      else if (field.fieldType !== 'Ch') { //checkbox, radio button, and link button
         rect[1] -= 3;
      }

      height = (height >= kMinHeight) ? height : kMinHeight;

      return {
         x: PDFUnit.toFormX(rect[0]),
         y: PDFUnit.toFormY(rect[1]),
         w: PDFUnit.toFormX(rect[2] - rect[0]),
         h: PDFUnit.toFormY(height)
      };
   }

   #getFieldBaseData(field) {
      let attributeMask = 0;
      //PDF Spec p.676 TABLE 8.70 Field flags common to all field types
      if (field.fieldFlags & 0x00000001) {
         attributeMask |= kFBANotOverridable;
      }
      if (field.fieldFlags & 0x00000002) {
         attributeMask |= kFBARequired;
      }

      let anData = {
         id: { Id: field.fullName, EN: 0 },
         TI: field.TI,
         AM: attributeMask
      };
      //PDF Spec p.675: add TU (AlternativeText) fields to provide accessibility info
      if (field.alternativeText && field.alternativeText.length > 1) {
         anData.TU = field.alternativeText;
      }

      if (field.alternativeID && field.alternativeID.length > 1) {
         anData.TM = field.alternativeID;
      }

      return Object.assign(anData, this.#getFieldPosition(field));
   }

   #addAlpha(field) {
      const anData = Object.assign({
         style: 48,
         T: {
            Name: field.TName || "alpha",
            TypeInfo: {}
         }
      }, this.#getFieldBaseData(field));

      if (field.MV) { //field attributes: arbitrary mask value
         anData.MV = field.MV;
      }
      if (field.fieldValue) {
         anData.V = field.fieldValue; //read-only field value, like "self-prepared"
      }

      this.Fields.push(anData);
   }

   #addCheckBox(box) {
      const anData = Object.assign({
         style: 48,
         T: {
            Name: "box",
            TypeInfo: {}
         }
      }, this.#getFieldBaseData(box));
      if (box.fieldValue) {
         anData.checked = box.fieldValue !== 'Off';
      }

      this.Boxsets.push({ boxes: [anData] });
   }

   #addRadioButton(box) {
      const anData = Object.assign({
         style: 48,
         T: {
            Name: "box",
            TypeInfo: {}
         }
      }, this.#getFieldBaseData(box));

      anData.id.Id = box.value;
      if ('checked' in box) {
         anData.checked = box.checked;
      }

      const rdGroup = this.Boxsets.filter(boxset => ('id' in boxset) && ('Id' in boxset.id) && (boxset.id.Id === box.fullName))[0];
      if ((!!rdGroup) && ('boxes' in rdGroup)) {
         rdGroup.boxes.push(anData);
      }
      else {
         this.Boxsets.push({ boxes: [anData], id: { Id: box.fullName, EN: 0 } });
      }
   }

   #addLinkButton(field) {
      const anData = Object.assign({
         style: 48,
         T: {
            Name: "link"
         },
         FL: {
            form: { Id: field.FL }
         }
      }, this.#getFieldBaseData(field));

      this.Fields.push(anData);
   }

   #addSelect(field) {
      const anData = Object.assign({
         style: 48,
         T: {
            Name: "alpha",
            TypeInfo: {}
         }
      }, this.#getFieldBaseData(field));

      anData.w -= 0.5; //adjust combobox width
      anData.PL = { V: [], D: [] };
      field.value.forEach((ele, idx) => {
         if (Array.isArray(ele)) {
            anData.PL.D.push(ele[0]);
            anData.PL.V.push(ele[1]);
         } else {
            anData.PL.D.push(ele);
            anData.PL.V.push(ele);
         }
      });

      // add field value to the object 
      if (field.fieldValue) {
         anData.V = field.fieldValue;
      }
      this.Fields.push(anData);
   };

   #addSignature(field) {
      const anData = Object.assign({
         style: 48,
         T: {
            Name: "signature",
            TypeInfo: {}
         }
      }, this.#getFieldBaseData(field));

      if (field.Sig) {
         anData.Sig = {};
         if (field.Sig.Name) anData.Sig.Name = field.Sig.Name;
         if (field.Sig.M) anData.Sig.M = PDFUnit.dateToIso8601(field.Sig.M);
         if (field.Sig.Location) anData.Sig.Location = field.Sig.Location;
         if (field.Sig.Reason) anData.Sig.Reason = field.Sig.Reason;
         if (field.Sig.ContactInfo) anData.Sig.ContactInfo = field.Sig.ContactInfo;
      }

      this.Fields.push(anData);
   }

   // public instance methods
   processField() {
      this.field.TI = PDFField.tabIndex++;

      switch (this.field.fieldType) {
         case 'Tx': this.#addAlpha(this.field); break;
         case 'Cb': this.#addCheckBox(this.field); break;
         case 'Rd': this.#addRadioButton(this.field); break;
         case 'Btn': this.#addLinkButton(this.field); break;
         case 'Ch': this.#addSelect(this.field); break;
         case 'Sig': this.#addSignature(this.field); break;
      }

      this.clean();
   }

   clean() {
      delete this.field;
      delete this.viewport;
      delete this.Fields;
      delete this.Boxsets;
   }

   //static public method to generate fieldsType object based on parser result
   static getAllFieldsTypes(data) {
      const isFieldReadOnly = field => {
         return (field.AM & kFBANotOverridable) ? true : false;
      };

      const getFieldBase = field => {
         return { id: field.id.Id, type: field.T.Name, calc: isFieldReadOnly(field), value: field.V || "" };
      };

      let retVal = [];
      data.Pages.forEach(page => {
         page.Boxsets.forEach(boxsets => {
            if (boxsets.boxes.length > 1) { //radio button
               boxsets.boxes.forEach(box => {
                  retVal.push({ id: boxsets.id.Id, type: "radio", calc: isFieldReadOnly(box), value: box.id.Id });
               });
            }
            else { //checkbox
               retVal.push(getFieldBase(boxsets.boxes[0]));
            }
         });

         page.Fields.forEach(field => retVal.push(getFieldBase(field)));

      });
      return retVal;
   }
}

//BEGIN - MQZ 9/19/2012. Helper functions to parse acroForm elements
function setupRadioButton(annotation, item) {
   let asName = '';
   //PDF Spec p.689: parent item's DV holds the item's value that is selected by default
   let po = annotation.get('Parent');
   if (po) {
      po.forEach(function (key, val) {
         if (key === 'DV') {
            asName = val.name || '';
         }
         else if (key === 'TU') {
            //radio buttons use the alternative text from the parent
            item.alternativeText = val;
         } else if (key == 'TM') {
            item.alternativeID = val;
         }
      });
   }

   //PDF Spec p.606: get appearance dictionary
   let ap = annotation.get('AP');
   //PDF Spec p.614 get normal appearance
   let nVal = ap.get('N');
   //PDF Spec p.689
   nVal.forEach(function (key, value) {
      if (key.toLowerCase() != "off") {
         //value if selected
         item.value = key; //export value
         item.checked = (key === asName); //initial selection state
      }
   });

   if (!item.value)
      item.value = "off";
}

function setupPushButton(annotation, item) {
   //button label: PDF Spec p.640
   let mk = annotation.get('MK');
   if (mk) {
      item.value = mk.get('CA') || '';
   }

   //button action: url when mouse up: PDF Spec:p.642
   item.FL = "";
   let ap = annotation.get('A');
   if (ap) {
      let sp = ap.get('S');
      item.FL = ap.get(sp.name);
   }
}

function setupCheckBox(annotation, item) {
   //PDF Spec p.606: get appearance dictionary
   let ap = annotation.get('AP');
   //PDF Spec p.614 get normal appearance
   let nVal = ap.get('N');

   //PDF Spec p.689
   let i = 0;
   nVal.forEach(function (key, value) {
      i++;
      if (i == 1) //initial selection state
         item.value = key;
   });
}

function setupDropDown(annotation, item) {
   //PDF Spec p.688
   item.value = annotation.get('Opt') || [];
}

function setupFieldAttributes(annotation, item) {
   //MQZ. Jan.03.2013. additional-actions dictionary
   //PDF Spec P.648. 8.5.2. Trigger Events
   let aa = annotation.get('AA');
   if (!aa) {
      return;
   }

   //PDF Spec p.651 get format dictionary
   let nVal = aa.get('F');
   if (!nVal) {
      nVal = aa.get('K');
      if (!nVal)
         return;
   }

   nVal.forEach(function (key, value) {
      if (key === "JS") {
         processFieldAttribute(value, item);
      }
   });
}

const AFSpecial_Format = ['zip', 'zip', 'phone', 'ssn', ''];
//  let AFNumber_Format = ['nDec', 'sepStyle', 'negStyle', 'currStyle', 'strCurrency', 'bCurrencyPrepend'];
//– nDec is the number of places after the decimal point;
//– sepStyle is an integer denoting whether to use a separator or not. If sepStyle=0, use commas. If sepStyle=1, do not separate.
//– negStyle is the formatting used for negative numbers: 0 = MinusBlack, 1 = Red, 2 = ParensBlack, 3 = ParensRed
//– currStyle is the currency style - not used
//- strCurrency is the currency symbol
//– bCurrencyPrepend
//  let AFDate_FormatEx = ["m/d", "m/d/yy", "mm/dd/yy", "mm/yy", "d-mmm", "d-mmm-yy", "dd-mmm-yy", "yymm-dd", "mmm-yy", "mmmm-yy", "mmm d, yyyy", "mmmm d, yyyy", "m/d/yy h:MM tt", "m/d/yy HH:MM"];

function processFieldAttribute(jsFuncName, item) {
   if (item.hasOwnProperty('TName'))
      return;

   if (!jsFuncName.split)
      return;

   let vParts = jsFuncName.split('(');
   if (vParts.length !== 2)
      return;

   let funcName = vParts[0];
   let funcParam = vParts[1].split(')')[0];

   switch (funcName) {
      case 'AFSpecial_Format':
         item.TName = AFSpecial_Format[Number(funcParam)];
         break;
      case 'AFNumber_Format':
         //              nfs = funcParam.split(',');
         //set the Money fields to use the Number type with no decimal places after, no commas, and bCurrencyPrepend is set as true; (o use a negative sign (fits the PDF layout and our print formatting as well).
         //              if (nfs[0] === '0' && nfs[1] === '1' && nfs[5])
         //                  item.TName = 'money';
         //              else
         item.TName = 'number';
         break;
      case 'AFDate_FormatEx':
         item.TName = 'date';
         item.MV = funcParam.replace(/^'+|^"+|'+$|"+$/g, ''); //mask value
         break;
      case 'AFSpecial_KeystrokeEx': //special format: "arbitrary mask"
         let maskValue = funcParam.replace(/^'+|^"+|'+$|"+$/g, ''); //mask value
         if ((!!maskValue) && maskValue.length > 0 && maskValue.length < 64) {
            item.TName = 'mask'; //fixed length input
            item.MV = maskValue;
         }
         break;
      case 'AFPercent_Format':
         item.TName = 'percent'; //funcParam => 2, 0, will specified how many decimal places
         break;
   }
}

function setupSignature(annotation, item) {
   //PDF Spec p.695: field value is signature dict if signed
   let sig = annotation.get('V');
   if (!sig) return;

   //PDF Spec p.728: get signature information
   item.Sig = {};
   let name = sig.get('Name');
   if (name) item.Sig.Name = name;
   let time = sig.get('M');
   if (time) item.Sig.M = time;
   let location = sig.get('Location');
   if (location) item.Sig.Location = location;
   let reason = sig.get('Reason');
   if (reason) item.Sig.Reason = reason;
   let contactInfo = sig.get('ContactInfo');
   if (contactInfo) item.Sig.ContactInfo = contactInfo;
}

//END - MQZ 9/19/2012. Helper functions to parse acroForm elements

class PDFAnno {
   static processAnnotation(annotation, item) {
      if (item.fieldType == 'Btn') { //PDF Spec p.675
         if (item.fieldFlags & 32768) {
            setupRadioButton(annotation, item);
         }
         else if (item.fieldFlags & 65536) {
            setupPushButton(annotation, item);
         }
         else {
            setupCheckBox(annotation, item);
         }
      }
      else if (item.fieldType == 'Ch') {
         setupDropDown(annotation, item);
      }
      else if (item.fieldType == 'Tx') {
         setupFieldAttributes(annotation, item);
      }
      else if (item.fieldType === 'Sig') {
         setupSignature(annotation, item);
      }
      else {
         nodeUtil.p2jwarn("Unknown fieldType: ", item);
      }
   }
}

class PDFImage {
   #_src = '';
   #_onload = null;

   set onload(val) {
      this.#_onload = typeof val === 'function' ? val : null;
   }

   get onload() {
      return this.#_onload;
   }

   set src(val) {
      this.#_src = val;
      if (this.#_onload) this.#_onload();
   }

   get src() {
      return this.#_src;
   }

   btoa(val) {
      if (typeof window === 'undefined') {
         return (new Buffer.from(val, 'ascii')).toString('base64');
      }
      else if (typeof window.btoa === 'function')
         return window.btoa(val);

      return "";
   }

}

class PTIXmlParser {
   xmlData = null;
   ptiPageArray = [];

   // constructor
   constructor() {
      this.xmlData = null;
      this.ptiPageArray = [];
   }

   parseXml(filePath, callback) {
      fs.readFile(filePath, 'utf8', (err, data) => {
         if (err) {
            callback(err);
         }
         else {
            this.xmlData = data;

            var parser = new xmldom.DOMParser();
            var dom = parser.parseFromString(this.xmlData);
            var root = dom.documentElement;

            var xmlFields = root.getElementsByTagName("field");
            var fields = [];

            for (var i = 0; i < xmlFields.length; i++) {
               var id = xmlFields[i].getAttribute('id');
               var xPos = xmlFields[i].getAttribute('x');
               var yPos = xmlFields[i].getAttribute('y');
               var width = xmlFields[i].getAttribute('width');
               var height = xmlFields[i].getAttribute('height');
               var type = xmlFields[i].getAttribute('xsi:type');
               var page = xmlFields[i].getAttribute('page');
               var fontName = xmlFields[i].getAttribute('fontName');
               var fontSize = xmlFields[i].getAttribute('fontSize');

               var item = {};

               var rectLeft = parseInt(xPos) - 21; //was 23.5
               var rectTop = parseInt(yPos) - 20;//was 23
               var rectRight = parseInt(rectLeft) + parseInt(width) - 4;
               var rectBottom = parseInt(rectTop) + parseInt(height) - 4;

               item.fieldType = "Tx";
               if (type == "Boolean") {
                  item.fieldType = "Btn";
               }
               else if (type == "SSN" || type == "Phone" || type == "zip") {
                  item.TName = type.toLowerCase();
               }
               item.alternativeText = "";
               item.fullName = id;
               item.fontSize = fontSize;
               item.subtype = "Widget";

               item.rect = [rectLeft, rectTop, rectRight, rectBottom];;

               fields.push(item);

               this.ptiPageArray[parseInt(page)] = fields;
            }

         }
         callback();
      });
   }

   getFields(pageNum) {
      return this.ptiPageArray[pageNum];
   }
}

const __filename$2 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('pdfparser.cjs', document.baseURI).href)));
const __dirname$2 = path.dirname(__filename$2);

const pkInfo = JSON.parse(fs.readFileSync(`${__dirname$2}/package.json`, 'utf8'));
const _PARSER_SIG = `${pkInfo.name}@${pkInfo.version} [${pkInfo.homepage}]`;

const __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('pdfparser.cjs', document.baseURI).href)));
const __dirname$1 = path.dirname(__filename$1);

const _pdfjsFiles = [
   'shared/util.js',
   'shared/colorspace.js',
   'shared/pattern.js',
   'shared/function.js',
   'shared/annotation.js',

   'core/core.js',
   'core/obj.js',
   'core/charsets.js',
   'core/crypto.js',
   'core/evaluator.js',
   'core/fonts.js',
   'core/font_renderer.js',
   'core/glyphlist.js',
   'core/image.js',
   'core/metrics.js',
   'core/parser.js',
   'core/stream.js',
   'core/worker.js',
   'core/jpx.js',
   'core/jbig2.js',
   'core/bidi.js',
   'core/jpg.js',
   'core/chunked_stream.js',
   'core/pdf_manager.js',
   'core/cmap.js',
   'core/cidmaps.js',

   'display/canvas.js',
   'display/font_loader.js',
   'display/metadata.js',
   'display/api.js',
];

//////replacing HTML5 canvas with PDFCanvas (in-memory canvas)
function createScratchCanvas(width, height) {
   return new CanvasRenderingContext2D_({}, width, height);
}

const PDFJS = {};
var Image = PDFImage
const globalScope = { console };

const baseDir = `${__dirname}/../base/`;

try {
   const _baseCode = _pdfjsFiles.reduce(
      (preContent, fileName) =>
         (preContent += fs.readFileSync(path.join(baseDir, fileName), 'utf8')),
      ''
   );
   eval(_baseCode);
} catch (error) {
   console.error('Error loading base PDF.js files:', error);
}

////////////////////////////////start of helper classes
class PDFPageParser {
   //static
   static RenderingStates = {
      INITIAL: 0,
      RUNNING: 1,
      PAUSED: 2,
      FINISHED: 3,
   };

   //public
   id = -1;
   pdfPage = null;
   ptiParser = null;
   scale = 0;
   viewport = null;
   renderingState = -1;

   Fields = null;
   Boxsets = null;
   ctxCanvas = null;

   #_addField(field) {
      if (!PDFField.isFormElement(field)) {
         nodeUtil.p2jwarn('NOT valid form element', field);
         return;
      }

      const oneField = new PDFField(
         field,
         this.viewport,
         this.Fields,
         this.Boxsets
      );
      oneField.processField();
   }

   // constructor
   constructor(pdfPage, id, scale, ptiParser) {
      // public, this instance copies
      this.id = id;
      this.pdfPage = pdfPage;
      this.ptiParser = ptiParser;

      this.scale = scale || 1.0;

      //leave out the 2nd parameter in order to use page's default rotation (for both portrait and landscape form)
      this.viewport = this.pdfPage.getViewport(this.scale);

      this.renderingState = PDFPageParser.RenderingStates.INITIAL;

      //form elements other than radio buttons and check boxes
      this.Fields = [];
      //form elements: radio buttons and check boxes
      this.Boxsets = [];
      this.ctxCanvas = {};
   }

   get width() {
      return PDFUnit.toFormX(this.viewport.width);
   }
   get height() {
      return PDFUnit.toFormY(this.viewport.height);
   }
   get HLines() {
      return this.ctxCanvas.HLines;
   }
   get VLines() {
      return this.ctxCanvas.VLines;
   }
   get Fills() {
      return this.ctxCanvas.Fills;
   }
   get Texts() {
      return this.ctxCanvas.Texts;
   }

   destroy() {
      this.pdfPage.destroy();
      this.pdfPage = null;

      this.ptiParser = null;
      this.Fields = null;
      this.Boxsets = null;
      this.ctxCanvas = null;
   }

   getPagePoint(x, y) {
      return this.viewport.convertToPdfPoint(x, y);
   }

   parsePage(callback, errorCallBack) {
      if (this.renderingState !== PDFPageParser.RenderingStates.INITIAL) {
         errorCallBack('Must be in new state before drawing');
         return;
      }

      this.renderingState = PDFPageParser.RenderingStates.RUNNING;

      const canvas = createScratchCanvas(1, 1);
      const ctx = canvas.getContext('2d');

      function pageViewDrawCallback(error) {
         this.renderingState = PDFPageParser.RenderingStates.FINISHED;

         if (error) {
            console.error(error);
            errorCallBack(`Error: Page ${this.id + 1}: ${error.message}`);
         } else {
            if (this.ptiParser) {
               const extraFields = this.ptiParser.getFields(
                  parseInt(this.id) + 1
               );
               extraFields.forEach((field) => this.#_addField(field));
            }

            this.ctxCanvas = ctx.canvas;
            this.stats = this.pdfPage.stats;

            nodeUtil.p2jinfo(`Success: Page ${this.id + 1}`);
            callback();
         }
      }

      const renderContext = {
         canvasContext: ctx,
         viewport: this.viewport,
      };

      this.pdfPage.render(renderContext).then(
         (data) => {
            this.pdfPage.getAnnotations().then(
               (fields) => {
                  fields.forEach((field) => this.#_addField(field));
                  pageViewDrawCallback.call(this, null);
               },
               (err) => errorCallBack('pdfPage.getAnnotations error:' + err)
            );
         },
         (err) => pageViewDrawCallback.call(this, err)
      );
   }
}

////////////////////////////////Start of Node.js Module
class PDFJSClass extends events.EventEmitter {
   pdfDocument = null;
   pages = null;
   rawTextContents = null;

   needRawText = null;

   // constructor
   constructor(needRawText) {
      super();

      // public, this instance copies
      this.pdfDocument = null;
      this.pages = [];
      this.rawTextContents = [];

      this.needRawText = needRawText;
   }

   raiseErrorEvent(errMsg) {
      console.error(errMsg);
      process.nextTick(() => this.emit('pdfjs_parseDataError', errMsg));
      // this.emit("error", errMsg);
      return errMsg;
   }

   raiseReadyEvent(data) {
      process.nextTick(() => this.emit('pdfjs_parseDataReady', data));
      return data;
   }

   parsePDFData(arrayBuffer, password) {
      this.pdfDocument = null;

      const parameters = { password: password, data: arrayBuffer };
      PDFJS.getDocument(parameters).then(
         (pdfDocument) => this.load(pdfDocument, 1),
         (error) => this.raiseErrorEvent(error)
      );
   }

   tryLoadFieldInfoXML(pdfFilePath) {
      const _sufInfo = '_fieldInfo.xml';
      const fieldInfoXMLPath = pdfFilePath.replace('.pdf', _sufInfo);
      if (
         fieldInfoXMLPath.indexOf(_sufInfo) < 1 ||
         !fs.existsSync(fieldInfoXMLPath)
      ) {
         return;
      }
      nodeUtil.p2jinfo('About to load fieldInfo XML : ' + fieldInfoXMLPath);

      this.ptiParser = new PTIXmlParser();
      this.ptiParser.parseXml(fieldInfoXMLPath, (err) => {
         if (err) {
            nodeUtil.p2jwarn('fieldInfo XML Error: ' + JSON.stringify(err));
            this.ptiParser = null;
         } else {
            nodeUtil.p2jinfo('fieldInfo XML loaded.');
         }
      });
   }

   load(pdfDocument, scale) {
      this.pdfDocument = pdfDocument;

      return this.loadMetaData().then(
         () => this.loadPages(),
         (error) => this.raiseErrorEvent('loadMetaData error: ' + error)
      );
   }

   loadMetaData() {
      return this.pdfDocument.getMetadata().then(
         (data) => {
            this.documentInfo = data.info;
            this.metadata = data.metadata?.metadata ?? {};
            this.parseMetaData();
         },
         (error) =>
            this.raiseErrorEvent('pdfDocument.getMetadata error: ' + error)
      );
   }

   parseMetaData() {
      const meta = {
         Transcoder: _PARSER_SIG,
         Meta: { ...this.documentInfo, Metadata: this.metadata },
      };
      this.raiseReadyEvent(meta);
      this.emit('readable', meta);
   }

   loadPages() {
      const pagesCount = this.pdfDocument.numPages;
      const pagePromises = [];
      for (let i = 1; i <= pagesCount; i++)
         pagePromises.push(this.pdfDocument.getPage(i));

      const pagesPromise = PDFJS.Promise.all(pagePromises);

      nodeUtil.p2jinfo('PDF loaded. pagesCount = ' + pagesCount);

      return pagesPromise.then(
         (promisedPages) => this.parsePage(promisedPages, 0, 1.5),
         (error) => this.raiseErrorEvent('pagesPromise error: ' + error)
      );
   }

   parsePage(promisedPages, id, scale) {
      nodeUtil.p2jinfo('start to parse page:' + (id + 1));

      const pdfPage = promisedPages[id];
      const pageParser = new PDFPageParser(pdfPage, id, scale, this.ptiParser);

      function continueOnNextPage() {
         nodeUtil.p2jinfo('complete parsing page:' + (id + 1));
         if (id === this.pdfDocument.numPages - 1) {
            this.raiseReadyEvent({ Pages: this.pages });
            //v1.1.2: signal end of parsed data with null
            process.nextTick(() => this.raiseReadyEvent(null));
            this.emit('data', null);
         } else {
            process.nextTick(() => this.parsePage(promisedPages, ++id, scale));
         }
      }

      pageParser.parsePage(
         (data) => {
            const page = {
               Width: pageParser.width,
               Height: pageParser.height,
               HLines: pageParser.HLines,
               VLines: pageParser.VLines,
               Fills: pageParser.Fills,
               //needs to keep current default output format, text content will output to a separate file if '-c' command line argument is set
               //                Content:pdfPage.getTextContent(),
               Texts: pageParser.Texts,
               Fields: pageParser.Fields,
               Boxsets: pageParser.Boxsets,
            };

            this.pages.push(page);
            this.emit('data', page);

            if (this.needRawText) {
               pdfPage.getTextContent().then(
                  (textContent) => {
                     this.rawTextContents.push(textContent);
                     nodeUtil.p2jinfo(
                        'complete parsing raw text content:' + (id + 1)
                     );
                     continueOnNextPage.call(this);
                  },
                  (error) =>
                     this.raiseErrorEvent(
                        'pdfPage.getTextContent error: ' + error
                     )
               );
            } else {
               continueOnNextPage.call(this);
            }
         },
         (errMsg) => this.raiseErrorEvent(errMsg)
      );
   }

   getRawTextContent() {
      let retVal = '';
      if (!this.needRawText) return retVal;

      this.rawTextContents.forEach((textContent, index) => {
         let prevText = null;
         textContent.bidiTexts.forEach((textObj, idx) => {
            if (prevText) {
               if (Math.abs(textObj.y - prevText.y) <= 9) {
                  prevText.str += textObj.str;
               } else {
                  retVal += prevText.str + '\r\n';
                  prevText = textObj;
               }
            } else {
               prevText = textObj;
            }
         });
         if (prevText) {
            retVal += prevText.str;
         }
         retVal +=
            '\r\n----------------Page (' +
            index +
            ') Break----------------\r\n';
      });

      return retVal;
   }

   getAllFieldsTypes() {
      return PDFField.getAllFieldsTypes({ Pages: this.pages || [] });
   }

   getMergedTextBlocksIfNeeded() {
      for (let p = 0; p < this.pages.length; p++) {
         let prevText = null;
         let page = this.pages[p];

         page.Texts.sort(PDFFont.compareBlockPos);
         page.Texts = page.Texts.filter((t, j) => {
            let isDup =
               j > 0 && PDFFont.areDuplicateBlocks(page.Texts[j - 1], t);
            if (isDup) {
               nodeUtil.p2jinfo(
                  'skipped: dup text block: ' + decodeURIComponent(t.R[0].T)
               );
            }
            return !isDup;
         });

         for (let i = 0; i < page.Texts.length; i++) {
            let text = page.Texts[i];

            if (prevText) {
               if (
                  PDFFont.areAdjacentBlocks(prevText, text) &&
                  PDFFont.haveSameStyle(prevText, text)
               ) {
                  let preT = decodeURIComponent(prevText.R[0].T);
                  let curT = decodeURIComponent(text.R[0].T);

                  prevText.R[0].T += text.R[0].T;
                  prevText.w += text.w;
                  text.merged = true;

                  let mergedText = decodeURIComponent(prevText.R[0].T);
                  nodeUtil.p2jinfo(
                     `merged text block: ${preT} + ${curT} => ${mergedText}`
                  );
                  prevText = null; //yeah, only merge two blocks for now
               } else {
                  prevText = text;
               }
            } else {
               prevText = text;
            }
         }

         page.Texts = page.Texts.filter((t) => !t.merged);
      }

      return { Pages: this.pages };
   }

   destroy() {
      this.removeAllListeners();

      if (this.pdfDocument) this.pdfDocument.destroy();
      this.pdfDocument = null;

      this.pages = null;
      this.rawTextContents = null;
   }
}

class ParserStream extends stream.Transform {
   static createContentStream(jsonObj) {
      const rStream = new stream.Readable({ objectMode: true });
      rStream.push(jsonObj);
      rStream.push(null);
      return rStream;
   }

   static createOutputStream(outputPath, resolve, reject) {
      const outputStream = fs.createWriteStream(outputPath);
      outputStream.on('finish', () => resolve(outputPath));
      outputStream.on('error', err => reject(err));
      return outputStream;
   }

   #pdfParser = null;
   #chunks = [];
   #parsedData = { Pages: [] };
   #_flush_callback = null;

   constructor(pdfParser, options) {
      super(options);
      this.#pdfParser = pdfParser;

      this.#chunks = [];

      // this.#pdfParser.on("pdfParser_dataReady", evtData => {
      //     this.push(evtData);
      //     this.#_flush_callback();
      //     this.emit('end', null);
      // });
      this.#pdfParser.on("readable", meta => this.#parsedData = { ...meta, Pages: [] });
      this.#pdfParser.on("data", page => {
         if (!page) {
            this.push(this.#parsedData);
            this.#_flush_callback();
         }
         else
            this.#parsedData.Pages.push(page);
      });
   }

   //implements transform stream
   _transform(chunk, enc, callback) {
      this.#chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, enc));
      callback();
   }

   _flush(callback) {
      this.#_flush_callback = callback;
      this.#pdfParser.parseBuffer(Buffer.concat(this.#chunks));
   }

   _destroy() {
      super.removeAllListeners();
      this.#pdfParser = null;
      this.#chunks = [];
   }
}


class StringifyStream extends stream.Transform {
   constructor(options) {
      super(options);

      this._readableState.objectMode = false;
      this._writableState.objectMode = true;
   }

   _transform(obj, encoding, callback) {
      this.push(JSON.stringify(obj));
      callback();
   }
}

class PDFParser extends events.EventEmitter { // inherit from event emitter
   //public static
   static get colorDict() { return kColors; }
   static get fontFaceDict() { return kFontFaces; }
   static get fontStyleDict() { return kFontStyles; }

   //private static    
   static #maxBinBufferCount = 10;
   static #binBuffer = {};

   //private 
   #password = "";

   #context = null; // service context object, only used in Web Service project; null in command line

   #pdfFilePath = null; //current PDF file to load and parse, null means loading/parsing not started
   #pdfFileMTime = null; // last time the current pdf was modified, used to recognize changes and ignore cache
   #data = null; //if file read success, data is PDF content; if failed, data is "err" object
   #PDFJS = null; //will be initialized in constructor
   #processFieldInfoXML = false;//disable additional _fieldInfo.xml parsing and merging (do NOT set to true)

   // constructor
   constructor(context, needRawText, password) {
      //call constructor for super class
      super();

      // private
      // service context object, only used in Web Service project; null in command line
      this.#context = context;

      this.#pdfFilePath = null; //current PDF file to load and parse, null means loading/parsing not started
      this.#pdfFileMTime = null; // last time the current pdf was modified, used to recognize changes and ignore cache
      this.#data = null; //if file read success, data is PDF content; if failed, data is "err" object
      this.#processFieldInfoXML = false;//disable additional _fieldInfo.xml parsing and merging (do NOT set to true)

      this.#PDFJS = new PDFJSClass(needRawText);
      this.#password = password;
   }

   //private methods, needs to invoked by [funcName].call(this, ...)
   #onPDFJSParseDataReady(data) {
      if (!data) { //v1.1.2: data===null means end of parsed data
         nodeUtil.p2jinfo("PDF parsing completed.");
         this.emit("pdfParser_dataReady", this.#data);
      }
      else {
         this.#data = { ...this.#data, ...data };
      }
   }

   #onPDFJSParserDataError(err) {
      this.#data = null;
      this.emit("pdfParser_dataError", { "parserError": err });
      // this.emit("error", err);
   }

   #startParsingPDF(buffer) {
      this.#data = {};

      this.#PDFJS.on("pdfjs_parseDataReady", data => this.#onPDFJSParseDataReady(data));
      this.#PDFJS.on("pdfjs_parseDataError", err => this.#onPDFJSParserDataError(err));

      //v1.3.0 the following Readable Stream-like events are replacement for the top two custom events
      this.#PDFJS.on("readable", meta => this.emit("readable", meta));
      this.#PDFJS.on("data", data => this.emit("data", data));
      this.#PDFJS.on("error", err => this.#onPDFJSParserDataError(err));

      this.#PDFJS.parsePDFData(buffer || PDFParser.#binBuffer[this.binBufferKey], this.#password);
   }

   #processBinaryCache() {
      if (this.binBufferKey in PDFParser.#binBuffer) {
         this.#startParsingPDF();
         return true;
      }

      const allKeys = Object.keys(PDFParser.#binBuffer);
      if (allKeys.length > PDFParser.#maxBinBufferCount) {
         const idx = this.id % PDFParser.#maxBinBufferCount;
         const key = allKeys[idx];
         PDFParser.#binBuffer[key] = null;
         delete PDFParser.#binBuffer[key];

         nodeUtil.p2jinfo("re-cycled cache for " + key);
      }

      return false;
   }

   //public getter
   get data() { return this.#data; }
   get binBufferKey() { return this.#pdfFilePath + this.#pdfFileMTime; }

   //public APIs
   createParserStream() {
      return new ParserStream(this, { objectMode: true, bufferSize: 64 * 1024 });
   }

   async loadPDF(pdfFilePath, verbosity) {
      nodeUtil.verbosity(verbosity || 0);
      nodeUtil.p2jinfo("about to load PDF file " + pdfFilePath);

      this.#pdfFilePath = pdfFilePath;

      try {
         this.#pdfFileMTime = fs.statSync(pdfFilePath).mtimeMs;
         if (this.#processFieldInfoXML) {
            this.#PDFJS.tryLoadFieldInfoXML(pdfFilePath);
         }

         if (this.#processBinaryCache())
            return;

         PDFParser.#binBuffer[this.binBufferKey] = await promises.readFile(pdfFilePath);
         nodeUtil.p2jinfo(`Load OK: ${pdfFilePath}`);
         this.#startParsingPDF();
      }
      catch (err) {
         nodeUtil.p2jerror(`Load Failed: ${pdfFilePath} - ${err}`);
         this.emit("pdfParser_dataError", err);
      }
   }

   // Introduce a way to directly process buffers without the need to write it to a temporary file
   parseBuffer(pdfBuffer) {
      this.#startParsingPDF(pdfBuffer);
   }

   getRawTextContent() { return this.#PDFJS.getRawTextContent(); }
   getRawTextContentStream() { return ParserStream.createContentStream(this.getRawTextContent()); }

   getAllFieldsTypes() { return this.#PDFJS.getAllFieldsTypes(); };
   getAllFieldsTypesStream() { return ParserStream.createContentStream(this.getAllFieldsTypes()); }

   getMergedTextBlocksIfNeeded() { return this.#PDFJS.getMergedTextBlocksIfNeeded(); }
   getMergedTextBlocksStream() { return ParserStream.createContentStream(this.getMergedTextBlocksIfNeeded()) }

   destroy() { // invoked with stream transform process		
      super.removeAllListeners();

      //context object will be set in Web Service project, but not in command line utility
      if (this.#context) {
         this.#context.destroy();
         this.#context = null;
      }

      this.#pdfFilePath = null;
      this.#pdfFileMTime = null;
      this.#data = null;
      this.#processFieldInfoXML = false;//disable additional _fieldInfo.xml parsing and merging (do NOT set to true)

      this.#PDFJS.destroy();
      this.#PDFJS = null;
   }
}

module.exports = PDFParser;