pdfjs-dist 2.6.347 → 2.7.570

package/lib/core/annotation.js

@@ -31,12 +31,14 @@ var _util = require("../shared/util.js");
 
 var _obj = require("./obj.js");
 
+var _core_utils = require("./core_utils.js");
+
+var _default_appearance = require("./default_appearance.js");
+
 var _primitives = require("./primitives.js");
 
 var _colorspace = require("./colorspace.js");
 
-var _core_utils = require("./core_utils.js");
-
 var _operator_list = require("./operator_list.js");
 
 var _stream = require("./stream.js");
@@ -165,7 +167,7 @@ function getQuadPoints(dict, rect) {
 
   const quadPoints = dict.getArray("QuadPoints");
 
-  if (!Array.isArray(quadPoints) || quadPoints.length % 8 > 0) {
+  if (!Array.isArray(quadPoints) || quadPoints.length === 0 || quadPoints.length % 8 > 0) {
     return null;
   }
 
@@ -178,7 +180,7 @@ function getQuadPoints(dict, rect) {
       const x = quadPoints[j];
       const y = quadPoints[j + 1];
 
-      if (x < rect[0] || x > rect[2] || y < rect[1] || y > rect[3]) {
+      if (rect !== null && (x < rect[0] || x > rect[2] || y < rect[1] || y > rect[3])) {
         return null;
       }
 
@@ -189,7 +191,22 @@ function getQuadPoints(dict, rect) {
     }
   }
 
-  return quadPointsLists;
+  return quadPointsLists.map(quadPointsList => {
+    const [minX, maxX, minY, maxY] = quadPointsList.reduce(([mX, MX, mY, MY], quadPoint) => [Math.min(mX, quadPoint.x), Math.max(MX, quadPoint.x), Math.min(mY, quadPoint.y), Math.max(MY, quadPoint.y)], [Number.MAX_VALUE, Number.MIN_VALUE, Number.MAX_VALUE, Number.MIN_VALUE]);
+    return [{
+      x: minX,
+      y: maxY
+    }, {
+      x: maxX,
+      y: maxY
+    }, {
+      x: minX,
+      y: minY
+    }, {
+      x: maxX,
+      y: minY
+    }];
+  });
 }
 
 function getTransformMatrix(rect, bbox, matrix) {
@@ -214,6 +231,12 @@ class Annotation {
     this.setColor(dict.getArray("C"));
     this.setBorderStyle(dict);
     this.setAppearance(dict);
+    this._streams = [];
+
+    if (this.appearance) {
+      this._streams.push(this.appearance);
+    }
+
     this.data = {
       annotationFlags: this.flags,
       borderStyle: this.borderStyle,
@@ -225,6 +248,7 @@ class Annotation {
       rect: this.rectangle,
       subtype: params.subtype
     };
+    this._fallbackFontDict = null;
   }
 
   _hasFlag(flags, flag) {
@@ -232,14 +256,28 @@ class Annotation {
   }
 
   _isViewable(flags) {
-    return !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE) && !this._hasFlag(flags, _util.AnnotationFlag.HIDDEN) && !this._hasFlag(flags, _util.AnnotationFlag.NOVIEW);
+    return !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE) && !this._hasFlag(flags, _util.AnnotationFlag.NOVIEW);
   }
 
   _isPrintable(flags) {
-    return this._hasFlag(flags, _util.AnnotationFlag.PRINT) && !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE) && !this._hasFlag(flags, _util.AnnotationFlag.HIDDEN);
+    return this._hasFlag(flags, _util.AnnotationFlag.PRINT) && !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE);
+  }
+
+  isHidden(annotationStorage) {
+    const data = annotationStorage && annotationStorage[this.data.id];
+
+    if (data && "hidden" in data) {
+      return data.hidden;
+    }
+
+    return this._hasFlag(this.flags, _util.AnnotationFlag.HIDDEN);
   }
 
   get viewable() {
+    if (this.data.quadPoints === null) {
+      return false;
+    }
+
     if (this.flags === 0) {
       return true;
     }
@@ -248,6 +286,10 @@ class Annotation {
   }
 
   get printable() {
+    if (this.data.quadPoints === null) {
+      return false;
+    }
+
     if (this.flags === 0) {
       return false;
     }
@@ -409,10 +451,11 @@ class Annotation {
         stream: appearance,
         task,
         resources,
-        operatorList: opList
+        operatorList: opList,
+        fallbackFontDict: this._fallbackFontDict
       }).then(() => {
         opList.addOp(_util.OPS.endAnnotation, []);
-        appearance.reset();
+        this.reset();
         return opList;
       });
     });
@@ -422,6 +465,16 @@ class Annotation {
     return null;
   }
 
+  getFieldObject() {
+    return null;
+  }
+
+  reset() {
+    for (const stream of this._streams) {
+      stream.reset();
+    }
+  }
+
 }
 
 exports.Annotation = Annotation;
@@ -585,6 +638,68 @@ class MarkupAnnotation extends Annotation {
     this.creationDate = (0, _util.isString)(creationDate) ? creationDate : null;
   }
 
