mol-pdf 1.0.0

package/lib/cafe-pdf/src/pdfjs-dist/lib/test/unit/test_utils.js

@@ -0,0 +1,383 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * Copyright 2019 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildGetDocumentParams = buildGetDocumentParams;
+exports.createIdFactory = createIdFactory;
+exports.TEST_PDFS_PATH = exports.XRefMock = exports.NodeCMapReaderFactory = exports.NodeCanvasFactory = exports.NodeFileReaderFactory = exports.DOMFileReaderFactory = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _util = require("../../shared/util");
+
+var _is_node = _interopRequireDefault(require("../../shared/is_node"));
+
+var _primitives = require("../../core/primitives");
+
+var _document = require("../../core/document");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+var DOMFileReaderFactory =
+/*#__PURE__*/
+function () {
+  function DOMFileReaderFactory() {
+    _classCallCheck(this, DOMFileReaderFactory);
+  }
+
+  _createClass(DOMFileReaderFactory, null, [{
+    key: "fetch",
+    value: function (_fetch) {
+      function fetch(_x) {
+        return _fetch.apply(this, arguments);
+      }
+
+      fetch.toString = function () {
+        return _fetch.toString();
+      };
+
+      return fetch;
+    }(
+    /*#__PURE__*/
+    function () {
+      var _ref = _asyncToGenerator(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee(params) {
+        var response;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return fetch(params.path);
+
+              case 2:
+                response = _context.sent;
+
+                if (response.ok) {
+                  _context.next = 5;
+                  break;
+                }
+
+                throw new Error(response.statusText);
+
+              case 5:
+                _context.t0 = Uint8Array;
+                _context.next = 8;
+                return response.arrayBuffer();
+
+              case 8:
+                _context.t1 = _context.sent;
+                return _context.abrupt("return", new _context.t0(_context.t1));
+
+              case 10:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function (_x2) {
+        return _ref.apply(this, arguments);
+      };
+    }())
+  }]);
+
+  return DOMFileReaderFactory;
+}();
+
+exports.DOMFileReaderFactory = DOMFileReaderFactory;
+
+var NodeFileReaderFactory =
+/*#__PURE__*/
+function () {
+  function NodeFileReaderFactory() {
+    _classCallCheck(this, NodeFileReaderFactory);
+  }
+
+  _createClass(NodeFileReaderFactory, null, [{
+    key: "fetch",
+    value: function () {
+      var _fetch2 = _asyncToGenerator(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee2(params) {
+        var fs;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                fs = require('fs');
+                return _context2.abrupt("return", new Promise(function (resolve, reject) {
+                  fs.readFile(params.path, function (error, data) {
+                    if (error || !data) {
+                      reject(error || new Error("Empty file for: ".concat(params.path)));
+                      return;
+                    }
+
+                    resolve(new Uint8Array(data));
+                  });
+                }));
+
+              case 2:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      function fetch(_x3) {
+        return _fetch2.apply(this, arguments);
+      }
+
+      return fetch;
+    }()
+  }]);
+
+  return NodeFileReaderFactory;
+}();
+
+exports.NodeFileReaderFactory = NodeFileReaderFactory;
+var TEST_PDFS_PATH = {
+  dom: '../pdfs/',
+  node: './test/pdfs/'
+};
+exports.TEST_PDFS_PATH = TEST_PDFS_PATH;
+
+function buildGetDocumentParams(filename, options) {
+  var params = Object.create(null);
+
+  if ((0, _is_node["default"])()) {
+    params.url = TEST_PDFS_PATH.node + filename;
+  } else {
+    params.url = new URL(TEST_PDFS_PATH.dom + filename, window.location).href;
+  }
+
+  for (var option in options) {
+    params[option] = options[option];
+  }
+
+  return params;
+}
+
+var NodeCanvasFactory =
+/*#__PURE__*/
+function () {
+  function NodeCanvasFactory() {
+    _classCallCheck(this, NodeCanvasFactory);
+  }
+
+  _createClass(NodeCanvasFactory, [{
+    key: "create",
+    value: function create(width, height) {
+      (0, _util.assert)(width > 0 && height > 0, 'Invalid canvas size');
+
+      var Canvas = require('canvas');
+
+      var canvas = Canvas.createCanvas(width, height);
+      return {
+        canvas: canvas,
+        context: canvas.getContext('2d')
+      };
+    }
+  }, {
+    key: "reset",
+    value: function reset(canvasAndContext, width, height) {
+      (0, _util.assert)(canvasAndContext.canvas, 'Canvas is not specified');
+      (0, _util.assert)(width > 0 && height > 0, 'Invalid canvas size');
+      canvasAndContext.canvas.width = width;
+      canvasAndContext.canvas.height = height;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy(canvasAndContext) {
+      (0, _util.assert)(canvasAndContext.canvas, 'Canvas is not specified');
+      canvasAndContext.canvas.width = 0;
+      canvasAndContext.canvas.height = 0;
+      canvasAndContext.canvas = null;
+      canvasAndContext.context = null;
+    }
+  }]);
+
+  return NodeCanvasFactory;
+}();
+
+exports.NodeCanvasFactory = NodeCanvasFactory;
+
+var NodeCMapReaderFactory =
+/*#__PURE__*/
+function () {
+  function NodeCMapReaderFactory(_ref2) {
+    var _ref2$baseUrl = _ref2.baseUrl,
+        baseUrl = _ref2$baseUrl === void 0 ? null : _ref2$baseUrl,
+        _ref2$isCompressed = _ref2.isCompressed,
+        isCompressed = _ref2$isCompressed === void 0 ? false : _ref2$isCompressed;
+
+    _classCallCheck(this, NodeCMapReaderFactory);
+
+    this.baseUrl = baseUrl;
+    this.isCompressed = isCompressed;
+  }
+
+  _createClass(NodeCMapReaderFactory, [{
+    key: "fetch",
+    value: function () {
+      var _fetch3 = _asyncToGenerator(
+      /*#__PURE__*/
+      _regenerator["default"].mark(function _callee3(_ref3) {
+        var _this = this;
+
+        var name, url, compressionType;
+        return _regenerator["default"].wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                name = _ref3.name;
+
+                if (this.baseUrl) {
+                  _context3.next = 3;
+                  break;
+                }
+
+                throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.');
+
+              case 3:
+                if (name) {
+                  _context3.next = 5;
+                  break;
+                }
+
+                throw new Error('CMap name must be specified.');
+
+              case 5:
+                url = this.baseUrl + name + (this.isCompressed ? '.bcmap' : '');
+                compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE;
+                return _context3.abrupt("return", new Promise(function (resolve, reject) {
+                  var fs = require('fs');
+
+                  fs.readFile(url, function (error, data) {
+                    if (error || !data) {
+                      reject(new Error(error));
+                      return;
+                    }
+
+                    resolve({
+                      cMapData: new Uint8Array(data),
+                      compressionType: compressionType
+                    });
+                  });
+                })["catch"](function (reason) {
+                  throw new Error("Unable to load ".concat(_this.isCompressed ? 'binary ' : '') + "CMap at: ".concat(url));
+                }));
+
+              case 8:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+
+      function fetch(_x4) {
+        return _fetch3.apply(this, arguments);
+      }
+
+      return fetch;
+    }()
+  }]);
+
+  return NodeCMapReaderFactory;
+}();
+
+exports.NodeCMapReaderFactory = NodeCMapReaderFactory;
+
+var XRefMock =
+/*#__PURE__*/
+function () {
+  function XRefMock(array) {
+    _classCallCheck(this, XRefMock);
+
+    this._map = Object.create(null);
+
+    for (var key in array) {
+      var obj = array[key];
+      this._map[obj.ref.toString()] = obj.data;
+    }
+  }
+
+  _createClass(XRefMock, [{
+    key: "fetch",
+    value: function fetch(ref) {
+      return this._map[ref.toString()];
+    }
+  }, {
+    key: "fetchAsync",
+    value: function fetchAsync(ref) {
+      return Promise.resolve(this.fetch(ref));
+    }
+  }, {
+    key: "fetchIfRef",
+    value: function fetchIfRef(obj) {
+      if (!(0, _primitives.isRef)(obj)) {
+        return obj;
+      }
+
+      return this.fetch(obj);
+    }
+  }, {
+    key: "fetchIfRefAsync",
+    value: function fetchIfRefAsync(obj) {
+      return Promise.resolve(this.fetchIfRef(obj));
+    }
+  }]);
+
+  return XRefMock;
+}();
+
+exports.XRefMock = XRefMock;
+
+function createIdFactory(pageIndex) {
+  var page = new _document.Page({
+    pdfManager: {
+      get docId() {
+        return 'd0';
+      }
+
+    },
+    pageIndex: pageIndex
+  });
+  return page.idFactory;
+}

package/lib/cafe-pdf/src/pdfjs-dist/lib/test/unit/testreporter.js

@@ -0,0 +1,102 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * Copyright 2019 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+'use strict';
+
+var TestReporter = function TestReporter(browser, appPath) {
+  function send(action, json, cb) {
+    var r = new XMLHttpRequest();
+    r.open('POST', action, true);
+    r.setRequestHeader('Content-Type', 'application/json');
+
+    r.onreadystatechange = function sendTaskResultOnreadystatechange(e) {
+      if (r.readyState === 4) {
+        if (r.status !== 200) {
+          send(action, json, cb);
+        } else {
+          if (cb) {
+            cb();
+          }
+        }
+      }
+    };
+
+    json['browser'] = browser;
+    r.send(JSON.stringify(json));
+  }
+
+  function sendInfo(message) {
+    send('/info', {
+      message: message
+    });
+  }
+
+  function sendResult(status, description, error) {
+    var message = {
+      status: status,
+      description: description
+    };
+
+    if (typeof error !== 'undefined') {
+      message['error'] = error;
+    }
+
+    send('/submit_task_results', message);
+  }
+
+  function sendQuitRequest() {
+    send('/tellMeToQuit?path=' + escape(appPath), {});
+  }
+
+  this.now = function () {
+    return new Date().getTime();
+  };
+
+  this.jasmineStarted = function (suiteInfo) {
+    this.runnerStartTime = this.now();
+    sendInfo('Started tests for ' + browser + '.');
+  };
+
+  this.suiteStarted = function (result) {};
+
+  this.specStarted = function (result) {};
+
+  this.specDone = function (result) {
+    if (result.failedExpectations.length === 0) {
+      sendResult('TEST-PASSED', result.description);
+    } else {
+      var failedMessages = '';
+      var items = result.failedExpectations;
+
+      for (var i = 0, ii = items.length; i < ii; i++) {
+        failedMessages += items[i].message + ' ';
+      }
+
+      sendResult('TEST-UNEXPECTED-FAIL', result.description, failedMessages);
+    }
+  };
+
+  this.suiteDone = function (result) {};
+
+  this.jasmineDone = function () {
+    setTimeout(sendQuitRequest, 500);
+  };
+};

package/lib/cafe-pdf/src/pdfjs-dist/lib/test/unit/type1_parser_spec.js

@@ -0,0 +1,104 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * Copyright 2019 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+"use strict";
+
+var _fonts = require("../../core/fonts");
+
+var _stream = require("../../core/stream");
+
+var _type1_parser = require("../../core/type1_parser");
+
+describe('Type1Parser', function () {
+  it('splits tokens', function () {
+    var stream = new _stream.StringStream('/BlueValues[-17 0]noaccess def');
+    var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
+    expect(parser.getToken()).toEqual('/');
+    expect(parser.getToken()).toEqual('BlueValues');
+    expect(parser.getToken()).toEqual('[');
+    expect(parser.getToken()).toEqual('-17');
+    expect(parser.getToken()).toEqual('0');
+    expect(parser.getToken()).toEqual(']');
+    expect(parser.getToken()).toEqual('noaccess');
+    expect(parser.getToken()).toEqual('def');
+    expect(parser.getToken()).toEqual(null);
+  });
+  it('handles glued tokens', function () {
+    var stream = new _stream.StringStream('dup/CharStrings');
+    var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
+    expect(parser.getToken()).toEqual('dup');
+    expect(parser.getToken()).toEqual('/');
+    expect(parser.getToken()).toEqual('CharStrings');
+  });
+  it('ignores whitespace', function () {
+    var stream = new _stream.StringStream('\nab   c\t');
+    var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
+    expect(parser.getToken()).toEqual('ab');
+    expect(parser.getToken()).toEqual('c');
+  });
+  it('parses numbers', function () {
+    var stream = new _stream.StringStream('123');
+    var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
+    expect(parser.readNumber()).toEqual(123);
+  });
+  it('parses booleans', function () {
+    var stream = new _stream.StringStream('true false');
+    var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
+    expect(parser.readBoolean()).toEqual(1);
+    expect(parser.readBoolean()).toEqual(0);
+  });
+  it('parses number arrays', function () {
+    var stream = new _stream.StringStream('[1 2]');
+    var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
+    expect(parser.readNumberArray()).toEqual([1, 2]);
+    stream = new _stream.StringStream('[ 1 2 ]');
+    parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
+    expect(parser.readNumberArray()).toEqual([1, 2]);
+  });
+  it('skips comments', function () {
+    var stream = new _stream.StringStream('%!PS-AdobeFont-1.0: CMSY10 003.002\n' + '%%Title: CMSY10\n' + '%Version: 003.002\n' + 'FontDirectory');
+    var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
+    expect(parser.getToken()).toEqual('FontDirectory');
+  });
+  it('parses font program', function () {
+    var stream = new _stream.StringStream('/ExpansionFactor  99\n' + '/Subrs 1 array\n' + 'dup 0 1 RD x noaccess put\n' + 'end\n' + '/CharStrings 46 dict dup begin\n' + '/.notdef 1 RD x ND\n' + 'end');
+    var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
+    var program = parser.extractFontProgram({});
+    expect(program.charstrings.length).toEqual(1);
+    expect(program.properties.privateData.ExpansionFactor).toEqual(99);
+  });
+  it('parses font header font matrix', function () {
+    var stream = new _stream.StringStream('/FontMatrix [0.001 0 0 0.001 0 0 ]readonly def\n');
+    var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
+    var props = {};
+    parser.extractFontHeader(props);
+    expect(props.fontMatrix).toEqual([0.001, 0, 0, 0.001, 0, 0]);
+  });
+  it('parses font header encoding', function () {
+    var stream = new _stream.StringStream('/Encoding 256 array\n' + '0 1 255 {1 index exch /.notdef put} for\n' + 'dup 33 /arrowright put\n' + 'readonly def\n');
+    var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
+    var props = {
+      overridableEncoding: true
+    };
+    parser.extractFontHeader(props);
+    expect(props.builtInEncoding[33]).toEqual('arrowright');
+  });
+});