diff --git a/examples/js/annotations.js b/examples/js/annotations.js
new file mode 100644
index 000000000..5914a0b31
--- /dev/null
+++ b/examples/js/annotations.js
@@ -0,0 +1,21 @@
+var doc = new jsPDF({
+    unit: "px",
+    format: [200, 300],
+    floatPrecision: 2,
+});
+
+doc.textWithLink("Click me!", 10, 10, {
+    url: "https://parall.ax/",
+});
+doc.createAnnotation({
+    type: "text",
+    title: "note",
+    bounds: {
+        x: 10,
+        y: 10,
+        w: 200,
+        h: 80
+    },
+    contents: "This is text annotation (closed by default)",
+    open: false
+});
\ No newline at end of file
diff --git a/examples/js/editor.js b/examples/js/editor.js
index 5187d43fc..872a4230d 100644
--- a/examples/js/editor.js
+++ b/examples/js/editor.js
@@ -20,10 +20,12 @@ var jsPDFEditor = (function() {
       "triangles.js": "Triangles",
       "user-input.js": "User input",
       "acroforms.js": "AcroForms",
+      "annotations.js": "Annotations",
       "autoprint.js": "Auto print",
       "arabic.js": "Arabic",
       "russian.js": "Russian",
-      "japanese.js": "Japanese"
+      "japanese.js": "Japanese",
+      "password.js": "Password"
     };
 
   var aceEditor = function() {
diff --git a/examples/js/password.js b/examples/js/password.js
new file mode 100644
index 000000000..9147b8b43
--- /dev/null
+++ b/examples/js/password.js
@@ -0,0 +1,12 @@
+var doc = new jsPDF({
+    encryption: {
+        userPassword: "user",
+        ownerPassword: "owner",
+        userPermissions: ["print", "modify", "copy", "annot-forms"]
+        // try changing the user permissions granted
+    }
+});
+
+doc.setFontSize(40);
+doc.text("Octonyan loves jsPDF", 35, 25);
+doc.addImage("examples/images/Octonyan.jpg", "JPEG", 15, 40, 180, 180);
diff --git a/modules.conf.js b/modules.conf.js
index 57ea8031c..b64dda56e 100644
--- a/modules.conf.js
+++ b/modules.conf.js
@@ -1,388 +1,322 @@
 var configuration = {
-
-    'license': {
-        name: 'License',
-        folder: '',
-        description: 'MIT License Header',
-        deps: []
-    },
-
-
-    'polyfill': {
-        name: 'Polyfill',
-        folder: 'libs',
-        description: 'Adds missing functions to older browsers',
-        deps: []
-    },
-
-    'jspdf': {
-        name: 'Core',
-        folder: '',
-        description: '',
-        deps: [
-            'license',
-            'adler32cs',
-            'rgbcolor'
-        ]
-    },
-
-    'adler32cs': {
-        name: 'Adler32',
-        folder: 'libs',
-        description: 'Adler32',
-        deps: []
-    },
-
-    'rgbcolor': {
-        name: 'rgbcolor',
-        folder: 'libs',
-        description: 'RGBcolor',
-        deps: []
-    },
-
-    'standard_fonts_metrics': {
-        name: 'Standard Font Metrics Plugin',
-        folder: 'modules',
-        description: 'Adds the Font metrics of the 14 Standard Fonts',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'split_text_to_size': {
-        name: 'Split text to size Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf',
-            'standard_fonts_metrics'
-        ]
-    },
-
-    'acroform': {
-        name: 'AcroForm Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf',
-            'annotations'
-        ]
-    },
-
-    'addimage': {
-        name: 'AddImage Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'jpeg_support': {
-        name: 'JPEG Support',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf',
-            'modules/addimage',
-            'libs/JPEGEncoder'
-        ]
-    },
-
-    'JPEGEncoder': {
-        name: 'JPEG Encoder',
-        folder: 'libs',
-        description: '',
-        deps: []
-    },
-
-    'bmp_support': {
-        name: 'BMP Support',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf',
-            'jpeg_support',
-            'BMPDecoder'
-        ]
-    },
-
-    'BMPDecoder': {
-        name: 'BMP Encoder',
-        folder: 'libs',
-        description: '',
-        deps: []
-    },
-
-    'png_support': {
-        name: 'PNG Support',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf',
-            'jpeg_support',
-            'Deflater',
-            'png',
-            'zlib'
-        ]
-    },
-
-    'png': {
-        name: 'PNG Encoder',
-        folder: 'libs',
-        description: '',
-        deps: []
-    },
-    'zlib': {
-        name: 'zlib',
-        folder: 'libs',
-        description: '',
-        deps: []
-    },
-    'Deflater': {
-        name: 'Deflater',
-        folder: 'libs',
-        description: '',
-        deps: []
-    },
-    'gif_support': {
-        name: 'Gif Support',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf',
-            'jpeg_support',
-            'omggif'
-        ]
-    },
-    'omggif': {
-        name: 'omggif',
-        folder: 'libs',
-        description: '',
-        deps: []
-    },
-
-    'webp_support': {
-        name: 'WebP Support',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf',
-            'jpeg_support',
-            'WebPDecoder'
-        ]
-    },
-    'WebPDecoder': {
-        name: 'WebPDecoder',
-        folder: 'libs',
-        description: '',
-        deps: []
-    },
-
-    'annotations': {
-        name: 'Annotations Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf',
-            'standard_fonts_metrics',
-            'split_text_to_size'
-        ]
-    },
-
-    'autoprint': {
-        name: 'AutoPrint Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'cell': {
-        name: 'cell Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'filters': {
-        name: 'Filter Plugin',
-        description: '',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'fileloading': {
-        name: 'FileLoading Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'outline': {
-        name: 'Outline Plugin',
-        folder: 'modules',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'javascript': {
-        name: 'Javascript Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf'
-        ]
-    },
-    'canvas': {
-        name: 'Canvas Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'context2d': {
-        name: 'Context2D Plugin',
-        folder: 'modules',
-        deps: [
-            'jspdf',
-            'canvas',
-            'addimage',
-            'standard_fonts_metrics',
-            'split_text_to_size',
-            'rgbcolor'
-        ]
-    },
-
-    'total_pages': {
-        name: 'TotalPages Plugin',
-        folder: 'modules',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'setlanguage': {
-        name: 'Language Tag Plugin',
-        folder: 'modules',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'svg': {
-        name: 'SVG Plugin',
-        folder: 'modules',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'viewerpreferences': {
-        name: 'ViewerPreferences Plugin',
-        folder: 'modules',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'html': {
-        name: 'HTML Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf',
-            'context2d',
-            'annotations',
-        ]
-    },
-
-    'ttfsupport': {
-        name: 'TTFFont Support',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf',
-            'vfs',
-            'ttffont'
-        ]
-    },
-    'ttffont': {
-        name: 'TTFFont Class',
-        folder: 'libs',
-        description: '',
-        deps: []
-    },
-
-    'modules/utf8': {
-        name: 'UTF8 Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf',
-            'ttfsupport',
-            'bidiEngine'
-        ]
-    },
-
-    'bidiEngine': {
-        name: 'BiDiEngine',
-        folder: 'libs',
-        description: '',
-        deps: []
-    },
-
-    'arabic': {
-        name: 'Arabic Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'utf8'
-        ]
-    },
-
-    'vfs': {
-        name: 'virtual FileSystem Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'xmp_metadata': {
-        name: 'XMP Metadata Plugin',
-        folder: 'modules',
-        description: '',
-        deps: [
-            'jspdf'
-        ]
-    },
-
-    'FileSaver': {
-        name: 'FileSaver',
-        folder: 'libs',
-        description: '',
-        deps: [
-            'Blob'
-        ]
-    },
-
-    'Blob': {
-        name: 'Blob',
-        folder: 'libs',
-        description: '',
-        deps: []
-    }
-}
-
-module.exports = configuration;
\ No newline at end of file
+  license: {
+    name: "License",
+    folder: "",
+    description: "MIT License Header",
+    deps: []
+  },
+
+  polyfill: {
+    name: "Polyfill",
+    folder: "libs",
+    description: "Adds missing functions to older browsers",
+    deps: []
+  },
+
+  jspdf: {
+    name: "Core",
+    folder: "",
+    description: "",
+    deps: ["license", "adler32cs", "rgbcolor"]
+  },
+
+  adler32cs: {
+    name: "Adler32",
+    folder: "libs",
+    description: "Adler32",
+    deps: []
+  },
+
+  rgbcolor: {
+    name: "rgbcolor",
+    folder: "libs",
+    description: "RGBcolor",
+    deps: []
+  },
+
+  standard_fonts_metrics: {
+    name: "Standard Font Metrics Plugin",
+    folder: "modules",
+    description: "Adds the Font metrics of the 14 Standard Fonts",
+    deps: ["jspdf"]
+  },
+
+  split_text_to_size: {
+    name: "Split text to size Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf", "standard_fonts_metrics"]
+  },
+
+  acroform: {
+    name: "AcroForm Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf", "annotations"]
+  },
+
+  addimage: {
+    name: "AddImage Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf"]
+  },
+
+  jpeg_support: {
+    name: "JPEG Support",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf", "modules/addimage", "libs/JPEGEncoder"]
+  },
+
+  JPEGEncoder: {
+    name: "JPEG Encoder",
+    folder: "libs",
+    description: "",
+    deps: []
+  },
+
+  bmp_support: {
+    name: "BMP Support",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf", "jpeg_support", "BMPDecoder"]
+  },
+
+  BMPDecoder: {
+    name: "BMP Encoder",
+    folder: "libs",
+    description: "",
+    deps: []
+  },
+
+  png_support: {
+    name: "PNG Support",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf", "jpeg_support", "Deflater", "png", "zlib"]
+  },
+
+  png: {
+    name: "PNG Encoder",
+    folder: "libs",
+    description: "",
+    deps: []
+  },
+  zlib: {
+    name: "zlib",
+    folder: "libs",
+    description: "",
+    deps: []
+  },
+  Deflater: {
+    name: "Deflater",
+    folder: "libs",
+    description: "",
+    deps: []
+  },
+  gif_support: {
+    name: "Gif Support",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf", "jpeg_support", "omggif"]
+  },
+  omggif: {
+    name: "omggif",
+    folder: "libs",
+    description: "",
+    deps: []
+  },
+
+  webp_support: {
+    name: "WebP Support",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf", "jpeg_support", "WebPDecoder"]
+  },
+  WebPDecoder: {
+    name: "WebPDecoder",
+    folder: "libs",
+    description: "",
+    deps: []
+  },
+
+  annotations: {
+    name: "Annotations Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf", "standard_fonts_metrics", "split_text_to_size"]
+  },
+
+  autoprint: {
+    name: "AutoPrint Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf"]
+  },
+
+  cell: {
+    name: "cell Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf"]
+  },
+
+  filters: {
+    name: "Filter Plugin",
+    description: "",
+    deps: ["jspdf"]
+  },
+
+  fileloading: {
+    name: "FileLoading Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf"]
+  },
+
+  outline: {
+    name: "Outline Plugin",
+    folder: "modules",
+    deps: ["jspdf"]
+  },
+
+  javascript: {
+    name: "Javascript Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf"]
+  },
+  canvas: {
+    name: "Canvas Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf"]
+  },
+
+  context2d: {
+    name: "Context2D Plugin",
+    folder: "modules",
+    deps: [
+      "jspdf",
+      "canvas",
+      "addimage",
+      "standard_fonts_metrics",
+      "split_text_to_size",
+      "rgbcolor"
+    ]
+  },
+
+  total_pages: {
+    name: "TotalPages Plugin",
+    folder: "modules",
+    deps: ["jspdf"]
+  },
+
+  setlanguage: {
+    name: "Language Tag Plugin",
+    folder: "modules",
+    deps: ["jspdf"]
+  },
+
+  svg: {
+    name: "SVG Plugin",
+    folder: "modules",
+    deps: ["jspdf"]
+  },
+
+  viewerpreferences: {
+    name: "ViewerPreferences Plugin",
+    folder: "modules",
+    deps: ["jspdf"]
+  },
+
+  html: {
+    name: "HTML Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf", "context2d", "annotations"]
+  },
+
+  ttfsupport: {
+    name: "TTFFont Support",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf", "vfs", "ttffont"]
+  },
+  ttffont: {
+    name: "TTFFont Class",
+    folder: "libs",
+    description: "",
+    deps: []
+  },
+
+  "modules/utf8": {
+    name: "UTF8 Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf", "ttfsupport", "bidiEngine"]
+  },
+
+  bidiEngine: {
+    name: "BiDiEngine",
+    folder: "libs",
+    description: "",
+    deps: []
+  },
+
+  arabic: {
+    name: "Arabic Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["utf8"]
+  },
+
+  vfs: {
+    name: "virtual FileSystem Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf"]
+  },
+
+  xmp_metadata: {
+    name: "XMP Metadata Plugin",
+    folder: "modules",
+    description: "",
+    deps: ["jspdf"]
+  },
+
+  FileSaver: {
+    name: "FileSaver",
+    folder: "libs",
+    description: "",
+    deps: ["Blob"]
+  },
+
+  Blob: {
+    name: "Blob",
+    folder: "libs",
+    description: "",
+    deps: []
+  },
+  md5: {
+    name: "md5",
+    folder: "libs",
+    description: "Implementation of MD5 hashing",
+    deps: []
+  },
+  rc4: {
+    name: "rc4",
+    folder: "libs",
+    description: "Implementation of RC4 encryption",
+    deps: []
+  },
+  pdfsecurity: {
+    name: "pdfsecurity",
+    folder: "libs",
+    description: "",
+    deps: ["md5", "rc4"]
+  }
+};
+
+module.exports = configuration;
diff --git a/src/jspdf.js b/src/jspdf.js
index a111c5995..de3a7bf3c 100644
--- a/src/jspdf.js
+++ b/src/jspdf.js
@@ -7,6 +7,7 @@ import { globalObject } from "./libs/globalObject.js";
 import { RGBColor } from "./libs/rgbcolor.js";
 import { btoa } from "./libs/AtobBtoa.js";
 import { console } from "./libs/console.js";