+  _setDefaultAppearance({
+    xref,
+    extra,
+    strokeColor,
+    fillColor,
+    blendMode,
+    pointsCallback
+  }) {
+    let minX = Number.MAX_VALUE;
+    let minY = Number.MAX_VALUE;
+    let maxX = Number.MIN_VALUE;
+    let maxY = Number.MIN_VALUE;
+    const buffer = ["q"];
+
+    if (extra) {
+      buffer.push(extra);
+    }
+
+    if (strokeColor) {
+      buffer.push(`${strokeColor[0]} ${strokeColor[1]} ${strokeColor[2]} RG`);
+    }
+
+    if (fillColor) {
+      buffer.push(`${fillColor[0]} ${fillColor[1]} ${fillColor[2]} rg`);
+    }
+
+    for (const points of this.data.quadPoints) {
+      const [mX, MX, mY, MY] = pointsCallback(buffer, points);
+      minX = Math.min(minX, mX);
+      maxX = Math.max(maxX, MX);
+      minY = Math.min(minY, mY);
+      maxY = Math.max(maxY, MY);
+    }
+
+    buffer.push("Q");
+    const formDict = new _primitives.Dict(xref);
+    const appearanceStreamDict = new _primitives.Dict(xref);
+    appearanceStreamDict.set("Subtype", _primitives.Name.get("Form"));
+    const appearanceStream = new _stream.StringStream(buffer.join(" "));
+    appearanceStream.dict = appearanceStreamDict;
+    formDict.set("Fm0", appearanceStream);
+    const gsDict = new _primitives.Dict(xref);
+
+    if (blendMode) {
+      gsDict.set("BM", _primitives.Name.get(blendMode));
+    }
+
+    const stateDict = new _primitives.Dict(xref);
+    stateDict.set("GS0", gsDict);
+    const resources = new _primitives.Dict(xref);
+    resources.set("ExtGState", stateDict);
+    resources.set("XObject", formDict);
+    const appearanceDict = new _primitives.Dict(xref);
+    appearanceDict.set("Resources", resources);
+    const bbox = this.data.rect = [minX, minY, maxX, maxY];
+    appearanceDict.set("BBox", bbox);
+    this.appearance = new _stream.StringStream("/GS0 gs /Fm0 Do");
+    this.appearance.dict = appearanceDict;
+
+    this._streams.push(this.appearance, appearanceStream);
+  }
+
 }
 
 exports.MarkupAnnotation = MarkupAnnotation;
