pdfkit 0.12.3 → 0.14.0

package/CHANGELOG.md

@@ -1,6 +1,17 @@
 ## pdfkit changelog
 
-### Unreleased
+### [v0.14.0] - 2023-11-09
+
+- Add support for PDF/A-1b, PDF/A-1a, PDF/A-2b, PDF/A-2a, PDF/A-3b, PDF/A-3a
+- Update crypto-js to v4.2.0 (properly fix security issue)
+
+### [v0.13.0] - 2021-10-24
+
+- Add tiling pattern support
+
+### [v0.12.3] - 2021-08-01
+
+- Remove examples from published package
 
 ### [v0.12.2] - 2021-08-01
 

package/README.md

@@ -154,7 +154,7 @@ const stream = doc.pipe(blobStream());
 
 // add your content to the document here, as usual
 
-// get a blob when you're done
+// get a blob when you are done
 doc.end();
 stream.on('finish', function() {
   // get a blob you can do whatever you like with

package/js/pdfkit.es5.js

@@ -762,6 +762,12 @@ var PDFPage = /*#__PURE__*/function () {
       var data = this.resources.data;
       return data.Pattern != null ? data.Pattern : data.Pattern = {};
     }
+  }, {
+    key: "colorSpaces",
+    get: function get() {
+      var data = this.resources.data;
+      return data.ColorSpace || (data.ColorSpace = {});
+    }
   }, {
     key: "annotations",
     get: function get() {
@@ -1891,7 +1897,7 @@ var PDFGradient = /*#__PURE__*/function () {
     }
   }, {
     key: "apply",
-    value: function apply(op) {
+    value: function apply(stroke) {
       // apply gradient transform to existing document ctm
       var _this$doc$_ctm = _slicedToArray(this.doc._ctm, 6),
           m0 = _this$doc$_ctm[0],
@@ -1915,6 +1921,9 @@ var PDFGradient = /*#__PURE__*/function () {
         this.embed(m);
       }
 
+      this.doc._setColorSpace('Pattern', stroke);
+
+      var op = stroke ? 'SCN' : 'scn';
       return this.doc.addContent("/".concat(this.id, " ").concat(op));
     }
   }]);
@@ -2009,21 +2018,143 @@ var Gradient = {
   PDFRadialGradient: PDFRadialGradient
 };
 
+/*
+PDF tiling pattern support. Uncolored only.
+ */
+var underlyingColorSpaces = ['DeviceCMYK', 'DeviceRGB'];
+
+var PDFTilingPattern = /*#__PURE__*/function () {
+  function PDFTilingPattern(doc, bBox, xStep, yStep, stream) {
+    _classCallCheck(this, PDFTilingPattern);
+
+    this.doc = doc;
+    this.bBox = bBox;
+    this.xStep = xStep;
+    this.yStep = yStep;
+    this.stream = stream;
+  }
+
+  _createClass(PDFTilingPattern, [{
+    key: "createPattern",
+    value: function createPattern() {
+      // no resources needed for our current usage
+      // required entry
+      var resources = this.doc.ref();
+      resources.end(); // apply default transform matrix (flipped in the default doc._ctm)
+      // see document.js & gradient.js
+
+      var _this$doc$_ctm = _slicedToArray(this.doc._ctm, 6),
+          m0 = _this$doc$_ctm[0],
+          m1 = _this$doc$_ctm[1],
+          m2 = _this$doc$_ctm[2],
+          m3 = _this$doc$_ctm[3],
+          m4 = _this$doc$_ctm[4],
+          m5 = _this$doc$_ctm[5];
+
+      var m11 = 1,
+          m12 = 0,
+          m21 = 0,
+          m22 = 1,
+          dx = 0,
+          dy = 0;
+      var m = [m0 * m11 + m2 * m12, m1 * m11 + m3 * m12, m0 * m21 + m2 * m22, m1 * m21 + m3 * m22, m0 * dx + m2 * dy + m4, m1 * dx + m3 * dy + m5];
+      var pattern = this.doc.ref({
+        Type: 'Pattern',
+        PatternType: 1,
+        // tiling
+        PaintType: 2,
+        // 1-colored, 2-uncolored
+        TilingType: 2,
+        // 2-no distortion
+        BBox: this.bBox,
+        XStep: this.xStep,
+        YStep: this.yStep,
+        Matrix: m.map(function (v) {
+          return +v.toFixed(5);
+        }),
+        Resources: resources
+      });
+      pattern.end(this.stream);
+      return pattern;
+    }
+  }, {
+    key: "embedPatternColorSpaces",
+    value: function embedPatternColorSpaces() {
+      var _this = this;
+
+      // map each pattern to an underlying color space
+      // and embed on each page
+      underlyingColorSpaces.forEach(function (csName) {
+        var csId = _this.getPatternColorSpaceId(csName);
+
+        if (_this.doc.page.colorSpaces[csId]) return;
+
+        var cs = _this.doc.ref(['Pattern', csName]);
+
+        cs.end();
+        _this.doc.page.colorSpaces[csId] = cs;
+      });
+    }
+  }, {
+    key: "getPatternColorSpaceId",
+    value: function getPatternColorSpaceId(underlyingColorspace) {
+      return "CsP".concat(underlyingColorspace);
+    }
+  }, {
+    key: "embed",
+    value: function embed() {
+      if (!this.id) {
+        this.doc._patternCount = this.doc._patternCount + 1;
+        this.id = 'P' + this.doc._patternCount;
+        this.pattern = this.createPattern();
+      } // patterns are embedded in each page
+
+
+      if (!this.doc.page.patterns[this.id]) {
+        this.doc.page.patterns[this.id] = this.pattern;
+      }
+    }
+  }, {
+    key: "apply",
+    value: function apply(stroke, patternColor) {
+      // do any embedding/creating that might be needed
+      this.embedPatternColorSpaces();
+      this.embed();
+
+      var normalizedColor = this.doc._normalizeColor(patternColor);
+
+      if (!normalizedColor) throw Error("invalid pattern color. (value: ".concat(patternColor, ")")); // select one of the pattern color spaces
+
+      var csId = this.getPatternColorSpaceId(this.doc._getColorSpace(normalizedColor));
+
+      this.doc._setColorSpace(csId, stroke); // stroke/fill using the pattern and color (in the above underlying color space)
+
+
+      var op = stroke ? 'SCN' : 'scn';
+      return this.doc.addContent("".concat(normalizedColor.join(' '), " /").concat(this.id, " ").concat(op));
+    }
+  }]);
+
+  return PDFTilingPattern;
+}();
+
+var pattern = {
+  PDFTilingPattern: PDFTilingPattern
+};
+
 var PDFGradient$1 = Gradient.PDFGradient,
     PDFLinearGradient$1 = Gradient.PDFLinearGradient,
     PDFRadialGradient$1 = Gradient.PDFRadialGradient;
+var PDFTilingPattern$1 = pattern.PDFTilingPattern;
 var ColorMixin = {
   initColor: function initColor() {
     // The opacity dictionaries
     this._opacityRegistry = {};
     this._opacityCount = 0;
+    this._patternCount = 0;
     return this._gradCount = 0;
   },
   _normalizeColor: function _normalizeColor(color) {
-    if (color instanceof PDFGradient$1) {
-      return color;
-    }
-
     if (typeof color === 'string') {
       if (color.charAt(0) === '#') {
         if (color.length === 4) {
@@ -2055,6 +2186,18 @@ var ColorMixin = {
     return null;
   },
   _setColor: function _setColor(color, stroke) {
+    if (color instanceof PDFGradient$1) {
+      color.apply(stroke);
+      return true; // see if tiling pattern, decode & apply it it
+    } else if (Array.isArray(color) && color[0] instanceof PDFTilingPattern$1) {
+      color[0].apply(stroke, color[1]);
+      return true;
+    } // any other case should be a normal color and not a pattern
+
+
+    return this._setColorCore(color, stroke);
+  },
+  _setColorCore: function _setColorCore(color, stroke) {
     color = this._normalizeColor(color);
 
     if (!color) {
@@ -2063,25 +2206,21 @@ var ColorMixin = {
 
     var op = stroke ? 'SCN' : 'scn';
 
-    if (color instanceof PDFGradient$1) {
-      this._setColorSpace('Pattern', stroke);
-
-      color.apply(op);
-    } else {
-      var space = color.length === 4 ? 'DeviceCMYK' : 'DeviceRGB';
-
-      this._setColorSpace(space, stroke);
+    var space = this._getColorSpace(color);
 
-      color = color.join(' ');
-      this.addContent("".concat(color, " ").concat(op));
-    }
+    this._setColorSpace(space, stroke);
 
+    color = color.join(' ');
+    this.addContent("".concat(color, " ").concat(op));
     return true;
   },
   _setColorSpace: function _setColorSpace(space, stroke) {
     var op = stroke ? 'CS' : 'cs';
     return this.addContent("/".concat(space, " ").concat(op));
   },
+  _getColorSpace: function _getColorSpace(color) {
+    return color.length === 4 ? 'DeviceCMYK' : 'DeviceRGB';
+  },
   fillColor: function fillColor(color, opacity) {
     var set = this._setColor(color, false);
 
@@ -2168,6 +2307,9 @@ var ColorMixin = {
   },
   radialGradient: function radialGradient(x1, y1, r1, x2, y2, r2) {
     return new PDFRadialGradient$1(this, x1, y1, r1, x2, y2, r2);
+  },
+  pattern: function pattern(bbox, xStep, yStep, stream) {
+    return new PDFTilingPattern$1(this, bbox, xStep, yStep, stream);
   }
 };
 var namedColors = {
@@ -3649,6 +3791,14 @@ var EmbeddedFont = /*#__PURE__*/function (_PDFFont) {
         descriptor.data.FontFile2 = fontFile;
       }
 
+      if (this.document.subset) {
+        var CIDSet = Buffer.from('FFFFFFFFC0', 'hex');
+        var CIDSetRef = this.document.ref();
+        CIDSetRef.write(CIDSet);
+        CIDSetRef.end();
+        descriptor.data.CIDSet = CIDSetRef;
+      }
+
       descriptor.end();
       var descendantFontData = {
         Type: 'Font',
@@ -6552,6 +6702,175 @@ function isEqual(a, b) {
   return a.Subtype === b.Subtype && a.Params.CheckSum.toString() === b.Params.CheckSum.toString() && a.Params.Size === b.Params.Size && a.Params.CreationDate === b.Params.CreationDate && a.Params.ModDate === b.Params.ModDate;
 }
 
+var PDFA = {
+  initPDFA: function initPDFA(pSubset) {
+    if (pSubset.charAt(pSubset.length - 3) === '-') {
+      this.subset_conformance = pSubset.charAt(pSubset.length - 1).toUpperCase();
+      this.subset = parseInt(pSubset.charAt(pSubset.length - 2));
+    } else {
+      // Default to Basic conformance when user doesn't specify
+      this.subset_conformance = 'B';
+      this.subset = parseInt(pSubset.charAt(pSubset.length - 1));
+    }
+  },
+  endSubset: function endSubset() {
+    this._addPdfaMetadata();
+
+    var jsPath = "".concat(__dirname, "/data/sRGB_IEC61966_2_1.icc");
+    var jestPath = "".concat(__dirname, "/../color_profiles/sRGB_IEC61966_2_1.icc");
+
+    this._addColorOutputIntent(fs.existsSync(jsPath) ? jsPath : jestPath);
+  },
+  _addColorOutputIntent: function _addColorOutputIntent(pICCPath) {
+    var iccProfile = fs.readFileSync(pICCPath);
+    var colorProfileRef = this.ref({
+      Length: iccProfile.length,
+      N: 3
+    });
+    colorProfileRef.write(iccProfile);
+    colorProfileRef.end();
+    var intentRef = this.ref({
+      Type: 'OutputIntent',
+      S: 'GTS_PDFA1',
+      Info: new String('sRGB IEC61966-2.1'),
+      OutputConditionIdentifier: new String('sRGB IEC61966-2.1'),
+      DestOutputProfile: colorProfileRef
+    });
+    intentRef.end();
+    this._root.data.OutputIntents = [intentRef];
+  },
+  _getPdfaid: function _getPdfaid() {
+    return "\n        <rdf:Description xmlns:pdfaid=\"http://www.aiim.org/pdfa/ns/id/\" rdf:about=\"\">\n            <pdfaid:part>".concat(this.subset, "</pdfaid:part>\n            <pdfaid:conformance>").concat(this.subset_conformance, "</pdfaid:conformance>\n        </rdf:Description>\n        ");
+  },
+  _addPdfaMetadata: function _addPdfaMetadata() {
+    this.appendXML(this._getPdfaid());
+  }
+};
+
+var SubsetMixin = {
+  _importSubset: function _importSubset(subset) {
+    Object.assign(this, subset);
+  },
+  initSubset: function initSubset(options) {
+    switch (options.subset) {
+      case 'PDF/A-1':
+      case 'PDF/A-1a':
+      case 'PDF/A-1b':
+      case 'PDF/A-2':
+      case 'PDF/A-2a':
+      case 'PDF/A-2b':
+      case 'PDF/A-3':
+      case 'PDF/A-3a':
+      case 'PDF/A-3b':
+        this._importSubset(PDFA);
+
+        this.initPDFA(options.subset);
+        break;
+    }
+  }
+};
+
+var PDFMetadata = /*#__PURE__*/function () {
+  function PDFMetadata() {
+    _classCallCheck(this, PDFMetadata);
+
+    this._metadata = "\n        <?xpacket begin=\"\uFEFF\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>\n            <x:xmpmeta xmlns:x=\"adobe:ns:meta/\">\n                <rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n        ";
+  }
+
+  _createClass(PDFMetadata, [{
+    key: "_closeTags",
+    value: function _closeTags() {
+      this._metadata = this._metadata.concat("\n                </rdf:RDF>\n            </x:xmpmeta>\n        <?xpacket end=\"w\"?>\n        ");
+    }
+  }, {
+    key: "append",
+    value: function append(xml) {
+      var newline = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      this._metadata = this._metadata.concat(xml);
+      if (newline) this._metadata = this._metadata.concat('\n');
+    }
+  }, {
+    key: "getXML",
+    value: function getXML() {
+      return this._metadata;
+    }
+  }, {
+    key: "getLength",
+    value: function getLength() {
+      return this._metadata.length;
+    }
+  }, {
+    key: "end",
+    value: function end() {
+      this._closeTags();
+
+      this._metadata = this._metadata.trim();
+    }
+  }]);
+
+  return PDFMetadata;
+}();
+
+var MetadataMixin = {
+  initMetadata: function initMetadata() {
+    this.metadata = new PDFMetadata();
+  },
+  appendXML: function appendXML(xml) {
+    var newline = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    this.metadata.append(xml, newline);
+  },
+  _addInfo: function _addInfo() {
+    this.appendXML("\n        <rdf:Description rdf:about=\"\" xmlns:xmp=\"http://ns.adobe.com/xap/1.0/\">\n            <xmp:CreateDate>".concat(this.info.CreationDate.toISOString().split('.')[0] + "Z", "</xmp:CreateDate>\n            <xmp:CreatorTool>").concat(this.info.Creator, "</xmp:CreatorTool>\n        </rdf:Description>\n        "));
+
+    if (this.info.Title || this.info.Author || this.info.Subject) {
+      this.appendXML("\n            <rdf:Description rdf:about=\"\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">\n            ");
+
+      if (this.info.Title) {
+        this.appendXML("\n                <dc:title>\n                    <rdf:Alt>\n                        <rdf:li xml:lang=\"x-default\">".concat(this.info.Title, "</rdf:li>\n                    </rdf:Alt>\n                </dc:title>\n                "));
+      }
+
+      if (this.info.Author) {
+        this.appendXML("\n                <dc:creator>\n                    <rdf:Seq>\n                        <rdf:li>".concat(this.info.Author, "</rdf:li>\n                    </rdf:Seq>\n                </dc:creator>\n                "));
+      }
+
+      if (this.info.Subject) {
+        this.appendXML("\n                <dc:description>\n                    <rdf:Alt>\n                        <rdf:li xml:lang=\"x-default\">".concat(this.info.Subject, "</rdf:li>\n                    </rdf:Alt>\n                </dc:description>\n                "));
+      }
+
+      this.appendXML("\n            </rdf:Description>\n            ");
+    }
+
+    this.appendXML("\n        <rdf:Description rdf:about=\"\" xmlns:pdf=\"http://ns.adobe.com/pdf/1.3/\">\n            <pdf:Producer>".concat(this.info.Creator, "</pdf:Producer>"), false);
+
+    if (this.info.Keywords) {
+      this.appendXML("\n            <pdf:Keywords>".concat(this.info.Keywords, "</pdf:Keywords>"), false);
+    }
+
+    this.appendXML("\n        </rdf:Description>\n        ");
+  },
+  endMetadata: function endMetadata() {
+    this._addInfo();
+
+    this.metadata.end();
+    /*
+    Metadata was introduced in PDF 1.4, so adding it to 1.3 
+    will likely only take up more space.
+    */
+
+    if (this.version != 1.3) {
+      this.metadataRef = this.ref({
+        length: this.metadata.getLength(),
+        Type: 'Metadata',
+        Subtype: 'XML'
+      });
+      this.metadataRef.compress = false;
+      this.metadataRef.write(Buffer.from(this.metadata.getXML(), 'utf-8'));
+      this.metadataRef.end();
+      this._root.data.Metadata = this.metadataRef;
+    }
+  }
+};
+
 var PDFDocument = /*#__PURE__*/function (_stream$Readable) {
   _inherits(PDFDocument, _stream$Readable);
 
@@ -6623,6 +6942,8 @@ var PDFDocument = /*#__PURE__*/function (_stream$Readable) {
 
     _this.page = null; // Initialize mixins
 
+    _this.initMetadata();
+
     _this.initColor();
 
     _this.initVector();
@@ -6635,7 +6956,9 @@ var PDFDocument = /*#__PURE__*/function (_stream$Readable) {
 
     _this.initOutline();
 
-    _this.initMarkings(options); // Initialize the metadata
+    _this.initMarkings(options);
+
+    _this.initSubset(options); // Initialize the metadata
 
 
     _this.info = {
@@ -6884,6 +7207,12 @@ var PDFDocument = /*#__PURE__*/function (_stream$Readable) {
       this.endOutline();
       this.endMarkings();
 
+      if (this.subset) {
+        this.endSubset();
+      }
+
+      this.endMetadata();
+
       this._root.end();
 
       this._root.data.Pages.end();
@@ -6973,6 +7302,7 @@ var mixin = function mixin(methods) {
   Object.assign(PDFDocument.prototype, methods);
 };
 
+mixin(MetadataMixin);
 mixin(ColorMixin);
 mixin(VectorMixin);
 mixin(FontsMixin);
@@ -6983,6 +7313,7 @@ mixin(OutlineMixin);
 mixin(MarkingsMixin);
 mixin(AcroFormMixin);
 mixin(AttachmentsMixin);
+mixin(SubsetMixin);
 PDFDocument.LineWrapper = LineWrapper;
 
 export default PDFDocument;