+import { PDFSecurity } from "./libs/pdfsecurity.js";
 
 /**
  * jsPDF's Internal PubSub Implementation.
@@ -186,6 +187,10 @@ function TilingPattern(boundingBox, xStep, yStep, gState, matrix) {
  * @param {number} [options.precision=16] Precision of the element-positions.
  * @param {number} [options.userUnit=1.0] Not to be confused with the base unit. Please inform yourself before you use it.
  * @param {string[]} [options.hotfixes] An array of strings to enable hotfixes such as correct pixel scaling.
+ * @param {Object} [options.encryption]
+ * @param {string} [options.encryption.userPassword] Password for the user bound by the given permissions list.
+ * @param {string} [options.encryption.ownerPassword] Both userPassword and ownerPassword should be set for proper authentication.
+ * @param {string[]} [options.encryption.userPermissions] Array of permissions "print", "modify", "copy", "annot-forms", accessible by the user.
  * @param {number|"smart"} [options.floatPrecision=16]
  * @returns {jsPDF} jsPDF-instance
  * @description
@@ -211,6 +216,7 @@ function jsPDF(options) {
   var precision;
   var floatPrecision = 16;
   var defaultPathOperation = "S";
+  var encryptionOptions = null;
 
   options = options || {};
 
@@ -219,6 +225,13 @@ function jsPDF(options) {
     unit = options.unit || unit;
     format = options.format || format;
     compressPdf = options.compress || options.compressPdf || compressPdf;
+    encryptionOptions = options.encryption || null;
+    if (encryptionOptions !== null) {
+      encryptionOptions.userPassword = encryptionOptions.userPassword || "";
+      encryptionOptions.ownerPassword = encryptionOptions.ownerPassword || "";
+      encryptionOptions.userPermissions =
+        encryptionOptions.userPermissions || [];
+    }
     userUnit =
       typeof options.userUnit === "number" ? Math.abs(options.userUnit) : 1.0;
     if (typeof options.precision !== "undefined") {
@@ -546,6 +559,15 @@ function jsPDF(options) {
         })
         .join("");
     }
+
+    if (encryptionOptions !== null) {
+      encryption = new PDFSecurity(
+        encryptionOptions.userPermissions,
+        encryptionOptions.userPassword,
+        encryptionOptions.ownerPassword,
+        fileId
+      );
+    }
     return fileId;
   });
 
@@ -1710,6 +1732,18 @@ function jsPDF(options) {
     var alreadyAppliedFilters = options.alreadyAppliedFilters || [];
     var addLength1 = options.addLength1 || false;
     var valueOfLength1 = data.length;
+    var objectId = options.objectId;
+    var encryptor = function(data) {
+      return data;
+    };
+    if (encryptionOptions !== null && typeof objectId == "undefined") {
+      throw new Error(
+        "ObjectId must be passed to putStream for file encryption"
+      );
+    }
+    if (encryptionOptions !== null) {
+      encryptor = encryption.encryptor(objectId, 0);
+    }
 
     var processedData = {};
     if (filters === true) {
@@ -1778,7 +1812,7 @@ function jsPDF(options) {
     out(">>");
     if (processedData.data.length !== 0) {
       out("stream");
-      out(processedData.data);
+      out(encryptor(processedData.data));
       out("endstream");
     }
   });
@@ -1884,7 +1918,8 @@ function jsPDF(options) {
     newObjectDeferredBegin(pageContentsObjId, true);
     putStream({
       data: pageContent,
-      filters: getFilters()
+      filters: getFilters(),
+      objectId: pageContentsObjId
     });
     out("endobj");
     return pageObjectNumber;
@@ -1933,7 +1968,7 @@ function jsPDF(options) {
 
   var putFont = function(font) {
     var pdfEscapeWithNeededParanthesis = function(text, flags) {
-      var addParanthesis = text.indexOf(" ") !== -1;
+      var addParanthesis = text.indexOf(" ") !== -1; // no space in string
       return addParanthesis
         ? "(" + pdfEscape(text, flags) + ")"
         : pdfEscape(text, flags);
@@ -2003,7 +2038,8 @@ function jsPDF(options) {
     var stream = xObject.pages[1].join("\n");
     putStream({
       data: stream,
-      additionalKeyValues: options
+      additionalKeyValues: options,
+      objectId: xObject.objectNumber
     });
     out("endobj");
   };
@@ -2084,7 +2120,8 @@ function jsPDF(options) {
     putStream({
       data: stream,
       additionalKeyValues: options,
-      alreadyAppliedFilters: ["/ASCIIHexDecode"]
+      alreadyAppliedFilters: ["/ASCIIHexDecode"],
+      objectId: funcObjectNumber
     });
     out("endobj");
 
@@ -2157,7 +2194,8 @@ function jsPDF(options) {
 
     putStream({
       data: pattern.stream,
-      additionalKeyValues: options
+      additionalKeyValues: options,
+      objectId: pattern.objectNumber
     });
     out("endobj");
   };
@@ -2223,6 +2261,19 @@ function jsPDF(options) {
     out(">>");
   };
 
+  var putEncryptionDict = function() {
+    encryption.oid = newObject();
+    out("<<");
+    out("/Filter /Standard");
+    out("/V " + encryption.v);
+    out("/R " + encryption.r);
+    out("/U <" + encryption.toHexString(encryption.U) + ">");
+    out("/O <" + encryption.toHexString(encryption.O) + ">");
+    out("/P " + encryption.P);
+    out(">>");
+    out("endobj");
+  };
+
   var putFontDict = function() {
     out("/Font <<");
 
@@ -2772,9 +2823,15 @@ function jsPDF(options) {
   };
 
   var putInfo = (API.__private__.putInfo = function() {
-    newObject();
+    var objectId = newObject();
+    var encryptor = function(data) {
+      return data;
+    };
+    if (encryptionOptions !== null) {
+      encryptor = encryption.encryptor(objectId, 0);
+    }
     out("<<");
-    out("/Producer (jsPDF " + jsPDF.version + ")");
+    out("/Producer (" + pdfEscape(encryptor("jsPDF " + jsPDF.version)) + ")");
     for (var key in documentProperties) {
       if (documentProperties.hasOwnProperty(key) && documentProperties[key]) {
         out(
@@ -2782,12 +2839,12 @@ function jsPDF(options) {
             key.substr(0, 1).toUpperCase() +
             key.substr(1) +
             " (" +
-            pdfEscape(documentProperties[key]) +
+            pdfEscape(encryptor(documentProperties[key])) +
             ")"
         );
       }
     }
-    out("/CreationDate (" + creationDate + ")");
+    out("/CreationDate (" + pdfEscape(encryptor(creationDate)) + ")");
     out(">>");
     out("endobj");
   });
@@ -2858,8 +2915,12 @@ function jsPDF(options) {
     out("trailer");
     out("<<");
     out("/Size " + (objectNumber + 1));
+    // Root and Info must be the last and second last objects written respectively
     out("/Root " + objectNumber + " 0 R");
     out("/Info " + (objectNumber - 1) + " 0 R");
+    if (encryptionOptions !== null) {
+      out("/Encrypt " + encryption.oid + " 0 R");
+    }
     out("/ID [ <" + fileId + "> <" + fileId + "> ]");
     out(">>");
   });
@@ -2899,6 +2960,7 @@ function jsPDF(options) {
     putPages();
     putAdditionalObjects();
     putResources();
+    if (encryptionOptions !== null) putEncryptionDict();
     putInfo();
     putCatalog();
 
@@ -3028,7 +3090,9 @@ function jsPDF(options) {
             "<style>html, body { padding: 0; margin: 0; } iframe { width: 100%; height: 100%; border: 0;}  </style>" +
             '<body><iframe id="pdfViewer" src="' +
             pdfJsUrl +
-            '?file=&downloadName=' + options.filename + '" width="500px" height="400px" />' +
+            "?file=&downloadName=" +
+            options.filename +
+            '" width="500px" height="400px" />' +
             "</body></html>";
           var PDFjsNewWindow = globalObject.open();
 
@@ -3132,9 +3196,19 @@ function jsPDF(options) {
       throw new Error("Invalid unit: " + unit);
   }
 
+  var encryption = null;
   setCreationDate();
   setFileId();
 
+  var getEncryptor = function(objectId) {
+    if (encryptionOptions !== null) {
+      return encryption.encryptor(objectId, 0);
+    }
+    return function(data) {
+      return data;
+    };
+  };
+
   //---------------------------------------
   // Public API
 
@@ -5822,6 +5896,9 @@ function jsPDF(options) {
         setPageHeight(currentPage, value);
       }
     },
+    encryptionOptions: encryptionOptions,
+    encryption: encryption,
+    getEncryptor: getEncryptor,
     output: output,
     getNumberOfPages: getNumberOfPages,
     pages: pages,
diff --git a/src/libs/md5.js b/src/libs/md5.js
new file mode 100644
index 000000000..a3c68d8ee
--- /dev/null
+++ b/src/libs/md5.js
@@ -0,0 +1,221 @@
+/**
+ * @license
+ * Joseph Myers does not specify a particular license for his work.
+ *
+ * Author: Joseph Myers
+ * Accessed from: http://www.myersdaily.org/joseph/javascript/md5.js
+ *
+ * Modified by: Owen Leong
+ */
+
+function md5cycle(x, k) {
+  var a = x[0],
+    b = x[1],
+    c = x[2],
+    d = x[3];
+
+  a = ff(a, b, c, d, k[0], 7, -680876936);
+  d = ff(d, a, b, c, k[1], 12, -389564586);
+  c = ff(c, d, a, b, k[2], 17, 606105819);
+  b = ff(b, c, d, a, k[3], 22, -1044525330);
+  a = ff(a, b, c, d, k[4], 7, -176418897);
+  d = ff(d, a, b, c, k[5], 12, 1200080426);
+  c = ff(c, d, a, b, k[6], 17, -1473231341);
+  b = ff(b, c, d, a, k[7], 22, -45705983);
+  a = ff(a, b, c, d, k[8], 7, 1770035416);
+  d = ff(d, a, b, c, k[9], 12, -1958414417);
+  c = ff(c, d, a, b, k[10], 17, -42063);
+  b = ff(b, c, d, a, k[11], 22, -1990404162);
+  a = ff(a, b, c, d, k[12], 7, 1804603682);
+  d = ff(d, a, b, c, k[13], 12, -40341101);
+  c = ff(c, d, a, b, k[14], 17, -1502002290);
+  b = ff(b, c, d, a, k[15], 22, 1236535329);
+
+  a = gg(a, b, c, d, k[1], 5, -165796510);
+  d = gg(d, a, b, c, k[6], 9, -1069501632);
+  c = gg(c, d, a, b, k[11], 14, 643717713);
+  b = gg(b, c, d, a, k[0], 20, -373897302);
+  a = gg(a, b, c, d, k[5], 5, -701558691);
+  d = gg(d, a, b, c, k[10], 9, 38016083);
+  c = gg(c, d, a, b, k[15], 14, -660478335);
+  b = gg(b, c, d, a, k[4], 20, -405537848);
+  a = gg(a, b, c, d, k[9], 5, 568446438);
+  d = gg(d, a, b, c, k[14], 9, -1019803690);
+  c = gg(c, d, a, b, k[3], 14, -187363961);
+  b = gg(b, c, d, a, k[8], 20, 1163531501);
+  a = gg(a, b, c, d, k[13], 5, -1444681467);
+  d = gg(d, a, b, c, k[2], 9, -51403784);
+  c = gg(c, d, a, b, k[7], 14, 1735328473);
+  b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+  a = hh(a, b, c, d, k[5], 4, -378558);
+  d = hh(d, a, b, c, k[8], 11, -2022574463);
+  c = hh(c, d, a, b, k[11], 16, 1839030562);
+  b = hh(b, c, d, a, k[14], 23, -35309556);
+  a = hh(a, b, c, d, k[1], 4, -1530992060);
+  d = hh(d, a, b, c, k[4], 11, 1272893353);
+  c = hh(c, d, a, b, k[7], 16, -155497632);
+  b = hh(b, c, d, a, k[10], 23, -1094730640);
+  a = hh(a, b, c, d, k[13], 4, 681279174);
+  d = hh(d, a, b, c, k[0], 11, -358537222);
+  c = hh(c, d, a, b, k[3], 16, -722521979);
+  b = hh(b, c, d, a, k[6], 23, 76029189);
+  a = hh(a, b, c, d, k[9], 4, -640364487);
+  d = hh(d, a, b, c, k[12], 11, -421815835);
+  c = hh(c, d, a, b, k[15], 16, 530742520);
+  b = hh(b, c, d, a, k[2], 23, -995338651);
+
+  a = ii(a, b, c, d, k[0], 6, -198630844);
+  d = ii(d, a, b, c, k[7], 10, 1126891415);
+  c = ii(c, d, a, b, k[14], 15, -1416354905);
+  b = ii(b, c, d, a, k[5], 21, -57434055);
+  a = ii(a, b, c, d, k[12], 6, 1700485571);
+  d = ii(d, a, b, c, k[3], 10, -1894986606);
+  c = ii(c, d, a, b, k[10], 15, -1051523);
+  b = ii(b, c, d, a, k[1], 21, -2054922799);
+  a = ii(a, b, c, d, k[8], 6, 1873313359);
+  d = ii(d, a, b, c, k[15], 10, -30611744);
+  c = ii(c, d, a, b, k[6], 15, -1560198380);
+  b = ii(b, c, d, a, k[13], 21, 1309151649);
+  a = ii(a, b, c, d, k[4], 6, -145523070);
+  d = ii(d, a, b, c, k[11], 10, -1120210379);
+  c = ii(c, d, a, b, k[2], 15, 718787259);
+  b = ii(b, c, d, a, k[9], 21, -343485551);
+
+  x[0] = add32(a, x[0]);
+  x[1] = add32(b, x[1]);
+  x[2] = add32(c, x[2]);
+  x[3] = add32(d, x[3]);
+}
+
+function cmn(q, a, b, x, s, t) {
+  a = add32(add32(a, q), add32(x, t));
+  return add32((a << s) | (a >>> (32 - s)), b);
+}
+
+function ff(a, b, c, d, x, s, t) {
+  return cmn((b & c) | (~b & d), a, b, x, s, t);
+}
+
+function gg(a, b, c, d, x, s, t) {
+  return cmn((b & d) | (c & ~d), a, b, x, s, t);
+}
+
+function hh(a, b, c, d, x, s, t) {
+  return cmn(b ^ c ^ d, a, b, x, s, t);
+}
+
+function ii(a, b, c, d, x, s, t) {
+  return cmn(c ^ (b | ~d), a, b, x, s, t);
+}
+
+function md51(s) {
+  // txt = '';
+  var n = s.length,
+    state = [1732584193, -271733879, -1732584194, 271733878],
+    i;
+  for (i = 64; i <= s.length; i += 64) {
+    md5cycle(state, md5blk(s.substring(i - 64, i)));
+  }
+  s = s.substring(i - 64);
+  var tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+  for (i = 0; i < s.length; i++)
+    tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
+  tail[i >> 2] |= 0x80 << (i % 4 << 3);
+  if (i > 55) {
+    md5cycle(state, tail);
+    for (i = 0; i < 16; i++) tail[i] = 0;
+  }
+  tail[14] = n * 8;
+  md5cycle(state, tail);
+  return state;
+}
+
+/* there needs to be support for Unicode here,
+ * unless we pretend that we can redefine the MD-5
+ * algorithm for multi-byte characters (perhaps
+ * by adding every four 16-bit characters and
+ * shortening the sum to 32 bits). Otherwise
+ * I suggest performing MD-5 as if every character
+ * was two bytes--e.g., 0040 0025 = @%--but then
+ * how will an ordinary MD-5 sum be matched?
+ * There is no way to standardize text to something
+ * like UTF-8 before transformation; speed cost is
+ * utterly prohibitive. The JavaScript standard
+ * itself needs to look at this: it should start
+ * providing access to strings as preformed UTF-8
+ * 8-bit unsigned value arrays.
+ */
+function md5blk(s) {
+  /* I figured global was faster.   */
+  var md5blks = [],
+    i; /* Andy King said do it this way. */
+  for (i = 0; i < 64; i += 4) {
+    md5blks[i >> 2] =
+      s.charCodeAt(i) +
+      (s.charCodeAt(i + 1) << 8) +
+      (s.charCodeAt(i + 2) << 16) +
+      (s.charCodeAt(i + 3) << 24);
+  }
+  return md5blks;
+}
+
+var hex_chr = "0123456789abcdef".split("");
+
+function rhex(n) {
+  var s = "",
+    j = 0;
+  for (; j < 4; j++)
+    s += hex_chr[(n >> (j * 8 + 4)) & 0x0f] + hex_chr[(n >> (j * 8)) & 0x0f];
+  return s;
+}
+
+function hex(x) {
+  for (var i = 0; i < x.length; i++) x[i] = rhex(x[i]);
+  return x.join("");
+}
+
+// Converts a 4-byte number to byte string
+function singleToByteString(n) {
+  return String.fromCharCode(
+    (n & 0xff) >> 0,
+    (n & 0xff00) >> 8,
+    (n & 0xff0000) >> 16,
+    (n & 0xff000000) >> 24
+  );
+}
+
+// Converts an array of numbers to a byte string
+function toByteString(x) {
+  return x.map(singleToByteString).join("");
+}
+
+// Returns the MD5 hash as a byte string
+function md5Bin(s) {
+  return toByteString(md51(s));
+}
+
+// Returns MD5 hash as a hex string
+function md5(s) {
+  return hex(md51(s));
+}
+
+/* this function is much faster,
+so if possible we use it. Some IEs
+are the only ones I know of that
+need the idiotic second function,
+generated by an if clause.  */
+
+function add32(a, b) {
+  return (a + b) & 0xffffffff;
+}
+
+if (md5("hello") != "5d41402abc4b2a76b9719d911017c592") {
+  function add32(x, y) {
+    var lsw = (x & 0xffff) + (y & 0xffff),
+      msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+    return (msw << 16) | (lsw & 0xffff);
+  }
+}
+
+export { md5, md5Bin };
diff --git a/src/libs/pdfsecurity.js b/src/libs/pdfsecurity.js
new file mode 100644
index 000000000..aacc29c4d
--- /dev/null
+++ b/src/libs/pdfsecurity.js
@@ -0,0 +1,162 @@
+/**
+ * @license
+ * Licensed under the MIT License.
+ * http://opensource.org/licenses/mit-license
+ * Author: Owen Leong (@owenl131)
+ * Date: 15 Oct 2020
+ * References:
+ * https://www.cs.cmu.edu/~dst/Adobe/Gallery/anon21jul01-pdf-encryption.txt
+ * https://github.com/foliojs/pdfkit/blob/master/lib/security.js
+ * http://www.fpdf.org/en/script/script37.php
+ */
+
+import { md5Bin } from "./md5.js";
+import { rc4 } from "./rc4.js";
+
+var permissionOptions = {
+  print: 4,
+  modify: 8,
+  copy: 16,
+  "annot-forms": 32
+};
+
+/**
+ * Initializes encryption settings
+ *
+ * @name constructor
+ * @function
+ * @param {Array} permissions Permissions allowed for user, "print", "modify", "copy" and "annot-forms".
+ * @param {String} userPassword Permissions apply to this user. Leaving this empty means the document
+ *                              is not password protected but viewer has the above permissions.
+ * @param {String} ownerPassword Owner has full functionalities to the file.
+ * @param {String} fileId As hex string, should be same as the file ID in the trailer.
+ * @example
+ * var security = new PDFSecurity(["print"])
+ */
+function PDFSecurity(permissions, userPassword, ownerPassword, fileId) {
+  this.v = 1; // algorithm 1, future work can add in more recent encryption schemes
+  this.r = 2; // revision 2
+
+  // set flags for what functionalities the user can access
+  let protection = 192;
+  permissions.forEach(function(perm) {
+    if (typeof permissionOptions.perm !== "undefined") {
+      throw new Error("Invalid permission: " + perm);
+    }
+    protection += permissionOptions[perm];
+  });
+
+  // padding is used to pad the passwords to 32 bytes, also is hashed and stored in the final PDF
+  this.padding =
+    "\x28\xBF\x4E\x5E\x4E\x75\x8A\x41\x64\x00\x4E\x56\xFF\xFA\x01\x08" +
+    "\x2E\x2E\x00\xB6\xD0\x68\x3E\x80\x2F\x0C\xA9\xFE\x64\x53\x69\x7A";
+  let paddedUserPassword = (userPassword + this.padding).substr(0, 32);
+  let paddedOwnerPassword = (ownerPassword + this.padding).substr(0, 32);
+
+  this.O = this.processOwnerPassword(paddedUserPassword, paddedOwnerPassword);
+  this.P = -((protection ^ 255) + 1);
+  this.encryptionKey = md5Bin(
+    paddedUserPassword +
+      this.O +
+      this.lsbFirstWord(this.P) +
+      this.hexToBytes(fileId)
+  ).substr(0, 5);
+  this.U = rc4(this.encryptionKey, this.padding);
+}
+
+/**
+ * Breaks down a 4-byte number into its individual bytes, with the least significant bit first
+ *
+ * @name lsbFirstWord
+ * @function
+ * @param {number} data 32-bit number
+ * @returns {Array}
+ */
+PDFSecurity.prototype.lsbFirstWord = function(data) {
+  return String.fromCharCode(
+    (data >> 0) & 0xff,
+    (data >> 8) & 0xff,
+    (data >> 16) & 0xff,
+    (data >> 24) & 0xff
+  );
+};
+
+/**
+ * Converts a byte string to a hex string
+ *
+ * @name toHexString
+ * @function
+ * @param {String} byteString Byte string
+ * @returns {String}
+ */
+PDFSecurity.prototype.toHexString = function(byteString) {
+  return byteString
+    .split("")
+    .map(function(byte) {
+      return ("0" + (byte.charCodeAt(0) & 0xff).toString(16)).slice(-2);
+    })
+    .join("");
+};
+
+/**
+ * Converts a hex string to a byte string
+ *
+ * @name hexToBytes
+ * @function
+ * @param {String} hex Hex string
+ * @returns {String}
+ */
+PDFSecurity.prototype.hexToBytes = function(hex) {
+  for (var bytes = [], c = 0; c < hex.length; c += 2)
+    bytes.push(String.fromCharCode(parseInt(hex.substr(c, 2), 16)));
+  return bytes.join("");
+};
+
+/**
+ * Computes the 'O' field in the encryption dictionary
+ *
+ * @name processOwnerPassword
+ * @function
+ * @param {String} paddedUserPassword Byte string of padded user password
+ * @param {String} paddedOwnerPassword Byte string of padded owner password
+ * @returns {String}
+ */
+PDFSecurity.prototype.processOwnerPassword = function(
+  paddedUserPassword,
+  paddedOwnerPassword
+) {
+  let key = md5Bin(paddedOwnerPassword).substr(0, 5);
+  return rc4(key, paddedUserPassword);
+};
+
+/**
+ * Returns an encryptor function which can take in a byte string and returns the encrypted version
+ *
+ * @name encryptor
+ * @function
+ * @param {number} objectId
+ * @param {number} generation Not sure what this is for, you can set it to 0
+ * @returns {Function}
+ * @example
+ * out("stream");
+ * encryptor = security.encryptor(object.id, 0);
+ * out(encryptor(data));
+ * out("endstream");
+ */
+PDFSecurity.prototype.encryptor = function(objectId, generation) {
+  let key = md5Bin(
+    this.encryptionKey +
+      String.fromCharCode(
+        objectId & 0xff,
+        (objectId >> 8) & 0xff,
+        (objectId >> 16) & 0xff,
+        generation & 0xff,
+        (generation >> 8) & 0xff
+      )
+  ).substr(0, 10);
+  return function(data) {
+    return rc4(key, data);
+  };
+};
+
+export { PDFSecurity };
diff --git a/src/libs/rc4.js b/src/libs/rc4.js
new file mode 100644
index 000000000..4bac3b185
--- /dev/null
+++ b/src/libs/rc4.js
@@ -0,0 +1,59 @@
+/**
+ * @license
+ * FPDF is released under a permissive license: there is no usage restriction.
+ * You may embed it freely in your application (commercial or not), with or
+ * without modifications.
+ *
+ * Reference: http://www.fpdf.org/en/script/script37.php
+ */
+
+function repeat(str, num) {
+  return new Array(num + 1).join(str);
+}
+
+/**
+ * Converts a byte string to a hex string
+ *
+ * @name rc4
+ * @function
+ * @param {string} key Byte string of encryption key
+ * @param {string} data Byte string of data to be encrypted
+ * @returns {string} Encrypted string
+ */
+function rc4(key, data) {
+  var lastKey, lastState;
+  if (key !== lastKey) {
+    var k = repeat(key, ((256 / key.length) >> 0) + 1);
+    var state = [];
+    for (var i = 0; i < 256; i++) {
+      state[i] = i;
+    }
+    var j = 0;
+    for (var i = 0; i < 256; i++) {
+      var t = state[i];
+      j = (j + t + k.charCodeAt(i)) % 256;
+      state[i] = state[j];
+      state[j] = t;
+    }
+    lastKey = key;
+    lastState = state;
+  } else {
+    state = lastState;
+  }
+  var length = data.length;
+  var a = 0;
+  var b = 0;
+  var out = "";
+  for (var i = 0; i < length; i++) {
+    a = (a + 1) % 256;
+    t = state[a];
+    b = (b + t) % 256;
+    state[a] = state[b];
+    state[b] = t;
+    k = state[(state[a] + state[b]) % 256];
+    out += String.fromCharCode(data.charCodeAt(i) ^ k);
+  }
+  return out;
+}
+
+export { rc4 };
diff --git a/src/modules/acroform.js b/src/modules/acroform.js
index cce824e6a..d333eb28d 100644
--- a/src/modules/acroform.js
+++ b/src/modules/acroform.js
@@ -15,7 +15,6 @@
 import { jsPDF } from "../jspdf.js";
 
 var jsPDFAPI = jsPDF.API;