@@ -597,26 +712,47 @@ class WidgetAnnotation extends Annotation {
     this.ref = params.ref;
     data.annotationType = _util.AnnotationType.WIDGET;
     data.fieldName = this._constructFieldName(dict);
+    data.actions = (0, _core_utils.collectActions)(params.xref, dict, _util.AnnotationActionEventType);
     const fieldValue = (0, _core_utils.getInheritableProperty)({
       dict,
       key: "V",
       getArray: true
     });
     data.fieldValue = this._decodeFormValue(fieldValue);
+    const defaultFieldValue = (0, _core_utils.getInheritableProperty)({
+      dict,
+      key: "DV",
+      getArray: true
+    });
+    data.defaultFieldValue = this._decodeFormValue(defaultFieldValue);
     data.alternativeText = (0, _util.stringToPDFString)(dict.get("TU") || "");
-    data.defaultAppearance = (0, _core_utils.getInheritableProperty)({
+    const defaultAppearance = (0, _core_utils.getInheritableProperty)({
       dict,
       key: "DA"
     }) || params.acroForm.get("DA") || "";
+    data.defaultAppearance = (0, _util.isString)(defaultAppearance) ? defaultAppearance : "";
+    data.defaultAppearanceData = (0, _default_appearance.parseDefaultAppearance)(data.defaultAppearance);
     const fieldType = (0, _core_utils.getInheritableProperty)({
       dict,
       key: "FT"
     });
     data.fieldType = (0, _primitives.isName)(fieldType) ? fieldType.name : null;
-    this.fieldResources = (0, _core_utils.getInheritableProperty)({
+    const localResources = (0, _core_utils.getInheritableProperty)({
       dict,
       key: "DR"
-    }) || params.acroForm.get("DR") || _primitives.Dict.empty;
+    });
+    const acroFormResources = params.acroForm.get("DR");
+    const appearanceResources = this.appearance && this.appearance.dict.get("Resources");
+    this._fieldResources = {
+      localResources,
+      acroFormResources,
+      appearanceResources,
+      mergedResources: _primitives.Dict.merge({
+        xref: params.xref,
+        dictArray: [localResources, appearanceResources, acroFormResources],
+        mergeSubDicts: true
+      })
+    };
     data.fieldFlags = (0, _core_utils.getInheritableProperty)({
       dict,
       key: "Ff"
@@ -627,10 +763,12 @@ class WidgetAnnotation extends Annotation {
     }
 
     data.readOnly = this.hasFieldFlag(_util.AnnotationFieldFlag.READONLY);
+    data.hidden = this._hasFlag(data.annotationFlags, _util.AnnotationFlag.HIDDEN);
 
     if (data.fieldType === "Sig") {
       data.fieldValue = null;
       this.setFlags(_util.AnnotationFlag.HIDDEN);
+      data.hidden = true;
     }
   }
 
@@ -711,7 +849,7 @@ class WidgetAnnotation extends Annotation {
       return evaluator.getOperatorList({
         stream,
         task,
-        resources: this.fieldResources,
+        resources: this._fieldResources.mergedResources,
         operatorList
       }).then(function () {
         operatorList.addOp(_util.OPS.endAnnotation, []);
@@ -721,7 +859,9 @@ class WidgetAnnotation extends Annotation {
   }
 
   async save(evaluator, task, annotationStorage) {
-    if (this.data.fieldValue === annotationStorage[this.data.id]) {
+    const value = annotationStorage[this.data.id] && annotationStorage[this.data.id].value;
+
+    if (value === this.data.fieldValue || value === undefined) {
       return null;
     }
 
@@ -731,18 +871,24 @@ class WidgetAnnotation extends Annotation {
       return null;
     }
 
-    const dict = evaluator.xref.fetchIfRef(this.ref);
+    const {
+      xref
+    } = evaluator;
+    const dict = xref.fetchIfRef(this.ref);
 
     if (!(0, _primitives.isDict)(dict)) {
       return null;
     }
 
     const bbox = [0, 0, this.data.rect[2] - this.data.rect[0], this.data.rect[3] - this.data.rect[1]];
-    const newRef = evaluator.xref.getNewRef();
-    const AP = new _primitives.Dict(evaluator.xref);
+    const xfa = {
+      path: (0, _util.stringToPDFString)(dict.get("T") || ""),
+      value
+    };
+    const newRef = xref.getNewRef();
+    const AP = new _primitives.Dict(xref);
     AP.set("N", newRef);
-    const value = annotationStorage[this.data.id];
-    const encrypt = evaluator.xref.encrypt;
+    const encrypt = xref.encrypt;
     let originalTransform = null;
     let newTransform = null;
 
@@ -752,13 +898,13 @@ class WidgetAnnotation extends Annotation {
       appearance = newTransform.encryptString(appearance);
     }
 
-    dict.set("V", value);
+    dict.set("V", (0, _util.isAscii)(value) ? value : (0, _util.stringToUTF16BEString)(value));
     dict.set("AP", AP);
     dict.set("M", `D:${(0, _util.getModificationDate)()}`);
-    const appearanceDict = new _primitives.Dict(evaluator.xref);
+    const appearanceDict = new _primitives.Dict(xref);
     appearanceDict.set("Length", appearance.length);
     appearanceDict.set("Subtype", _primitives.Name.get("Form"));
-    appearanceDict.set("Resources", this.fieldResources);
+    appearanceDict.set("Resources", this._getSaveFieldResources(xref));
     appearanceDict.set("BBox", bbox);
     const bufferOriginal = [`${this.ref.num} ${this.ref.gen} obj\n`];
     (0, _writer.writeDict)(dict, bufferOriginal, originalTransform);
@@ -770,10 +916,12 @@ class WidgetAnnotation extends Annotation {
     bufferNew.push("\nendstream\nendobj\n");
     return [{
       ref: this.ref,
-      data: bufferOriginal.join("")
+      data: bufferOriginal.join(""),
+      xfa
     }, {
       ref: newRef,
-      data: bufferNew.join("")
+      data: bufferNew.join(""),
+      xfa: null
     }];
   }
 
@@ -784,7 +932,11 @@ class WidgetAnnotation extends Annotation {
       return null;
     }
 
-    const value = annotationStorage[this.data.id];
+    const value = annotationStorage[this.data.id] && annotationStorage[this.data.id].value;
+
+    if (value === undefined) {
+      return null;
+    }
 
     if (value === "") {
       return "";
@@ -794,10 +946,16 @@ class WidgetAnnotation extends Annotation {
     const hPadding = defaultPadding;
     const totalHeight = this.data.rect[3] - this.data.rect[1];
     const totalWidth = this.data.rect[2] - this.data.rect[0];
-    const fontInfo = await this._getFontData(evaluator, task);
-    const [font, fontName] = fontInfo;
-    let fontSize = fontInfo[2];
-    fontSize = this._computeFontSize(font, fontName, fontSize, totalHeight);
+
+    if (!this.data.defaultAppearance) {
+      this.data.defaultAppearance = "/Helvetica 0 Tf 0 g";
+      this.data.defaultAppearanceData = (0, _default_appearance.parseDefaultAppearance)(this.data.defaultAppearance);
+    }
+
+    const font = await this._getFontData(evaluator, task);
+
+    const fontSize = this._computeFontSize(font, totalHeight);
+
     let descent = font.descent;
 
     if (isNaN(descent)) {
@@ -808,19 +966,21 @@ class WidgetAnnotation extends Annotation {
     const defaultAppearance = this.data.defaultAppearance;
     const alignment = this.data.textAlignment;
 
-    if (this.data.comb) {
-      return this._getCombAppearance(defaultAppearance, value, totalWidth, hPadding, vPadding);
-    }
-
     if (this.data.multiLine) {
       return this._getMultilineAppearance(defaultAppearance, value, font, fontSize, totalWidth, totalHeight, alignment, hPadding, vPadding);
     }
 
+    const encodedString = font.encodeString(value).join("");
+
+    if (this.data.comb) {
+      return this._getCombAppearance(defaultAppearance, font, encodedString, totalWidth, hPadding, vPadding);
+    }
+
     if (alignment === 0 || alignment > 2) {
-      return "/Tx BMC q BT " + defaultAppearance + ` 1 0 0 1 ${hPadding} ${vPadding} Tm (${(0, _util.escapeString)(value)}) Tj` + " ET Q EMC";
+      return "/Tx BMC q BT " + defaultAppearance + ` 1 0 0 1 ${hPadding} ${vPadding} Tm (${(0, _util.escapeString)(encodedString)}) Tj` + " ET Q EMC";
     }
 
-    const renderedText = this._renderText(value, font, fontSize, totalWidth, alignment, hPadding, vPadding);
+    const renderedText = this._renderText(encodedString, font, fontSize, totalWidth, alignment, hPadding, vPadding);
 
     return "/Tx BMC q BT " + defaultAppearance + ` 1 0 0 1 0 0 Tm ${renderedText}` + " ET Q EMC";
   }
@@ -828,37 +988,50 @@ class WidgetAnnotation extends Annotation {
   async _getFontData(evaluator, task) {
     const operatorList = new _operator_list.OperatorList();
     const initialState = {
-      fontSize: 0,
       font: null,
-      fontName: null,
 
       clone() {
         return this;
       }
 
     };
-    await evaluator.getOperatorList({
-      stream: new _stream.StringStream(this.data.defaultAppearance),
-      task,
-      resources: this.fieldResources,
-      operatorList,
-      initialState
-    });
-    return [initialState.font, initialState.fontName, initialState.fontSize];
-  }
-
-  _computeFontSize(font, fontName, fontSize, height) {
-    if (fontSize === null || fontSize === 0) {
-      const em = font.charsToGlyphs("M", true)[0].width / 1000;
-      const capHeight = 0.7 * em;
-      fontSize = Math.max(1, Math.floor(height / (1.5 * capHeight)));
-      let fontRegex = new RegExp(`/${fontName}\\s+[0-9\.]+\\s+Tf`);
+    const {
+      fontName,
+      fontSize
+    } = this.data.defaultAppearanceData;
+    await evaluator.handleSetFont(this._fieldResources.mergedResources, [fontName, fontSize], null, operatorList, task, initialState, null);
+    return initialState.font;
+  }
+
+  _computeFontSize(font, height) {
+    let fontSize = this.data.defaultAppearanceData.fontSize;
+
+    if (!fontSize) {
+      const {
+        fontColor,
+        fontName
+      } = this.data.defaultAppearanceData;
+      let capHeight;
+
+      if (font.capHeight) {
+        capHeight = font.capHeight;
+      } else {
+        const glyphs = font.charsToGlyphs(font.encodeString("M").join(""));
 
-      if (this.data.defaultAppearance.search(fontRegex) === -1) {
-        fontRegex = new RegExp(`/${fontName}\\s+Tf`);
+        if (glyphs.length === 1 && glyphs[0].width) {
+          const em = glyphs[0].width / 1000;
+          capHeight = 0.7 * em;
+        } else {
+          capHeight = 0.7;
+        }
       }
 
-      this.data.defaultAppearance = this.data.defaultAppearance.replace(fontRegex, `/${fontName} ${fontSize} Tf`);
+      fontSize = Math.max(1, Math.floor(height / (1.5 * capHeight)));
+      this.data.defaultAppearance = (0, _default_appearance.createDefaultAppearance)({
+        fontSize,
+        fontName,
+        fontColor
+      });
     }
 
     return fontSize;
@@ -888,6 +1061,59 @@ class WidgetAnnotation extends Annotation {
     return `${shift} ${vPadding} Td (${(0, _util.escapeString)(text)}) Tj`;
   }
 
+  _getSaveFieldResources(xref) {
+    const {
+      localResources,
+      appearanceResources,
+      acroFormResources
+    } = this._fieldResources;
+    const fontNameStr = this.data.defaultAppearanceData && this.data.defaultAppearanceData.fontName.name;
+
+    if (!fontNameStr) {
+      return localResources || _primitives.Dict.empty;
+    }
+
+    for (const resources of [localResources, appearanceResources]) {
+      if (resources instanceof _primitives.Dict) {
+        const localFont = resources.get("Font");
+
+        if (localFont instanceof _primitives.Dict && localFont.has(fontNameStr)) {
+          return resources;
+        }
+      }
+    }
+
+    if (acroFormResources instanceof _primitives.Dict) {
+      const acroFormFont = acroFormResources.get("Font");
+
+      if (acroFormFont instanceof _primitives.Dict && acroFormFont.has(fontNameStr)) {
+        const subFontDict = new _primitives.Dict(xref);
+        subFontDict.set(fontNameStr, acroFormFont.getRaw(fontNameStr));
+        const subResourcesDict = new _primitives.Dict(xref);
+        subResourcesDict.set("Font", subFontDict);
+        return _primitives.Dict.merge({
+          xref,
+          dictArray: [subResourcesDict, localResources],
+          mergeSubDicts: true
+        });
+      }
+    }
+
+    return localResources || _primitives.Dict.empty;
+  }
+
+  getFieldObject() {
+    if (this.data.fieldType === "Sig") {
+      return {
+        id: this.data.id,
+        value: null,
+        type: "signature"
+      };
+    }
+
+    return null;
+  }
+
 }
 
 class TextWidgetAnnotation extends WidgetAnnotation {
@@ -924,12 +1150,13 @@ class TextWidgetAnnotation extends WidgetAnnotation {
     this.data.comb = this.hasFieldFlag(_util.AnnotationFieldFlag.COMB) && !this.hasFieldFlag(_util.AnnotationFieldFlag.MULTILINE) && !this.hasFieldFlag(_util.AnnotationFieldFlag.PASSWORD) && !this.hasFieldFlag(_util.AnnotationFieldFlag.FILESELECT) && this.data.maxLen !== null;
   }
 
-  _getCombAppearance(defaultAppearance, text, width, hPadding, vPadding) {
+  _getCombAppearance(defaultAppearance, font, text, width, hPadding, vPadding) {
     const combWidth = (width / this.data.maxLen).toFixed(2);
     const buf = [];
+    const positions = font.getCharPositions(text);
 
-    for (const character of text) {
-      buf.push(`(${(0, _util.escapeString)(character)}) Tj`);
+    for (const [start, end] of positions) {
+      buf.push(`(${(0, _util.escapeString)(text.substring(start, end))}) Tj`);
     }
 
     const renderedComb = buf.join(` ${combWidth} 0 Td `);
@@ -955,46 +1182,55 @@ class TextWidgetAnnotation extends WidgetAnnotation {
   }
 
   _splitLine(line, font, fontSize, width) {
-    if (line.length <= 1) {
+    line = font.encodeString(line).join("");
+    const glyphs = font.charsToGlyphs(line);
+
+    if (glyphs.length <= 1) {
       return [line];
     }
 
+    const positions = font.getCharPositions(line);
     const scale = fontSize / 1000;
-    const whitespace = font.charsToGlyphs(" ", true)[0].width * scale;
     const chunks = [];
-    let lastSpacePos = -1,
+    let lastSpacePosInStringStart = -1,
+        lastSpacePosInStringEnd = -1,
+        lastSpacePos = -1,
         startChunk = 0,
         currentWidth = 0;
 
-    for (let i = 0, ii = line.length; i < ii; i++) {
-      const character = line.charAt(i);
-
-      if (character === " ") {
-        if (currentWidth + whitespace > width) {
-          chunks.push(line.substring(startChunk, i));
-          startChunk = i;
-          currentWidth = whitespace;
+    for (let i = 0, ii = glyphs.length; i < ii; i++) {
+      const [start, end] = positions[i];
+      const glyph = glyphs[i];
+      const glyphWidth = glyph.width * scale;
+
+      if (glyph.unicode === " ") {
+        if (currentWidth + glyphWidth > width) {
+          chunks.push(line.substring(startChunk, start));
+          startChunk = start;
+          currentWidth = glyphWidth;
+          lastSpacePosInStringStart = -1;
           lastSpacePos = -1;
         } else {
-          currentWidth += whitespace;
+          currentWidth += glyphWidth;
+          lastSpacePosInStringStart = start;
+          lastSpacePosInStringEnd = end;
           lastSpacePos = i;
         }
       } else {
-        const charWidth = font.charsToGlyphs(character, false)[0].width * scale;
-
-        if (currentWidth + charWidth > width) {
-          if (lastSpacePos !== -1) {
-            chunks.push(line.substring(startChunk, lastSpacePos + 1));
-            startChunk = i = lastSpacePos + 1;
-            lastSpacePos = -1;
+        if (currentWidth + glyphWidth > width) {
+          if (lastSpacePosInStringStart !== -1) {
+            chunks.push(line.substring(startChunk, lastSpacePosInStringEnd));
+            startChunk = lastSpacePosInStringEnd;
+            i = lastSpacePos + 1;
+            lastSpacePosInStringStart = -1;
             currentWidth = 0;
           } else {
-            chunks.push(line.substring(startChunk, i));
-            startChunk = i;
-            currentWidth = charWidth;
+            chunks.push(line.substring(startChunk, start));
+            startChunk = start;
+            currentWidth = glyphWidth;
           }
         } else {
-          currentWidth += charWidth;
+          currentWidth += glyphWidth;
         }
       }
     }
@@ -1006,6 +1242,24 @@ class TextWidgetAnnotation extends WidgetAnnotation {
     return chunks;
   }
 
+  getFieldObject() {
+    return {
+      id: this.data.id,
+      value: this.data.fieldValue,
+      defaultValue: this.data.defaultFieldValue,
+      multiline: this.data.multiLine,
+      password: this.hasFieldFlag(_util.AnnotationFieldFlag.PASSWORD),
+      charLimit: this.data.maxLen,
+      comb: this.data.comb,
+      editable: !this.data.readOnly,
+      hidden: this.data.hidden,
+      name: this.data.fieldName,
+      rect: this.data.rect,
+      actions: this.data.actions,
+      type: "text"
+    };
+  }
+
 }
 
 class ButtonWidgetAnnotation extends WidgetAnnotation {
@@ -1016,6 +1270,7 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
     this.data.checkBox = !this.hasFieldFlag(_util.AnnotationFieldFlag.RADIO) && !this.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
     this.data.radioButton = this.hasFieldFlag(_util.AnnotationFieldFlag.RADIO) && !this.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
     this.data.pushButton = this.hasFieldFlag(_util.AnnotationFieldFlag.PUSHBUTTON);
+    this.data.isTooltipOnly = false;
 
     if (this.data.checkBox) {
       this._processCheckBox(params);
@@ -1034,7 +1289,12 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
     }
 
     if (annotationStorage) {
-      const value = annotationStorage[this.data.id] || false;
+      const value = annotationStorage[this.data.id] && annotationStorage[this.data.id].value;
+
+      if (value === undefined) {
+        return super.getOperatorList(evaluator, task, renderForms, annotationStorage);
+      }
+
       let appearance;
 
       if (value) {
@@ -1066,12 +1326,17 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
       return this._saveRadioButton(evaluator, task, annotationStorage);
     }
 
-    return super.save(evaluator, task, annotationStorage);
+    return null;
   }
 
   async _saveCheckbox(evaluator, task, annotationStorage) {
+    const value = annotationStorage[this.data.id] && annotationStorage[this.data.id].value;
+
+    if (value === undefined) {
+      return null;
+    }
+
     const defaultValue = this.data.fieldValue && this.data.fieldValue !== "Off";
-    const value = annotationStorage[this.data.id];
 
     if (defaultValue === value) {
       return null;
@@ -1083,6 +1348,11 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
       return null;
     }
 
+    const xfa = {
+      path: (0, _util.stringToPDFString)(dict.get("T") || ""),
+      value: value ? this.data.exportValue : ""
+    };
+
     const name = _primitives.Name.get(value ? this.data.exportValue : "Off");
 
     dict.set("V", name);
@@ -1100,13 +1370,19 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
     buffer.push("\nendobj\n");
     return [{
       ref: this.ref,
-      data: buffer.join("")
+      data: buffer.join(""),
+      xfa
     }];
   }
 
   async _saveRadioButton(evaluator, task, annotationStorage) {
+    const value = annotationStorage[this.data.id] && annotationStorage[this.data.id].value;
+
+    if (value === undefined) {
+      return null;
+    }
+
     const defaultValue = this.data.fieldValue === this.data.buttonValue;
-    const value = annotationStorage[this.data.id];
 
     if (defaultValue === value) {
       return null;
@@ -1118,6 +1394,11 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
       return null;
     }
 
+    const xfa = {
+      path: (0, _util.stringToPDFString)(dict.get("T") || ""),
+      value: value ? this.data.buttonValue : ""
+    };
+
     const name = _primitives.Name.get(value ? this.data.buttonValue : "Off");
 
     let parentBuffer = null;
@@ -1154,13 +1435,15 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
     buffer.push("\nendobj\n");
     const newRefs = [{
       ref: this.ref,
-      data: buffer.join("")
+      data: buffer.join(""),
+      xfa
     }];
 
     if (parentBuffer !== null) {
       newRefs.push({
         ref: this.parent,
-        data: parentBuffer.join("")
+        data: parentBuffer.join(""),
+        xfa: null
       });
     }
 
@@ -1193,17 +1476,25 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
     this.data.exportValue = exportValues[0] === "Off" ? exportValues[1] : exportValues[0];
     this.checkedAppearance = normalAppearance.get(this.data.exportValue);
     this.uncheckedAppearance = normalAppearance.get("Off") || null;
+
+    this._streams.push(this.checkedAppearance);
+
+    if (this.uncheckedAppearance) {
+      this._streams.push(this.uncheckedAppearance);
+    }
+
+    this._fallbackFontDict = this.fallbackFontDict;
   }
 
   _processRadioButton(params) {
     this.data.fieldValue = this.data.buttonValue = null;
     const fieldParent = params.dict.get("Parent");
 
-    if ((0, _primitives.isDict)(fieldParent) && fieldParent.has("V")) {
+    if ((0, _primitives.isDict)(fieldParent)) {
+      this.parent = params.dict.getRaw("Parent");
       const fieldParentValue = fieldParent.get("V");
 
       if ((0, _primitives.isName)(fieldParentValue)) {
-        this.parent = params.dict.getRaw("Parent");
         this.data.fieldValue = this._decodeFormValue(fieldParentValue);
       }
     }
@@ -1222,21 +1513,31 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
 
     for (const key of normalAppearance.getKeys()) {
       if (key !== "Off") {
-        this.data.buttonValue = key;
+        this.data.buttonValue = this._decodeFormValue(key);
         break;
       }
     }
 
     this.checkedAppearance = normalAppearance.get(this.data.buttonValue);
     this.uncheckedAppearance = normalAppearance.get("Off") || null;
+
+    this._streams.push(this.checkedAppearance);
+
+    if (this.uncheckedAppearance) {
+      this._streams.push(this.uncheckedAppearance);
+    }
+
+    this._fallbackFontDict = this.fallbackFontDict;
   }
 
   _processPushButton(params) {
-    if (!params.dict.has("A")) {
+    if (!params.dict.has("A") && !params.dict.has("AA") && !this.data.alternativeText) {
       (0, _util.warn)("Push buttons without action dictionaries are not supported");
       return;
     }
 
+    this.data.isTooltipOnly = !params.dict.has("A") && !params.dict.has("AA");
+
     _obj.Catalog.parseDestDictionary({
       destDict: params.dict,
       resultObj: this.data,
@@ -1244,6 +1545,41 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
     });
   }
 
+  getFieldObject() {
+    let type = "button";
+    let exportValues;
+
+    if (this.data.checkBox) {
+      type = "checkbox";
+      exportValues = this.data.exportValue;
+    } else if (this.data.radioButton) {
+      type = "radiobutton";
+      exportValues = this.data.buttonValue;
+    }
+
+    return {
+      id: this.data.id,
+      value: this.data.fieldValue || "Off",
+      defaultValue: this.data.defaultFieldValue,
+      exportValues,
+      editable: !this.data.readOnly,
+      name: this.data.fieldName,
+      rect: this.data.rect,
+      hidden: this.data.hidden,
+      actions: this.data.actions,
+      type
+    };
+  }
+
+  get fallbackFontDict() {
+    const dict = new _primitives.Dict();
+    dict.set("BaseFont", _primitives.Name.get("ZapfDingbats"));
+    dict.set("Type", _primitives.Name.get("FallbackType"));
+    dict.set("Subtype", _primitives.Name.get("FallbackType"));
+    dict.set("Encoding", _primitives.Name.get("ZapfDingbatsEncoding"));
+    return (0, _util.shadow)(this, "fallbackFontDict", dict);
+  }
+
 }
 
 class ChoiceWidgetAnnotation extends WidgetAnnotation {
@@ -1279,6 +1615,24 @@ class ChoiceWidgetAnnotation extends WidgetAnnotation {
     this._hasText = true;
   }
 
+  getFieldObject() {
+    const type = this.data.combo ? "combobox" : "listbox";
+    const value = this.data.fieldValue.length > 0 ? this.data.fieldValue[0] : null;
+    return {
+      id: this.data.id,
+      value,
+      defaultValue: this.data.defaultFieldValue,
+      editable: !this.data.readOnly,
+      name: this.data.fieldName,
+      rect: this.data.rect,
+      numItems: this.data.fieldValue.length,
+      multipleSelection: this.data.multiSelect,
+      hidden: this.data.hidden,
+      actions: this.data.actions,
+      type
+    };
+  }
+
 }
 
 class TextAnnotation extends MarkupAnnotation {
@@ -1341,6 +1695,14 @@ class PopupAnnotation extends Annotation {
     this.data.parentType = (0, _primitives.isName)(parentSubtype) ? parentSubtype.name : null;
     const rawParent = parameters.dict.getRaw("Parent");
     this.data.parentId = (0, _primitives.isRef)(rawParent) ? rawParent.toString() : null;
+    const parentRect = parentItem.getArray("Rect");
+
+    if (Array.isArray(parentRect) && parentRect.length === 4) {
+      this.data.parentRect = _util.Util.normalizeRect(parentRect);
+    } else {
+      this.data.parentRect = [0, 0, 0, 0];
+    }
+
     const rt = parentItem.get("RT");
 
     if ((0, _primitives.isName)(rt, _util.AnnotationReplyType.GROUP)) {
@@ -1412,8 +1774,12 @@ class PolylineAnnotation extends MarkupAnnotation {
   constructor(parameters) {
     super(parameters);
     this.data.annotationType = _util.AnnotationType.POLYLINE;
-    const rawVertices = parameters.dict.getArray("Vertices");
     this.data.vertices = [];
+    const rawVertices = parameters.dict.getArray("Vertices");
+
+    if (!Array.isArray(rawVertices)) {
+      return;
+    }
 
     for (let i = 0, ii = rawVertices.length; i < ii; i += 2) {
       this.data.vertices.push({
@@ -1445,17 +1811,22 @@ class InkAnnotation extends MarkupAnnotation {
   constructor(parameters) {
     super(parameters);
     this.data.annotationType = _util.AnnotationType.INK;
-    const xref = parameters.xref;
-    const originalInkLists = parameters.dict.getArray("InkList");
     this.data.inkLists = [];
+    const rawInkLists = parameters.dict.getArray("InkList");
+
+    if (!Array.isArray(rawInkLists)) {
+      return;
+    }
 
-    for (let i = 0, ii = originalInkLists.length; i < ii; ++i) {
+    const xref = parameters.xref;
+
+    for (let i = 0, ii = rawInkLists.length; i < ii; ++i) {
       this.data.inkLists.push([]);
 
-      for (let j = 0, jj = originalInkLists[i].length; j < jj; j += 2) {
+      for (let j = 0, jj = rawInkLists[i].length; j < jj; j += 2) {
         this.data.inkLists[i].push({
-          x: xref.fetchIfRef(originalInkLists[i][j]),
-          y: xref.fetchIfRef(originalInkLists[i][j + 1])
+          x: xref.fetchIfRef(rawInkLists[i][j]),
+          y: xref.fetchIfRef(rawInkLists[i][j + 1])
         });
       }
     }
@@ -1467,10 +1838,28 @@ class HighlightAnnotation extends MarkupAnnotation {
   constructor(parameters) {
     super(parameters);
     this.data.annotationType = _util.AnnotationType.HIGHLIGHT;
-    const quadPoints = getQuadPoints(parameters.dict, this.rectangle);
+    const quadPoints = this.data.quadPoints = getQuadPoints(parameters.dict, null);
 
     if (quadPoints) {
-      this.data.quadPoints = quadPoints;
+      if (!this.appearance) {
+        const fillColor = this.color ? Array.from(this.color).map(c => c / 255) : [1, 1, 0];
+
+        this._setDefaultAppearance({
+          xref: parameters.xref,
+          fillColor,
+          blendMode: "Multiply",
+          pointsCallback: (buffer, points) => {
+            buffer.push(`${points[0].x} ${points[0].y} m`);
+            buffer.push(`${points[1].x} ${points[1].y} l`);
+            buffer.push(`${points[3].x} ${points[3].y} l`);
+            buffer.push(`${points[2].x} ${points[2].y} l`);
+            buffer.push("f");
+            return [points[0].x, points[1].x, points[3].y, points[1].y];
+          }
+        });
+      }
+    } else {
+      this.data.hasPopup = false;
     }
   }
 
@@ -1480,10 +1869,26 @@ class UnderlineAnnotation extends MarkupAnnotation {
   constructor(parameters) {
     super(parameters);
     this.data.annotationType = _util.AnnotationType.UNDERLINE;
-    const quadPoints = getQuadPoints(parameters.dict, this.rectangle);
+    const quadPoints = this.data.quadPoints = getQuadPoints(parameters.dict, null);
 
     if (quadPoints) {
-      this.data.quadPoints = quadPoints;
+      if (!this.appearance) {
+        const strokeColor = this.color ? Array.from(this.color).map(c => c / 255) : [0, 0, 0];
+
+        this._setDefaultAppearance({
+          xref: parameters.xref,
+          extra: "[] 0 d 1 w",
+          strokeColor,
+          pointsCallback: (buffer, points) => {
+            buffer.push(`${points[2].x} ${points[2].y} m`);
+            buffer.push(`${points[3].x} ${points[3].y} l`);
+            buffer.push("S");
+            return [points[0].x, points[1].x, points[3].y, points[1].y];
+          }
+        });
+      }
+    } else {
+      this.data.hasPopup = false;
     }
   }
 
@@ -1493,10 +1898,37 @@ class SquigglyAnnotation extends MarkupAnnotation {
   constructor(parameters) {
     super(parameters);
     this.data.annotationType = _util.AnnotationType.SQUIGGLY;
-    const quadPoints = getQuadPoints(parameters.dict, this.rectangle);
+    const quadPoints = this.data.quadPoints = getQuadPoints(parameters.dict, null);
 
     if (quadPoints) {
-      this.data.quadPoints = quadPoints;
+      if (!this.appearance) {
+        const strokeColor = this.color ? Array.from(this.color).map(c => c / 255) : [0, 0, 0];
+
+        this._setDefaultAppearance({
+          xref: parameters.xref,
+          extra: "[] 0 d 1 w",
+          strokeColor,
+          pointsCallback: (buffer, points) => {
+            const dy = (points[0].y - points[2].y) / 6;
+            let shift = dy;
+            let x = points[2].x;
+            const y = points[2].y;
+            const xEnd = points[3].x;
+            buffer.push(`${x} ${y + shift} m`);
+
+            do {
+              x += 2;
+              shift = shift === 0 ? dy : 0;
+              buffer.push(`${x} ${y + shift} l`);
+            } while (x < xEnd);
+
+            buffer.push("S");
+            return [points[2].x, xEnd, y - 2 * dy, y + 2 * dy];
+          }
+        });
+      }
+    } else {
+      this.data.hasPopup = false;
     }
   }
 
@@ -1506,10 +1938,26 @@ class StrikeOutAnnotation extends MarkupAnnotation {
   constructor(parameters) {
     super(parameters);
     this.data.annotationType = _util.AnnotationType.STRIKEOUT;
-    const quadPoints = getQuadPoints(parameters.dict, this.rectangle);
+    const quadPoints = this.data.quadPoints = getQuadPoints(parameters.dict, null);
 
     if (quadPoints) {
-      this.data.quadPoints = quadPoints;
+      if (!this.appearance) {
+        const strokeColor = this.color ? Array.from(this.color).map(c => c / 255) : [0, 0, 0];
+
+        this._setDefaultAppearance({
+          xref: parameters.xref,
+          extra: "[] 0 d 1 w",
+          strokeColor,
+          pointsCallback: (buffer, points) => {
+            buffer.push(`${(points[0].x + points[2].x) / 2}` + ` ${(points[0].y + points[2].y) / 2} m`);
+            buffer.push(`${(points[1].x + points[3].x) / 2}` + ` ${(points[1].y + points[3].y) / 2} l`);
+            buffer.push("S");
+            return [points[0].x, points[1].x, points[3].y, points[1].y];
+          }
+        });
+      }
+    } else {
+      this.data.hasPopup = false;
     }
   }