pdfkit 0.12.3 → 0.14.0

package/js/pdfkit.esnext.js

@@ -405,6 +405,11 @@ class PDFPage {
     return data.Pattern != null ? data.Pattern : data.Pattern = {};
   }
 
+  get colorSpaces() {
+    var data = this.resources.data;
+    return data.ColorSpace || (data.ColorSpace = {});
+  }
+
   get annotations() {
     var data = this.dictionary.data;
     return data.Annots != null ? data.Annots : data.Annots = [];
@@ -1478,7 +1483,7 @@ class PDFGradient {
     return pattern;
   }
 
-  apply(op) {
+  apply(stroke) {
     // apply gradient transform to existing document ctm
     var [m0, m1, m2, m3, m4, m5] = this.doc._ctm;
     var [m11, m12, m21, m22, dx, dy] = this.transform;
@@ -1488,6 +1493,9 @@ class PDFGradient {
       this.embed(m);
     }
 
+    this.doc._setColorSpace('Pattern', stroke);
+
+    var op = stroke ? 'SCN' : 'scn';
     return this.doc.addContent("/".concat(this.id, " ").concat(op));
   }
 
@@ -1552,24 +1560,119 @@ var Gradient = {
   PDFRadialGradient
 };
 
+/*
+PDF tiling pattern support. Uncolored only.
+ */
+var underlyingColorSpaces = ['DeviceCMYK', 'DeviceRGB'];
+
+class PDFTilingPattern {
+  constructor(doc, bBox, xStep, yStep, stream) {
+    this.doc = doc;
+    this.bBox = bBox;
+    this.xStep = xStep;
+    this.yStep = yStep;
+    this.stream = stream;
+  }
+
+  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 [m0, m1, m2, m3, m4, m5] = this.doc._ctm;
+    var [m11, m12, m21, m22, dx, dy] = [1, 0, 0, 1, 0, 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(v => +v.toFixed(5)),
+      Resources: resources
+    });
+    pattern.end(this.stream);
+    return pattern;
+  }
+
+  embedPatternColorSpaces() {
+    // map each pattern to an underlying color space
+    // and embed on each page
+    underlyingColorSpaces.forEach(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;
+    });
+  }
+
+  getPatternColorSpaceId(underlyingColorspace) {
+    return "CsP".concat(underlyingColorspace);
+  }
+
+  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;
+    }
+  }
+
+  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));
+  }
+
+}
+
+var pattern = {
+  PDFTilingPattern
+};
+
 var {
   PDFGradient: PDFGradient$1,
   PDFLinearGradient: PDFLinearGradient$1,
   PDFRadialGradient: PDFRadialGradient$1
 } = Gradient;
+var {
+  PDFTilingPattern: PDFTilingPattern$1
+} = pattern;
 var ColorMixin = {
   initColor() {
     // The opacity dictionaries
     this._opacityRegistry = {};
     this._opacityCount = 0;
+    this._patternCount = 0;
     return this._gradCount = 0;
   },
 
   _normalizeColor(color) {
-    if (color instanceof PDFGradient$1) {
-      return color;
-    }
-
     if (typeof color === 'string') {
       if (color.charAt(0) === '#') {
         if (color.length === 4) {
@@ -1598,6 +1701,19 @@ var ColorMixin = {
   },
 
   _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(color, stroke) {
     color = this._normalizeColor(color);
 
     if (!color) {
@@ -1606,19 +1722,12 @@ var ColorMixin = {
 
     var op = stroke ? 'SCN' : 'scn';
 
-    if (color instanceof PDFGradient$1) {
-      this._setColorSpace('Pattern', stroke);
+    var space = this._getColorSpace(color);
 
-      color.apply(op);
-    } else {
-      var space = color.length === 4 ? 'DeviceCMYK' : 'DeviceRGB';
-
-      this._setColorSpace(space, stroke);
-
-      color = color.join(' ');
-      this.addContent("".concat(color, " ").concat(op));
-    }
+    this._setColorSpace(space, stroke);
 
+    color = color.join(' ');
+    this.addContent("".concat(color, " ").concat(op));
     return true;
   },
 
@@ -1627,6 +1736,10 @@ var ColorMixin = {
     return this.addContent("/".concat(space, " ").concat(op));
   },
 
+  _getColorSpace(color) {
+    return color.length === 4 ? 'DeviceCMYK' : 'DeviceRGB';
+  },
+
   fillColor(color, opacity) {
     var set = this._setColor(color, false);
 
@@ -1717,6 +1830,10 @@ var ColorMixin = {
 
   radialGradient(x1, y1, r1, x2, y2, r2) {
     return new PDFRadialGradient$1(this, x1, y1, r1, x2, y2, r2);
+  },
+
+  pattern(bbox, xStep, yStep, stream) {
+    return new PDFTilingPattern$1(this, bbox, xStep, yStep, stream);
   }
 
 };
@@ -3124,6 +3241,14 @@ class EmbeddedFont extends 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',
@@ -5927,6 +6052,176 @@ 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(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() {
+    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(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() {
+    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() {
+    this.appendXML(this._getPdfaid());
+  }
+
+};
+
+var SubsetMixin = {
+  _importSubset(subset) {
+    Object.assign(this, subset);
+  },
+
+  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;
+    }
+  }
+
+};
+
+class PDFMetadata {
+  constructor() {
+    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        ";
+  }
+
+  _closeTags() {
+    this._metadata = this._metadata.concat("\n                </rdf:RDF>\n            </x:xmpmeta>\n        <?xpacket end=\"w\"?>\n        ");
+  }
+
+  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');
+  }
+
+  getXML() {
+    return this._metadata;
+  }
+
+  getLength() {
+    return this._metadata.length;
+  }
+
+  end() {
+    this._closeTags();
+
+    this._metadata = this._metadata.trim();
+  }
+
+}
+
+var MetadataMixin = {
+  initMetadata() {
+    this.metadata = new PDFMetadata();
+  },
+
+  appendXML(xml) {
+    var newline = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    this.metadata.append(xml, newline);
+  },
+
+  _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() {
+    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;
+    }
+  }
+
+};
+
 /*
 PDFDocument - represents an entire PDF document
 By Devon Govett
@@ -5991,13 +6286,15 @@ class PDFDocument extends stream.Readable {
 
     this.page = null; // Initialize mixins
 
+    this.initMetadata();
     this.initColor();
     this.initVector();
     this.initFonts(options.font);
     this.initText();
     this.initImages();
     this.initOutline();
-    this.initMarkings(options); // Initialize the metadata
+    this.initMarkings(options);
+    this.initSubset(options); // Initialize the metadata
 
     this.info = {
       Producer: 'PDFKit',
@@ -6219,6 +6516,12 @@ class PDFDocument extends stream.Readable {
     this.endOutline();
     this.endMarkings();
 
+    if (this.subset) {
+      this.endSubset();
+    }
+
+    this.endMetadata();
+
     this._root.end();
 
     this._root.data.Pages.end();
@@ -6294,6 +6597,7 @@ var mixin = methods => {
   Object.assign(PDFDocument.prototype, methods);
 };
 
+mixin(MetadataMixin);
 mixin(ColorMixin);
 mixin(VectorMixin);
 mixin(FontsMixin);
@@ -6304,6 +6608,7 @@ mixin(OutlineMixin);
 mixin(MarkingsMixin);
 mixin(AcroFormMixin);
 mixin(AttachmentsMixin);
+mixin(SubsetMixin);
 PDFDocument.LineWrapper = LineWrapper;
 
 export default PDFDocument;