-var scope;
 var scaleFactor = 1;
 
 var pdfEscape = function(value) {
@@ -141,10 +140,11 @@ var clearBitForPdf = (jsPDFAPI.__acroform__.clearBitForPdf = function(
 });
 
 var calculateCoordinates = (jsPDFAPI.__acroform__.calculateCoordinates = function(
-  args
+  args,
+  scope
 ) {
-  var getHorizontalCoordinate = this.internal.getHorizontalCoordinate;
-  var getVerticalCoordinate = this.internal.getVerticalCoordinate;
+  var getHorizontalCoordinate = scope.internal.getHorizontalCoordinate;
+  var getVerticalCoordinate = scope.internal.getVerticalCoordinate;
   var x = args[0];
   var y = args[1];
   var w = args[2];
@@ -177,9 +177,9 @@ var calculateAppearanceStream = function(formObject) {
   // else calculate it
 
   var stream = [];
-  var text = formObject.V || formObject.DV;
+  var text = formObject._V || formObject.DV;
   var calcRes = calculateX(formObject, text);
-  var fontKey = scope.internal.getFont(
+  var fontKey = formObject.scope.internal.getFont(
     formObject.fontName,
     formObject.fontStyle
   ).id;
@@ -188,7 +188,7 @@ var calculateAppearanceStream = function(formObject) {
   stream.push("/Tx BMC");
   stream.push("q");
   stream.push("BT"); // Begin Text
-  stream.push(scope.__private__.encodeColorString(formObject.color));
+  stream.push(formObject.scope.__private__.encodeColorString(formObject.color));
   stream.push("/" + fontKey + " " + f2(calcRes.fontSize) + " Tf");
   stream.push("1 0 0 1 0 0 Tm"); // Transformation Matrix
   stream.push(calcRes.text);
@@ -196,7 +196,8 @@ var calculateAppearanceStream = function(formObject) {
   stream.push("Q");
   stream.push("EMC");
 
-  var appearanceStreamContent = new createFormXObject(formObject);
+  var appearanceStreamContent = createFormXObject(formObject);
+  appearanceStreamContent.scope = formObject.scope;
   appearanceStreamContent.stream = stream.join("\n");
   return appearanceStreamContent;
 };
@@ -370,15 +371,18 @@ var calculateX = function(formObject, text) {
  * @returns {TextMetrics} (Has Height and Width)
  */
 var calculateFontSpace = function(text, formObject, fontSize) {
-  var font = scope.internal.getFont(formObject.fontName, formObject.fontStyle);
+  var font = formObject.scope.internal.getFont(
+    formObject.fontName,
+    formObject.fontStyle
+  );
   var width =
-    scope.getStringUnitWidth(text, {
+    formObject.scope.getStringUnitWidth(text, {
       font: font,
       fontSize: parseFloat(fontSize),
       charSpace: 0
     }) * parseFloat(fontSize);
   var height =
-    scope.getStringUnitWidth("3", {
+    formObject.scope.getStringUnitWidth("3", {
       font: font,
       fontSize: parseFloat(fontSize),
       charSpace: 0
@@ -407,7 +411,7 @@ var acroformPluginTemplate = {
   isInitialized: false
 };
 
-var annotReferenceCallback = function() {
+var annotReferenceCallback = function(scope) {
   //set objId to undefined and force it to get a new objId on buildDocument
   scope.internal.acroformPlugin.acroFormDictionaryRoot.objId = undefined;
   var fields = scope.internal.acroformPlugin.acroFormDictionaryRoot.Fields;
@@ -420,27 +424,26 @@ var annotReferenceCallback = function() {
       if (formObject.hasAnnotation) {
         // If theres an Annotation Widget in the Form Object, put the
         // Reference in the /Annot array
-        createAnnotationReference.call(scope, formObject);
+        createAnnotationReference(formObject, scope);
       }
     }
   }
 };
 
 var putForm = function(formObject) {
-  if (scope.internal.acroformPlugin.printedOut) {
-    scope.internal.acroformPlugin.printedOut = false;
-    scope.internal.acroformPlugin.acroFormDictionaryRoot = null;
+  if (formObject.scope.internal.acroformPlugin.printedOut) {
+    formObject.scope.internal.acroformPlugin.printedOut = false;
+    formObject.scope.internal.acroformPlugin.acroFormDictionaryRoot = null;
   }
-  if (!scope.internal.acroformPlugin.acroFormDictionaryRoot) {
-    initializeAcroForm.call(scope);
-  }
-  scope.internal.acroformPlugin.acroFormDictionaryRoot.Fields.push(formObject);
+  formObject.scope.internal.acroformPlugin.acroFormDictionaryRoot.Fields.push(
+    formObject
+  );
 };
 /**
  * Create the Reference to the widgetAnnotation, so that it gets referenced
  * in the Annot[] int the+ (Requires the Annotation Plugin)
  */
-var createAnnotationReference = function(object) {
+var createAnnotationReference = function(object, scope) {
   var options = {
     type: "reference",
     object: object
@@ -461,10 +464,10 @@ var createAnnotationReference = function(object) {
 
 // Callbacks
 
-var putCatalogCallback = function() {
+var putCatalogCallback = function(scope) {
   // Put reference to AcroForm to DocumentCatalog
   if (
-    typeof scope.internal.acroformPlugin.acroFormDictionaryRoot != "undefined"
+    typeof scope.internal.acroformPlugin.acroFormDictionaryRoot !== "undefined"
   ) {
     // for safety, shouldn't normally be the case
     scope.internal.write(
@@ -483,7 +486,7 @@ var putCatalogCallback = function() {
  * Adds /Acroform X 0 R to Document Catalog, and creates the AcroForm
  * Dictionary
  */
-var AcroFormDictionaryCallback = function() {
+var AcroFormDictionaryCallback = function(scope) {
   // Remove event
   scope.internal.events.unsubscribe(
     scope.internal.acroformPlugin.acroFormDictionaryRoot._eventID
@@ -498,7 +501,7 @@ var AcroFormDictionaryCallback = function() {
  * If fieldArray is set, use the fields that are inside it instead of the
  * fields from the AcroRoot (for the FormXObjects...)
  */
-var createFieldCallback = function(fieldArray) {
+var createFieldCallback = function(fieldArray, scope) {
   var standardFields = !fieldArray;
 
   if (!fieldArray) {
@@ -522,7 +525,7 @@ var createFieldCallback = function(fieldArray) {
       var oldRect = fieldObject.Rect;
 
       if (fieldObject.Rect) {
-        fieldObject.Rect = calculateCoordinates.call(this, fieldObject.Rect);
+        fieldObject.Rect = calculateCoordinates(fieldObject.Rect, scope);
       }
 
       // Start Writing the Object
@@ -546,7 +549,7 @@ var createFieldCallback = function(fieldArray) {
         !fieldObject.appearanceStreamContent
       ) {
         // Calculate Appearance
-        var appearance = calculateAppearanceStream.call(this, fieldObject);
+        var appearance = calculateAppearanceStream(fieldObject);
         keyValueList.push({ key: "AP", value: "<</N " + appearance + ">>" });
 
         scope.internal.acroformPlugin.xForms.push(appearance);
@@ -570,7 +573,7 @@ var createFieldCallback = function(fieldArray) {
                   if (typeof obj === "function") {
                     // if Function is referenced, call it in order
                     // to get the FormXObject
-                    obj = obj.call(this, fieldObject);
+                    obj = obj.call(scope, fieldObject);
                   }
                   appearanceStreamString += "/" + i + " " + obj + " ";
 
@@ -585,7 +588,7 @@ var createFieldCallback = function(fieldArray) {
               if (typeof obj === "function") {
                 // if Function is referenced, call it in order to
                 // get the FormXObject
-                obj = obj.call(this, fieldObject);
+                obj = obj.call(scope, fieldObject);
               }
               appearanceStreamString += "/" + i + " " + obj;
               if (!(scope.internal.acroformPlugin.xForms.indexOf(obj) >= 0))
@@ -602,26 +605,26 @@ var createFieldCallback = function(fieldArray) {
         });
       }
 
-      scope.internal.putStream({ additionalKeyValues: keyValueList });
+      scope.internal.putStream({
+        additionalKeyValues: keyValueList,
+        objectId: fieldObject.objId
+      });
 
       scope.internal.out("endobj");
     }
   }
   if (standardFields) {
-    createXFormObjectCallback.call(this, scope.internal.acroformPlugin.xForms);
+    createXFormObjectCallback(scope.internal.acroformPlugin.xForms, scope);
   }
 };
 
-var createXFormObjectCallback = function(fieldArray) {
+var createXFormObjectCallback = function(fieldArray, scope) {
   for (var i in fieldArray) {
     if (fieldArray.hasOwnProperty(i)) {
       var key = i;
       var fieldObject = fieldArray[i];
       // Start Writing the Object
-      scope.internal.newObjectDeferredBegin(
-        fieldObject && fieldObject.objId,
-        true
-      );
+      scope.internal.newObjectDeferredBegin(fieldObject.objId, true);
 
       if (
         typeof fieldObject === "object" &&
@@ -634,46 +637,62 @@ var createXFormObjectCallback = function(fieldArray) {
   }
 };
 
-var initializeAcroForm = function() {
+var initializeAcroForm = function(scope, formObject) {
+  formObject.scope = scope;
   if (
-    this.internal !== undefined &&
-    (this.internal.acroformPlugin === undefined ||
-      this.internal.acroformPlugin.isInitialized === false)
+    scope.internal !== undefined &&
+    (scope.internal.acroformPlugin === undefined ||
+      scope.internal.acroformPlugin.isInitialized === false)
   ) {
-    scope = this;
-
     AcroFormField.FieldNum = 0;
-    this.internal.acroformPlugin = JSON.parse(
+    scope.internal.acroformPlugin = JSON.parse(
       JSON.stringify(acroformPluginTemplate)
     );
-    if (this.internal.acroformPlugin.acroFormDictionaryRoot) {
+    if (scope.internal.acroformPlugin.acroFormDictionaryRoot) {
       throw new Error("Exception while creating AcroformDictionary");
     }
     scaleFactor = scope.internal.scaleFactor;
     // The Object Number of the AcroForm Dictionary
     scope.internal.acroformPlugin.acroFormDictionaryRoot = new AcroFormDictionary();
+    scope.internal.acroformPlugin.acroFormDictionaryRoot.scope = scope;
 
     // add Callback for creating the AcroForm Dictionary
     scope.internal.acroformPlugin.acroFormDictionaryRoot._eventID = scope.internal.events.subscribe(
       "postPutResources",
-      AcroFormDictionaryCallback
+      function() {
+        AcroFormDictionaryCallback(scope);
+      }
     );
 
-    scope.internal.events.subscribe("buildDocument", annotReferenceCallback); // buildDocument
+    scope.internal.events.subscribe("buildDocument", function() {
+      annotReferenceCallback(scope);
+    }); // buildDocument
 
     // Register event, that is triggered when the DocumentCatalog is
     // written, in order to add /AcroForm
-    scope.internal.events.subscribe("putCatalog", putCatalogCallback);
+
+    scope.internal.events.subscribe("putCatalog", function() {
+      putCatalogCallback(scope);
+    });
 
     // Register event, that creates all Fields
-    scope.internal.events.subscribe("postPutPages", createFieldCallback);
+    scope.internal.events.subscribe("postPutPages", function(fieldArray) {
+      createFieldCallback(fieldArray, scope);
+    });
 
     scope.internal.acroformPlugin.isInitialized = true;
   }
 };
 
 //PDF 32000-1:2008, page 26, 7.3.6
-var arrayToPdfArray = (jsPDFAPI.__acroform__.arrayToPdfArray = function(array) {
+var arrayToPdfArray = (jsPDFAPI.__acroform__.arrayToPdfArray = function(
+  array,
+  objId,
+  scope
+) {
+  var encryptor = function(data) {
+    return data;
+  };
   if (Array.isArray(array)) {
     var content = "[";
     for (var i = 0; i < array.length; i++) {
@@ -688,7 +707,9 @@ var arrayToPdfArray = (jsPDFAPI.__acroform__.arrayToPdfArray = function(array) {
           break;
         case "string":
           if (array[i].substr(0, 1) !== "/") {
-            content += "(" + pdfEscape(array[i].toString()) + ")";
+            if (typeof objId !== "undefined" && scope)
+              encryptor = scope.internal.getEncryptor(objId);
+            content += "(" + pdfEscape(encryptor(array[i].toString())) + ")";
           } else {
             content += array[i].toString();
           }
@@ -719,10 +740,15 @@ var pdfArrayToStringArray = function(array) {
   return result;
 };
 
-var toPdfString = function(string) {
+var toPdfString = function(string, objId, scope) {
+  var encryptor = function(data) {
+    return data;
+  };
+  if (typeof objId !== "undefined" && scope)
+    encryptor = scope.internal.getEncryptor(objId);
   string = string || "";
   string.toString();
-  string = "(" + pdfEscape(string) + ")";
+  string = "(" + pdfEscape(encryptor(string)) + ")";
   return string;
 };
 
@@ -735,24 +761,31 @@ var toPdfString = function(string) {
  * @classdesc A AcroFormPDFObject
  */
 var AcroFormPDFObject = function() {
-  var _objId;
+  this._objId = undefined;
+  this._scope = undefined;
 
   /**
    * @name AcroFormPDFObject#objId
    * @type {any}
    */
   Object.defineProperty(this, "objId", {
-    configurable: true,
     get: function() {
-      if (!_objId) {
-        _objId = scope.internal.newObjectDeferred();
+      if (typeof this._objId === "undefined") {
+        if (typeof this.scope === "undefined") {
+          return undefined;
+        }
+        this._objId = this.scope.internal.newObjectDeferred();
       }
-      return _objId;
+      return this._objId;
     },
     set: function(value) {
-      _objId = value;
+      this._objId = value;
     }
   });
+  Object.defineProperty(this, "scope", {
+    value: this._scope,
+    writable: true
+  });
 };
 
 /**
@@ -764,11 +797,12 @@ AcroFormPDFObject.prototype.toString = function() {
 
 AcroFormPDFObject.prototype.putStream = function() {
   var keyValueList = this.getKeyValueListForStream();
-  scope.internal.putStream({
+  this.scope.internal.putStream({
     data: this.stream,
-    additionalKeyValues: keyValueList
+    additionalKeyValues: keyValueList,
+    objectId: this.objId
   });
-  scope.internal.out("endobj");
+  this.scope.internal.out("endobj");
 };
 
 /**
@@ -778,41 +812,40 @@ AcroFormPDFObject.prototype.putStream = function() {
  * @returns {string}
  */
 AcroFormPDFObject.prototype.getKeyValueListForStream = function() {
-  var createKeyValueListFromFieldObject = function(fieldObject) {
-    var keyValueList = [];
-    var keys = Object.getOwnPropertyNames(fieldObject).filter(function(key) {
-      return (
-        key != "content" &&
-        key != "appearanceStreamContent" &&
-        key.substring(0, 1) != "_"
-      );
-    });
+  var keyValueList = [];
+  var keys = Object.getOwnPropertyNames(this).filter(function(key) {
+    return (
+      key != "content" &&
+      key != "appearanceStreamContent" &&
+      key != "scope" &&
+      key != "objId" &&
+      key.substring(0, 1) != "_"
+    );
+  });
 
-    for (var i in keys) {
-      if (
-        Object.getOwnPropertyDescriptor(fieldObject, keys[i]).configurable ===
-        false
-      ) {
-        var key = keys[i];
-        var value = fieldObject[key];
-
-        if (value) {
-          if (Array.isArray(value)) {
-            keyValueList.push({ key: key, value: arrayToPdfArray(value) });
-          } else if (value instanceof AcroFormPDFObject) {
-            // In case it is a reference to another PDFObject,
-            // take the reference number
-            keyValueList.push({ key: key, value: value.objId + " 0 R" });
-          } else if (typeof value !== "function") {
-            keyValueList.push({ key: key, value: value });
-          }
+  for (var i in keys) {
+    if (Object.getOwnPropertyDescriptor(this, keys[i]).configurable === false) {
+      var key = keys[i];
+      var value = this[key];
+
+      if (value) {
+        if (Array.isArray(value)) {
+          keyValueList.push({
+            key: key,
+            value: arrayToPdfArray(value, this.objId, this.scope)
+          });
+        } else if (value instanceof AcroFormPDFObject) {
+          // In case it is a reference to another PDFObject,
+          // take the reference number
+          value.scope = this.scope;
+          keyValueList.push({ key: key, value: value.objId + " 0 R" });
+        } else if (typeof value !== "function") {
+          keyValueList.push({ key: key, value: value });
         }
       }
     }
-    return keyValueList;
-  };
-
-  return createKeyValueListFromFieldObject(this);
+  }
+  return keyValueList;
 };
 
 var AcroFormXObject = function() {
@@ -821,25 +854,24 @@ var AcroFormXObject = function() {
   Object.defineProperty(this, "Type", {
     value: "/XObject",
     configurable: false,
-    writeable: true
+    writable: true
   });
 
   Object.defineProperty(this, "Subtype", {
     value: "/Form",
     configurable: false,
-    writeable: true
+    writable: true
   });
 
   Object.defineProperty(this, "FormType", {
     value: 1,
     configurable: false,
-    writeable: true
+    writable: true
   });
 
   var _BBox = [];
   Object.defineProperty(this, "BBox", {
     configurable: false,
-    writeable: true,
     get: function() {
       return _BBox;
     },
@@ -851,7 +883,7 @@ var AcroFormXObject = function() {
   Object.defineProperty(this, "Resources", {
     value: "2 0 R",
     configurable: false,
-    writeable: true
+    writable: true
   });
 
   var _stream;
@@ -906,7 +938,11 @@ var AcroFormDictionary = function() {
       if (!_DA) {
         return undefined;
       }
-      return "(" + _DA + ")";
+      var encryptor = function(data) {
+        return data;
+      };
+      if (this.scope) encryptor = this.scope.internal.getEncryptor(this.objId);
+      return "(" + pdfEscape(encryptor(_DA)) + ")";
     },
     set: function(value) {
       _DA = value;
@@ -1124,7 +1160,11 @@ var AcroFormField = function() {
         }
         _T = "FieldObject" + AcroFormField.FieldNum++;
       }
-      return "(" + pdfEscape(_T) + ")";
+      var encryptor = function(data) {
+        return data;
+      };
+      if (this.scope) encryptor = this.scope.internal.getEncryptor(this.objId);
+      return "(" + pdfEscape(encryptor(_T)) + ")";
     },
     set: function(value) {
       _T = value.toString();
@@ -1263,7 +1303,7 @@ var AcroFormField = function() {
       ) {
         return undefined;
       }
-      return toPdfString(_DA);
+      return toPdfString(_DA, this.objId, this.scope);
     },
     set: function(value) {
       value = value.toString();
@@ -1280,7 +1320,7 @@ var AcroFormField = function() {
         return undefined;
       }
       if (this instanceof AcroFormButton === false) {
-        return toPdfString(_DV);
+        return toPdfString(_DV, this.objId, this.scope);
       }
       return _DV;
     },
@@ -1326,6 +1366,19 @@ var AcroFormField = function() {
   });
 
   var _V = null;
+  Object.defineProperty(this, "_V", {
+    enumerable: false,
+    configurable: false,
+    get: function() {
+      if (!_V) {
+        return undefined;
+      }
+      return _V;
+    },
+    set: function(value) {
+      this.V = value;
+    }
+  });
   Object.defineProperty(this, "V", {
     enumerable: false,
     configurable: false,
@@ -1334,7 +1387,7 @@ var AcroFormField = function() {
         return undefined;
       }
       if (this instanceof AcroFormButton === false) {
-        return toPdfString(_V);
+        return toPdfString(_V, this.objId, this.scope);
       }
       return _V;
     },
@@ -1421,7 +1474,6 @@ var AcroFormField = function() {
   Object.defineProperty(this, "hasAppearanceStream", {
     enumerable: true,
     configurable: true,
-    writeable: true,
     get: function() {
       return _hasAppearanceStream;
     },
@@ -1441,7 +1493,6 @@ var AcroFormField = function() {
   Object.defineProperty(this, "page", {
     enumerable: true,
     configurable: true,
-    writeable: true,
     get: function() {
       if (!_page) {
         return undefined;
@@ -1637,7 +1688,7 @@ var AcroFormChoiceField = function() {
     enumerable: true,
     configurable: false,
     get: function() {
-      return arrayToPdfArray(_Opt);
+      return arrayToPdfArray(_Opt, this.objId, this.scope);
     },
     set: function(value) {
       _Opt = pdfArrayToStringArray(value);
@@ -1983,12 +2034,16 @@ var AcroFormButton = function() {
     enumerable: false,
     configurable: false,
     get: function() {
+      var encryptor = function(data) {
+        return data;
+      };
+      if (this.scope) encryptor = this.scope.internal.getEncryptor(this.objId);
       if (Object.keys(_MK).length !== 0) {
         var result = [];
         result.push("<<");
         var key;
         for (key in _MK) {
-          result.push("/" + key + " (" + _MK[key] + ")");
+          result.push("/" + key + " (" + pdfEscape(encryptor(_MK[key])) + ")");
         }
         result.push(">>");
         return result.join("\n");
@@ -2135,11 +2190,15 @@ var AcroFormChildClass = function() {
     enumerable: false,
     configurable: false,
     get: function() {
+      var encryptor = function(data) {
+        return data;
+      };
+      if (this.scope) encryptor = this.scope.internal.getEncryptor(this.objId);
       var result = [];
       result.push("<<");
       var key;
       for (key in _MK) {
-        result.push("/" + key + " (" + _MK[key] + ")");
+        result.push("/" + key + " (" + pdfEscape(encryptor(_MK[key])) + ")");
       }
       result.push(">>");
       return result.join("\n");
@@ -2240,7 +2299,7 @@ AcroFormRadioButton.prototype.createOption = function(name) {
   // Add to Parent
   this.Kids.push(child);
 
-  addField.call(this, child);
+  addField.call(this.scope, child);
 
   return child;
 };
@@ -2492,13 +2551,16 @@ var AcroFormAppearance = {
      * @returns {AcroFormXObject}
      */
     YesPushDown: function(formObject) {
-      var xobj = new createFormXObject(formObject);
+      var xobj = createFormXObject(formObject);
+      xobj.scope = formObject.scope;
       var stream = [];
-      var fontKey = scope.internal.getFont(
+      var fontKey = formObject.scope.internal.getFont(
         formObject.fontName,
         formObject.fontStyle
       ).id;
-      var encodedColor = scope.__private__.encodeColorString(formObject.color);
+      var encodedColor = formObject.scope.__private__.encodeColorString(
+        formObject.color
+      );
       var calcRes = calculateX(formObject, formObject.caption);
       stream.push("0.749023 g");
       stream.push(
@@ -2525,12 +2587,15 @@ var AcroFormAppearance = {
     },
 
     YesNormal: function(formObject) {
-      var xobj = new createFormXObject(formObject);
-      var fontKey = scope.internal.getFont(
+      var xobj = createFormXObject(formObject);
+      xobj.scope = formObject.scope;
+      var fontKey = formObject.scope.internal.getFont(
         formObject.fontName,
         formObject.fontStyle
       ).id;
-      var encodedColor = scope.__private__.encodeColorString(formObject.color);
+      var encodedColor = formObject.scope.__private__.encodeColorString(
+        formObject.color
+      );
       var stream = [];
       var height = AcroFormAppearance.internal.getHeight(formObject);
       var width = AcroFormAppearance.internal.getWidth(formObject);
@@ -2561,7 +2626,8 @@ var AcroFormAppearance = {
      * @returns {AcroFormXObject}
      */
     OffPushDown: function(formObject) {
-      var xobj = new createFormXObject(formObject);
+      var xobj = createFormXObject(formObject);
+      xobj.scope = formObject.scope;
       var stream = [];
       stream.push("0.749023 g");
       stream.push(
@@ -2597,7 +2663,8 @@ var AcroFormAppearance = {
       },
 
       YesNormal: function(formObject) {
-        var xobj = new createFormXObject(formObject);
+        var xobj = createFormXObject(formObject);
+        xobj.scope = formObject.scope;
         var stream = [];
         // Make the Radius of the Circle relative to min(height, width) of formObject
         var DotRadius =
@@ -2677,7 +2744,8 @@ var AcroFormAppearance = {
         return xobj;
       },
       YesPushDown: function(formObject) {
-        var xobj = new createFormXObject(formObject);
+        var xobj = createFormXObject(formObject);
+        xobj.scope = formObject.scope;
         var stream = [];
         var DotRadius =
           AcroFormAppearance.internal.getWidth(formObject) <=
@@ -2685,7 +2753,7 @@ var AcroFormAppearance = {
             ? AcroFormAppearance.internal.getWidth(formObject) / 4
             : AcroFormAppearance.internal.getHeight(formObject) / 4;
         // The Borderpadding...
-        var DotRadius = Number((DotRadius * 0.9).toFixed(5));
+        DotRadius = Number((DotRadius * 0.9).toFixed(5));
         // Save results for later use; no need to waste
         // processor ticks on doing math
         var k = Number((DotRadius * 2).toFixed(5));
@@ -2781,7 +2849,8 @@ var AcroFormAppearance = {
         return xobj;
       },
       OffPushDown: function(formObject) {
-        var xobj = new createFormXObject(formObject);
+        var xobj = createFormXObject(formObject);
+        xobj.scope = formObject.scope;
         var stream = [];
         var DotRadius =
           AcroFormAppearance.internal.getWidth(formObject) <=
@@ -2846,7 +2915,8 @@ var AcroFormAppearance = {
       },
 
       YesNormal: function(formObject) {
-        var xobj = new createFormXObject(formObject);
+        var xobj = createFormXObject(formObject);
+        xobj.scope = formObject.scope;
         var stream = [];
         var cross = AcroFormAppearance.internal.calculateCross(formObject);
         stream.push("q");
@@ -2869,7 +2939,8 @@ var AcroFormAppearance = {
         return xobj;
       },
       YesPushDown: function(formObject) {
-        var xobj = new createFormXObject(formObject);
+        var xobj = createFormXObject(formObject);
+        xobj.scope = formObject.scope;
         var cross = AcroFormAppearance.internal.calculateCross(formObject);
         var stream = [];
         stream.push("0.749023 g");
@@ -2901,7 +2972,8 @@ var AcroFormAppearance = {
         return xobj;
       },
       OffPushDown: function(formObject) {
-        var xobj = new createFormXObject(formObject);
+        var xobj = createFormXObject(formObject);
+        xobj.scope = formObject.scope;
         var stream = [];
         stream.push("0.749023 g");
         stream.push(
@@ -2926,11 +2998,13 @@ var AcroFormAppearance = {
   createDefaultAppearanceStream: function(formObject) {
     // Set Helvetica to Standard Font (size: auto)
     // Color: Black
-    var fontKey = scope.internal.getFont(
+    var fontKey = formObject.scope.internal.getFont(
       formObject.fontName,
       formObject.fontStyle
     ).id;
-    var encodedColor = scope.__private__.encodeColorString(formObject.color);
+    var encodedColor = formObject.scope.__private__.encodeColorString(
+      formObject.color
+    );
     var fontSize = formObject.fontSize;
     var result = "/" + fontKey + " " + fontSize + " Tf " + encodedColor;
     return result;
@@ -2998,14 +3072,14 @@ AcroFormAppearance.internal.getHeight = function(formObject) {
  * @returns {jsPDF}
  */
 var addField = (jsPDFAPI.addField = function(fieldObject) {
-  initializeAcroForm.call(this);
+  initializeAcroForm(this, fieldObject);
 
   if (fieldObject instanceof AcroFormField) {
-    putForm.call(this, fieldObject);
+    putForm(fieldObject);
   } else {
     throw new Error("Invalid argument passed to jsPDF.addField.");
   }
-  fieldObject.page = scope.internal.getCurrentPageInfo().pageNumber;
+  fieldObject.page = fieldObject.scope.internal.getCurrentPageInfo().pageNumber;
   return this;
 });
 
diff --git a/src/modules/addimage.js b/src/modules/addimage.js
index d441cb6b1..5d206606f 100644
--- a/src/modules/addimage.js
+++ b/src/modules/addimage.js
@@ -262,7 +262,8 @@ import { atob, btoa } from "../libs/AtobBtoa.js";
     putStream({
       data: image.data,
       additionalKeyValues: additionalKeyValues,
-      alreadyAppliedFilters: alreadyAppliedFilters
+      alreadyAppliedFilters: alreadyAppliedFilters,
+      objectId: image.objectId
     });
 
     out("endobj");
@@ -292,11 +293,12 @@ import { atob, btoa } from "../libs/AtobBtoa.js";
 
     //Palette
     if (image.colorSpace === color_spaces.INDEXED) {
-      this.internal.newObject();
+      var objId = this.internal.newObject();
       //out('<< /Filter / ' + img['f'] +' /Length ' + img['pal'].length + '>>');
       //putStream(zlib.compress(img['pal']));
       putStream({
-        data: arrayBufferToBinaryString(new Uint8Array(image.palette))
+        data: arrayBufferToBinaryString(new Uint8Array(image.palette)),
+        objectId: objId
       });
       out("endobj");
     }
diff --git a/src/modules/annotations.js b/src/modules/annotations.js
index 2900c38f8..a9207b667 100644
--- a/src/modules/annotations.js
+++ b/src/modules/annotations.js
@@ -110,6 +110,8 @@ import { jsPDF } from "../jspdf.js";
       this.internal.write("/Annots [");
       for (var i = 0; i < pageAnnos.length; i++) {
         anno = pageAnnos[i];
+        var escape = this.internal.pdfEscape;
+        var encryptor = this.internal.getEncryptor(putPageData.objId);
 
         switch (anno.type) {
           case "reference":
@@ -120,6 +122,7 @@ import { jsPDF } from "../jspdf.js";
             // Create a an object for both the text and the popup
             var objText = this.internal.newAdditionalObject();
             var objPopup = this.internal.newAdditionalObject();
+            var encryptorText = this.internal.getEncryptor(objText.objId);
 
             var title = anno.title || "Note";
             rect =
@@ -132,17 +135,18 @@ import { jsPDF } from "../jspdf.js";
               " " +
               getVerticalCoordinateString(anno.bounds.y) +
               "] ";
+
             line =
               "<</Type /Annot /Subtype /" +
               "Text" +
               " " +
               rect +
               "/Contents (" +
-              anno.contents +
+              escape(encryptorText(anno.contents)) +
               ")";
             line += " /Popup " + objPopup.objId + " 0 R";
             line += " /P " + pageInfo.objId + " 0 R";
-            line += " /T (" + title + ") >>";
+            line += " /T (" + escape(encryptorText(title)) + ") >>";
             objText.content = line;
 
             var parent = objText.objId + " 0 R";
@@ -193,7 +197,7 @@ import { jsPDF } from "../jspdf.js";
               " " +
               rect +
               "/Contents (" +
-              anno.contents +
+              escape(encryptor(anno.contents)) +
               ")";
             line +=
               " /DS(font: Helvetica,sans-serif 12.0pt; text-align:left; color:#" +
@@ -231,7 +235,7 @@ import { jsPDF } from "../jspdf.js";
                 "<</Type /Annot /Subtype /Link " +
                 rect +
                 "/Border [0 0 0] /A <</S /URI /URI (" +
-                anno.options.url +
+                escape(encryptor(anno.options.url)) +
                 ") >>";
             } else if (anno.options.pageNumber) {
               // first page is 0
diff --git a/src/modules/html.js b/src/modules/html.js
index 5fff1aaf4..1cbae5bee 100644
--- a/src/modules/html.js
+++ b/src/modules/html.js
@@ -970,8 +970,8 @@ import { globalObject } from "../libs/globalObject.js";
    * @param {Object} [options] Collection of settings
    * @param {function} [options.callback] The mandatory callback-function gets as first parameter the current jsPDF instance
    * @param {number|array} [options.margin] Array of margins [left, bottom, right, top]
-   * @param {string} [options.filename] name of the file 
-   * @param {HTMLOptionImage} [options.image] image settings when converting HTML to image 
+   * @param {string} [options.filename] name of the file
+   * @param {HTMLOptionImage} [options.image] image settings when converting HTML to image
    * @param {Html2CanvasOptions} [options.html2canvas] html2canvas options
    * @param {jsPDF} [options.jsPDF] jsPDF instance
    * @param {number} [options.x] x position on the PDF document
diff --git a/src/modules/utf8.js b/src/modules/utf8.js
index f82cb6be5..8c2b0c982 100644
--- a/src/modules/utf8.js
+++ b/src/modules/utf8.js
@@ -101,12 +101,12 @@ import { jsPDF } from "../jspdf.js";
         pdfOutput2 += String.fromCharCode(pdfOutput[i]);
       }
       var fontTable = newObject();
-      putStream({ data: pdfOutput2, addLength1: true });
+      putStream({ data: pdfOutput2, addLength1: true, objectId: fontTable });
       out("endobj");
 
       var cmap = newObject();
       var cmapData = toUnicodeCmap(font.metadata.toUnicode);
-      putStream({ data: cmapData, addLength1: true });
+      putStream({ data: cmapData, addLength1: true, objectId: cmap });
       out("endobj");
 
       var fontDescriptor = newObject();
@@ -183,12 +183,12 @@ import { jsPDF } from "../jspdf.js";
         pdfOutput2 += String.fromCharCode(pdfOutput[i]);
       }
       var fontTable = newObject();
-      putStream({ data: pdfOutput2, addLength1: true });
+      putStream({ data: pdfOutput2, addLength1: true, objectId: fontTable });
       out("endobj");
 
       var cmap = newObject();
       var cmapData = toUnicodeCmap(font.metadata.toUnicode);
-      putStream({ data: cmapData, addLength1: true });
+      putStream({ data: cmapData, addLength1: true, objectId: cmap });
       out("endobj");
 
       var fontDescriptor = newObject();
diff --git a/test/reference/closed.pdf b/test/reference/closed.pdf
index acfd258f1..33483607e 100644
Binary files a/test/reference/closed.pdf and b/test/reference/closed.pdf differ
diff --git a/test/reference/encrypted_printable.pdf b/test/reference/encrypted_printable.pdf
new file mode 100644
index 000000000..0e7a97162
Binary files /dev/null and b/test/reference/encrypted_printable.pdf differ
diff --git a/test/reference/encrypted_standard.pdf b/test/reference/encrypted_standard.pdf
new file mode 100644
index 000000000..cdc5d3188
Binary files /dev/null and b/test/reference/encrypted_standard.pdf differ
diff --git a/test/reference/encrypted_withAcroForm.pdf b/test/reference/encrypted_withAcroForm.pdf
new file mode 100644
index 000000000..536d36f91
Binary files /dev/null and b/test/reference/encrypted_withAcroForm.pdf differ
diff --git a/test/reference/encrypted_withImage.pdf b/test/reference/encrypted_withImage.pdf
new file mode 100644
index 000000000..bd7865e7e
Binary files /dev/null and b/test/reference/encrypted_withImage.pdf differ
diff --git a/test/reference/open.pdf b/test/reference/open.pdf
index c24102501..f5348a299 100644
Binary files a/test/reference/open.pdf and b/test/reference/open.pdf differ
diff --git a/test/specs/acroform.spec.js b/test/specs/acroform.spec.js
index 9a4a9902a..42e411b07 100644
--- a/test/specs/acroform.spec.js
+++ b/test/specs/acroform.spec.js
@@ -1,5 +1,6 @@
 /* eslint-disable no-self-assign */
 /* global describe, it, expect, jsPDF, comparePdf, Button, ComboBox, ChoiceField, EditBox, ListBox, PushButton, CheckBox, TextField, PasswordField, RadioButton, AcroForm */
+
 /**
  * Acroform testing
  */
@@ -125,7 +126,7 @@ describe("Module: Acroform Unit Test", function() {
     var doc = new jsPDF("p", "pt", "a4");
     var textFieldRect = new TextField();
     textFieldRect.Rect = [50, 140, 30, 10];
-    doc.addField(textFieldRect);
+    // doc.addField(textFieldRect);
 
     expect(textFieldRect.x).toEqual(50);
     expect(textFieldRect.y).toEqual(140);
@@ -151,6 +152,7 @@ describe("Module: Acroform Unit Test", function() {
 
   it("AcroFormField value", function() {
     var formObject = new TextField();
+
     formObject.value = "test1";
     expect(formObject.value).toEqual("test1");
     expect(formObject.V).toEqual("(test1)");
@@ -212,6 +214,7 @@ describe("Module: Acroform Unit Test", function() {
 
   it("AcroFormField defaultValue", function() {
     var formObject = new TextField();
+    
     formObject.defaultValue = "test1";
     expect(formObject.defaultValue).toEqual("test1");
     expect(formObject.DV).toEqual("(test1)");
@@ -308,6 +311,7 @@ describe("Module: Acroform Unit Test", function() {
 
   it("AcroFormChoiceField getOptions, setOptions, addOption, removeOption", function() {
     var listbox = new ListBox();
+
     listbox.Opt = "[(c)(a)(d)(f)(b)(s)]"; // classic initialization
 
     expect(listbox.getOptions()).toEqual(["c", "a", "d", "f", "b", "s"]);
@@ -321,6 +325,7 @@ describe("Module: Acroform Unit Test", function() {
 
   it("AcroFormChoiceField sort", function() {
     var listbox = new ListBox();
+
     listbox.Opt = "[(c)(a)(d)(f)(b)(g)]"; // classic initialization
 
     listbox.sort = true;
@@ -442,7 +447,7 @@ describe("Module: Acroform Unit Test", function() {
     field = new TextField();
     expect(field.Ff).toEqual(0);
 
-    field = new TextField();
+    field = new TextField();    
     expect(field.Ff).toEqual(0);
     expect(field.readOnly).toEqual(false);
     field.readOnly = true;
@@ -643,16 +648,19 @@ describe("Module: Acroform Unit Test", function() {
   });
 
   it("AcroFormCheckBox", function() {
-    expect(new CheckBox().FT).toEqual("/Btn");
-    expect(new CheckBox().fontName).toEqual("zapfdingbats");
-    expect(new CheckBox().caption).toEqual("3");
-    expect(new CheckBox().appearanceState).toEqual("On");
-    expect(new CheckBox().value).toEqual("On");
-    expect(new CheckBox().textAlign).toEqual("center");
+    var field = new CheckBox();
+
+    expect(field.FT).toEqual("/Btn");
+    expect(field.fontName).toEqual("zapfdingbats");
+    expect(field.caption).toEqual("3");
+    expect(field.appearanceState).toEqual("On");
+    expect(field.value).toEqual("On");
+    expect(field.textAlign).toEqual("center");
   });
 
   it("AcroFormField fontName, fontStyle", function() {
     var field = new TextField();
+
     expect(field.fontName).toEqual("helvetica");
     field.fontName = "courier";
     expect(field.fontName).toEqual("courier");
@@ -664,6 +672,7 @@ describe("Module: Acroform Unit Test", function() {
 
   it("AcroFormField textAlign", function() {
     var field = new TextField();
+
     expect(field.Q).toEqual(undefined);
 
     field.textAlign = "left";
@@ -747,6 +756,7 @@ describe("Module: Acroform Unit Test", function() {
 
   it("AcroFormPasswordField", function() {
     var field = new PasswordField();
+
     expect(field.Ff).toEqual(Math.pow(2, 13));
     expect(field.password).toEqual(true);
     field.password = false;
diff --git a/test/specs/encryption.spec.js b/test/specs/encryption.spec.js
new file mode 100644
index 000000000..859e7653a
--- /dev/null
+++ b/test/specs/encryption.spec.js
@@ -0,0 +1,155 @@
+/* global describe, it, expect, jsPDF, comparePdf */
+/**
+ * Standard spec tests
+ *
+ * These tests return the datauristring so that reference files can be generated.
+ * We compare the exact output.
+ */
+
+describe("Core: Standard Encryption", () => {
+  beforeAll(loadGlobals);
+  it("should allow text insertion", () => {
+    const doc = jsPDF({ 
+      floatPrecision: 2,
+      encryption: {
+        userPassword: "password"
+      }
+    });
+    doc.__private__.setFileId("0000000000000000000000000BADFACE");
+    doc.text(10, 10, "This is a test!");
+    comparePdf(doc.output(), "encrypted_standard.pdf", "encryption");
+    doc.internal.encryption = null;
+    doc.internal.encryptionOptions = null;
+  });
+  it("should be printable", () => {
+    const doc = jsPDF({ 
+      floatPrecision: 2,
+      encryption: {
+        userPassword: "password",
+        userPermissions: ["print"]
+      }
+    });
+    doc.__private__.setFileId("0000000000000000000000000BADFACE");
+    doc.text(10, 10, "This is a test!");
+    comparePdf(doc.output(), "encrypted_printable.pdf", "encryption");
+    doc.internal.encryption = null;
+    doc.internal.encryptionOptions = null;
+  });
+  it("should display forms properly", () => {
+    var doc = new jsPDF({
+      floatPrecision: 2,
+      encryption: {}
+    });
+    doc.__private__.setFileId("0000000000000000000000000BADFACE");
+    var {
+      ComboBox,
+      ListBox,
+      CheckBox,
+      PushButton,
+      TextField,
+      PasswordField,
+      RadioButton,
+      Appearance,
+    } = jsPDF.AcroForm;
+
+    doc.setFontSize(12);
+    doc.text("ComboBox:", 10, 105);
+
+    var comboBox = new ComboBox();
+    comboBox.fieldName = "ChoiceField1";
+    comboBox.topIndex = 1;
+    comboBox.Rect = [50, 100, 30, 10];
+    comboBox.setOptions(["a", "b", "c"]);
+    comboBox.value = "b";
+    comboBox.defaultValue = "b";
+    doc.addField(comboBox);
+
+    doc.text("ListBox:", 10, 115);
+    var listbox = new ListBox();
+    listbox.edit = false;
+    listbox.fieldName = "ChoiceField2";
+    listbox.topIndex = 2;
+    listbox.Rect = [50, 110, 30, 10];
+    listbox.setOptions(["c", "a", "d", "f", "b", "s"]);
+    listbox.value = "s";
+    doc.addField(listbox);
+
+    doc.text("CheckBox:", 10, 125);
+    var checkBox = new CheckBox();
+    checkBox.fieldName = "CheckBox1";
+    checkBox.Rect = [50, 120, 30, 10];
+    doc.addField(checkBox);
+
+    doc.text("PushButton:", 10, 135);
+    var pushButton = new PushButton();
+    pushButton.fieldName = "PushButton1";
+    pushButton.Rect = [50, 130, 30, 10];
+    doc.addField(pushButton);
+
+    doc.text("TextField:", 10, 145);
+    var textField = new TextField();
+    textField.Rect = [50, 140, 30, 10];
+    textField.multiline = true;
+    textField.value =
+      "The quick brown fox ate the lazy mouse The quick brown fox ate the lazy mouse The quick brown fox ate the lazy mouse"; //
+    textField.fieldName = "TestTextBox";
+    doc.addField(textField);
+
+    doc.text("Password:", 10, 155);
+    var passwordField = new PasswordField();
+    passwordField.Rect = [50, 150, 30, 10];
+    doc.addField(passwordField);
+
+    doc.text("RadioGroup:", 50, 165);
+    var radioGroup = new RadioButton();
+    radioGroup.value = "Test";
+    doc.addField(radioGroup);
+    var radioButton1 = radioGroup.createOption("Test");
+    radioButton1.Rect = [50, 170, 30, 10];
+    radioButton1.AS = "/Test";
+    var radioButton2 = radioGroup.createOption("Test2");
+    radioButton2.Rect = [50, 180, 30, 10];
+    var radioButton3 = radioGroup.createOption("Test3");
+    radioButton3.Rect = [50, 190, 20, 10];
+    radioGroup.setAppearance(Appearance.RadioButton.Cross);
+    
+    comparePdf(
+      doc.output(),
+      "encrypted_withAcroForm.pdf",
+      "encryption"
+    );
+
+  })
+  it("colortype_3_indexed_single_colour_alpha_4_bit_png", () => {
+    var colortype_3_indexed_single_colour_alpha_4_bit_png =
+      "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQBAMAAADt3eJSAAAAG1BMVEX/////AAD/pQD//wAA/wAAgAAAgIAAAP+BAIC08EFzAAAAAXRSTlMAQObYZgAAAJtJREFUCB0BkABv/wAREQAAAAAAAAAiIhEQAAAAAAAzMyIhEAAAAABERDMyIQAAAABVVUQzIhAAAABmZlVEMyEAAAB3d2ZVQzIQAACIh3dlVDIhAAAACId2VUMhAAAAAAiHZUMyEAAAAACHdlQyEAAAAAAIdlQyEAAAAAAId2VDIQAAAAAAh2VDIQAAAAAAh2VDIQAAAAAAh2VDIWfgFTHZzlYNAAAAAElFTkSuQmCC";
+    var doc = new jsPDF({
+      orientation: "p",
+      unit: "pt",
+      format: "a4",
+      filters: ["ASCIIHexEncode"],
+      floatPrecision: 2,
+      encryption: {
+        userPassword: "password"
+      }
+    });
+    doc.__private__.setFileId("0000000000000000000000000BADFACE");
+    doc.addImage(
+      colortype_3_indexed_single_colour_alpha_4_bit_png,
+      "PNG",
+      100,
+      200,
+      280,
+      210,
+      undefined,
+      undefined
+    );
+    comparePdf(
+      doc.output(),
+      "encrypted_withImage.pdf",
+      "encryption"
+    );
+    doc.internal.encryption = null;
+    doc.internal.encryptionOptions = null;
+  });
+});
diff --git a/test/utils/compare.js b/test/utils/compare.js
index 7c2393d6e..08de852b4 100644
--- a/test/utils/compare.js
+++ b/test/utils/compare.js
@@ -72,7 +72,7 @@ if (globalVar.isNode === true) {
 
 function resetFile(pdfFile) {
   pdfFile = pdfFile.replace(
-    /\/CreationDate \(D:(.*?)\)/,
+    /\/CreationDate \([^)]+\)/,
     "/CreationDate (D:19871210000000+00'00')"
   );
   pdfFile = pdfFile.replace(
@@ -80,7 +80,7 @@ function resetFile(pdfFile) {
     "/ID [ <00000000000000000000000000000000> <00000000000000000000000000000000> ]"
   );
   pdfFile = pdfFile.replace(
-    /(\/Producer \(jsPDF [^)]+\))/,
+    /\/Producer \([^)]+\)/,
     "/Producer (jsPDF 0.0.0)"
   );
   return pdfFile;
diff --git a/types/index.d.ts b/types/index.d.ts
index 3c7328d1a..69f5525ea 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -538,6 +538,12 @@ declare module "jspdf" {
     width: number;
   }
 
+  export interface EncryptionOptions {
+    userPassword?: string;
+    ownerPassword?: string;
+    userPermissions?: ("print" | "modify" | "copy" | "annot-forms")[];
+  }
+
   export interface jsPDFOptions {
     orientation?: "p" | "portrait" | "l" | "landscape";
     unit?: "pt" | "px" | "in" | "mm" | "cm" | "ex" | "em" | "pc";
@@ -546,6 +552,7 @@ declare module "jspdf" {
     precision?: number;
     filters?: string[];
     userUnit?: number;
+    encryption?: EncryptionOptions;
   }
 
   export interface Point {
@@ -804,6 +811,7 @@ declare module "jspdf" {
         getHeight: () => number;
       };
       pages: number[];
+      getEncryptor(objectId: number): (data: string) => string;
     };
 
     /**
diff --git a/types/jspdf-tests-node.ts b/types/jspdf-tests-node.ts
index f9410ee86..bc15b7a87 100644
--- a/types/jspdf-tests-node.ts
+++ b/types/jspdf-tests-node.ts
@@ -597,3 +597,33 @@ function test_loadFile() {
     return data;
   });
 }
+
+function test_simpleTwoPageDocumentWithEncryption() {
+  const doc = new jsPDF({
+    encryption: {
+      userPassword: "longpassword",
+      userPermissions: ["print", "copy"]
+    }
+  });
+  doc.text("Hello world!", 20, 20);
+  doc.text("This is client-side Javascript, pumping out a PDF.", 20, 20);
+  doc.addPage();
+  doc.text("Do you like that?", 20, 20);
+  doc.save("Test.pdf");
+}
+
+function test_addImageWithEncryption() {
+  const doc = new jsPDF({
+    encryption: {
+      userPassword: "password",
+      ownerPassword: "password"
+    }
+  });
+  doc.addImage({
+    imageData: "/image.png",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100
+  });
+}
diff --git a/types/jspdf-tests.ts b/types/jspdf-tests.ts
index f74bea3eb..64cba864a 100644
--- a/types/jspdf-tests.ts
+++ b/types/jspdf-tests.ts
@@ -596,3 +596,33 @@ function test_loadFile() {
     return data;
   });
 }
+
+function test_simpleTwoPageDocumentWithEncryption() {
+  const doc = new jsPDF({
+    encryption: {
+      userPassword: "longpassword",
+      userPermissions: ["print", "copy"]
+    }
+  });
+  doc.text("Hello world!", 20, 20);
+  doc.text("This is client-side Javascript, pumping out a PDF.", 20, 20);
+  doc.addPage();
+  doc.text("Do you like that?", 20, 20);
+  doc.save("Test.pdf");
+}
+
+function test_addImageWithEncryption() {
+  const doc = new jsPDF({
+    encryption: {
+      userPassword: "password",
+      ownerPassword: "password"
+    }
+  });
+  doc.addImage({
+    imageData: "/image.png",
+    x: 0,
+    y: 0,
+    width: 100,
+    height: 100
+  });
+}