mol-pdf 1.0.0

package/lib/cafe-pdf/src/pdfjs-dist/lib/examples/node/domstubs.js

@@ -0,0 +1,302 @@
+/**
+ * @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";
+
+function xmlEncode(s) {
+  var i = 0,
+      ch;
+  s = String(s);
+
+  while (i < s.length && (ch = s[i]) !== '&' && ch !== '<' && ch !== '\"' && ch !== '\n' && ch !== '\r' && ch !== '\t') {
+    i++;
+  }
+
+  if (i >= s.length) {
+    return s;
+  }
+
+  var buf = s.substring(0, i);
+
+  while (i < s.length) {
+    ch = s[i++];
+
+    switch (ch) {
+      case '&':
+        buf += '&amp;';
+        break;
+
+      case '<':
+        buf += '&lt;';
+        break;
+
+      case '\"':
+        buf += '&quot;';
+        break;
+
+      case '\n':
+        buf += '&#xA;';
+        break;
+
+      case '\r':
+        buf += '&#xD;';
+        break;
+
+      case '\t':
+        buf += '&#x9;';
+        break;
+
+      default:
+        buf += ch;
+        break;
+    }
+  }
+
+  return buf;
+}
+
+function DOMElement(name) {
+  this.nodeName = name;
+  this.childNodes = [];
+  this.attributes = {};
+  this.textContent = '';
+
+  if (name === 'style') {
+    this.sheet = {
+      cssRules: [],
+      insertRule: function insertRule(rule) {
+        this.cssRules.push(rule);
+      }
+    };
+  }
+}
+
+DOMElement.prototype = {
+  getAttribute: function DOMElement_getAttribute(name) {
+    if (name in this.attributes) {
+      return this.attributes[name];
+    }
+
+    return null;
+  },
+  getAttributeNS: function DOMElement_getAttributeNS(NS, name) {
+    if (name in this.attributes) {
+      return this.attributes[name];
+    }
+
+    if (NS) {
+      var suffix = ':' + name;
+
+      for (var fullName in this.attributes) {
+        if (fullName.slice(-suffix.length) === suffix) {
+          return this.attributes[fullName];
+        }
+      }
+    }
+
+    return null;
+  },
+  setAttribute: function DOMElement_setAttribute(name, value) {
+    value = value || '';
+    value = xmlEncode(value);
+    this.attributes[name] = value;
+  },
+  setAttributeNS: function DOMElement_setAttributeNS(NS, name, value) {
+    this.setAttribute(name, value);
+  },
+  appendChild: function DOMElement_appendChild(element) {
+    var childNodes = this.childNodes;
+
+    if (!childNodes.includes(element)) {
+      childNodes.push(element);
+    }
+  },
+  hasChildNodes: function DOMElement_hasChildNodes() {
+    return this.childNodes.length !== 0;
+  },
+  cloneNode: function DOMElement_cloneNode() {
+    var newNode = new DOMElement(this.nodeName);
+    newNode.childNodes = this.childNodes;
+    newNode.attributes = this.attributes;
+    newNode.textContent = this.textContent;
+    return newNode;
+  },
+  toString: function DOMElement_toString() {
+    var buf = [];
+    var serializer = this.getSerializer();
+    var chunk;
+
+    while ((chunk = serializer.getNext()) !== null) {
+      buf.push(chunk);
+    }
+
+    return buf.join('');
+  },
+  getSerializer: function DOMElement_getSerializer() {
+    return new DOMElementSerializer(this);
+  }
+};
+
+function DOMElementSerializer(node) {
+  this._node = node;
+  this._state = 0;
+  this._loopIndex = 0;
+  this._attributeKeys = null;
+  this._childSerializer = null;
+}
+
+DOMElementSerializer.prototype = {
+  getNext: function DOMElementSerializer_getNext() {
+    var node = this._node;
+
+    switch (this._state) {
+      case 0:
+        ++this._state;
+        return '<' + node.nodeName;
+
+      case 1:
+        ++this._state;
+
+        if (node.nodeName === 'svg:svg') {
+          return ' xmlns:xlink="http://www.w3.org/1999/xlink"' + ' xmlns:svg="http://www.w3.org/2000/svg"';
+        }
+
+      case 2:
+        ++this._state;
+        this._loopIndex = 0;
+        this._attributeKeys = Object.keys(node.attributes);
+
+      case 3:
+        if (this._loopIndex < this._attributeKeys.length) {
+          var name = this._attributeKeys[this._loopIndex++];
+          return ' ' + name + '="' + xmlEncode(node.attributes[name]) + '"';
+        }
+
+        ++this._state;
+        return '>';
+
+      case 4:
+        if (node.nodeName === 'svg:tspan' || node.nodeName === 'svg:style') {
+          this._state = 6;
+          return xmlEncode(node.textContent);
+        }
+
+        ++this._state;
+        this._loopIndex = 0;
+
+      case 5:
+        var value;
+
+        while (true) {
+          value = this._childSerializer && this._childSerializer.getNext();
+
+          if (value !== null) {
+            return value;
+          }
+
+          var nextChild = node.childNodes[this._loopIndex++];
+
+          if (nextChild) {
+            this._childSerializer = new DOMElementSerializer(nextChild);
+          } else {
+            this._childSerializer = null;
+            ++this._state;
+            break;
+          }
+        }
+
+      case 6:
+        ++this._state;
+        return '</' + node.nodeName + '>';
+
+      case 7:
+        return null;
+
+      default:
+        throw new Error('Unexpected serialization state: ' + this._state);
+    }
+  }
+};
+var document = {
+  childNodes: [],
+
+  get currentScript() {
+    return {
+      src: ''
+    };
+  },
+
+  get documentElement() {
+    return this;
+  },
+
+  createElementNS: function createElementNS(NS, element) {
+    var elObject = new DOMElement(element);
+    return elObject;
+  },
+  createElement: function createElement(element) {
+    return this.createElementNS('', element);
+  },
+  getElementsByTagName: function getElementsByTagName(element) {
+    if (element === 'head') {
+      return [this.head || (this.head = new DOMElement('head'))];
+    }
+
+    return [];
+  }
+};
+
+function Image() {
+  this._src = null;
+  this.onload = null;
+}
+
+Image.prototype = {
+  get src() {
+    return this._src;
+  },
+
+  set src(value) {
+    this._src = value;
+
+    if (this.onload) {
+      this.onload();
+    }
+  }
+
+};
+exports.document = document;
+exports.Image = Image;
+var exported_symbols = Object.keys(exports);
+
+exports.setStubs = function (namespace) {
+  exported_symbols.forEach(function (key) {
+    console.assert(!(key in namespace), 'property should not be set: ' + key);
+    namespace[key] = exports[key];
+  });
+};
+
+exports.unsetStubs = function (namespace) {
+  exported_symbols.forEach(function (key) {
+    console.assert(key in namespace, 'property should be set: ' + key);
+    delete namespace[key];
+  });
+};

package/lib/cafe-pdf/src/pdfjs-dist/lib/pdf.js

@@ -0,0 +1,103 @@
+/**
+ * @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 pdfjsVersion = '2.3.200';
+var pdfjsBuild = '4ae3f9fc';
+
+var pdfjsSharedUtil = require('./shared/util.js');
+
+var pdfjsDisplayAPI = require('./display/api.js');
+
+var pdfjsDisplayTextLayer = require('./display/text_layer.js');
+
+var pdfjsDisplayAnnotationLayer = require('./display/annotation_layer.js');
+
+var pdfjsDisplayDisplayUtils = require('./display/display_utils.js');
+
+var pdfjsDisplaySVG = require('./display/svg.js');
+
+var pdfjsDisplayWorkerOptions = require('./display/worker_options.js');
+
+var pdfjsDisplayAPICompatibility = require('./display/api_compatibility.js');
+
+{
+  var isNodeJS = require('./shared/is_node.js');
+
+  if (isNodeJS()) {
+    var PDFNodeStream = require('./display/node_stream.js').PDFNodeStream;
+
+    pdfjsDisplayAPI.setPDFNetworkStreamFactory(function (params) {
+      return new PDFNodeStream(params);
+    });
+  } else {
+    var PDFNetworkStream = require('./display/network.js').PDFNetworkStream;
+
+    var PDFFetchStream;
+
+    if (pdfjsDisplayDisplayUtils.isFetchSupported()) {
+      PDFFetchStream = require('./display/fetch_stream.js').PDFFetchStream;
+    }
+
+    pdfjsDisplayAPI.setPDFNetworkStreamFactory(function (params) {
+      if (PDFFetchStream && pdfjsDisplayDisplayUtils.isValidFetchUrl(params.url)) {
+        return new PDFFetchStream(params);
+      }
+
+      return new PDFNetworkStream(params);
+    });
+  }
+}
+exports.build = pdfjsDisplayAPI.build;
+exports.version = pdfjsDisplayAPI.version;
+exports.getDocument = pdfjsDisplayAPI.getDocument;
+exports.LoopbackPort = pdfjsDisplayAPI.LoopbackPort;
+exports.PDFDataRangeTransport = pdfjsDisplayAPI.PDFDataRangeTransport;
+exports.PDFWorker = pdfjsDisplayAPI.PDFWorker;
+exports.renderTextLayer = pdfjsDisplayTextLayer.renderTextLayer;
+exports.AnnotationLayer = pdfjsDisplayAnnotationLayer.AnnotationLayer;
+exports.createPromiseCapability = pdfjsSharedUtil.createPromiseCapability;
+exports.PasswordResponses = pdfjsSharedUtil.PasswordResponses;
+exports.InvalidPDFException = pdfjsSharedUtil.InvalidPDFException;
+exports.MissingPDFException = pdfjsSharedUtil.MissingPDFException;
+exports.SVGGraphics = pdfjsDisplaySVG.SVGGraphics;
+exports.NativeImageDecoding = pdfjsSharedUtil.NativeImageDecoding;
+exports.CMapCompressionType = pdfjsSharedUtil.CMapCompressionType;
+exports.PermissionFlag = pdfjsSharedUtil.PermissionFlag;
+exports.UnexpectedResponseException = pdfjsSharedUtil.UnexpectedResponseException;
+exports.OPS = pdfjsSharedUtil.OPS;
+exports.VerbosityLevel = pdfjsSharedUtil.VerbosityLevel;
+exports.UNSUPPORTED_FEATURES = pdfjsSharedUtil.UNSUPPORTED_FEATURES;
+exports.createValidAbsoluteUrl = pdfjsSharedUtil.createValidAbsoluteUrl;
+exports.createObjectURL = pdfjsSharedUtil.createObjectURL;
+exports.removeNullCharacters = pdfjsSharedUtil.removeNullCharacters;
+exports.shadow = pdfjsSharedUtil.shadow;
+exports.Util = pdfjsSharedUtil.Util;
+exports.ReadableStream = pdfjsSharedUtil.ReadableStream;
+exports.RenderingCancelledException = pdfjsDisplayDisplayUtils.RenderingCancelledException;
+exports.getFilenameFromUrl = pdfjsDisplayDisplayUtils.getFilenameFromUrl;
+exports.LinkTarget = pdfjsDisplayDisplayUtils.LinkTarget;
+exports.addLinkAttributes = pdfjsDisplayDisplayUtils.addLinkAttributes;
+exports.loadScript = pdfjsDisplayDisplayUtils.loadScript;
+exports.PDFDateString = pdfjsDisplayDisplayUtils.PDFDateString;
+exports.GlobalWorkerOptions = pdfjsDisplayWorkerOptions.GlobalWorkerOptions;
+exports.apiCompatibilityParams = pdfjsDisplayAPICompatibility.apiCompatibilityParams;

package/lib/cafe-pdf/src/pdfjs-dist/lib/pdf.worker.js

@@ -0,0 +1,29 @@
+/**
+ * @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 pdfjsVersion = '2.3.200';
+var pdfjsBuild = '4ae3f9fc';
+
+var pdfjsCoreWorker = require('./core/worker.js');
+
+exports.WorkerMessageHandler = pdfjsCoreWorker.WorkerMessageHandler;

package/lib/cafe-pdf/src/pdfjs-dist/lib/shared/compatibility.js

@@ -0,0 +1,273 @@
+/**
+ * @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";
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var globalScope = require('./global_scope');
+
+if (!globalScope._pdfjsCompatibilityChecked) {
+  globalScope._pdfjsCompatibilityChecked = true;
+
+  var isNodeJS = require('./is_node');
+
+  var hasDOM = (typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object' && (typeof document === "undefined" ? "undefined" : _typeof(document)) === 'object';
+
+  (function checkNodeBtoa() {
+    if (globalScope.btoa || !isNodeJS()) {
+      return;
+    }
+
+    globalScope.btoa = function (chars) {
+      return Buffer.from(chars, 'binary').toString('base64');
+    };
+  })();
+
+  (function checkNodeAtob() {
+    if (globalScope.atob || !isNodeJS()) {
+      return;
+    }
+
+    globalScope.atob = function (input) {
+      return Buffer.from(input, 'base64').toString('binary');
+    };
+  })();
+
+  (function checkChildNodeRemove() {
+    if (!hasDOM) {
+      return;
+    }
+
+    if (typeof Element.prototype.remove !== 'undefined') {
+      return;
+    }
+
+    Element.prototype.remove = function () {
+      if (this.parentNode) {
+        this.parentNode.removeChild(this);
+      }
+    };
+  })();
+
+  (function checkDOMTokenListAddRemove() {
+    if (!hasDOM || isNodeJS()) {
+      return;
+    }
+
+    var div = document.createElement('div');
+    div.classList.add('testOne', 'testTwo');
+
+    if (div.classList.contains('testOne') === true && div.classList.contains('testTwo') === true) {
+      return;
+    }
+
+    var OriginalDOMTokenListAdd = DOMTokenList.prototype.add;
+    var OriginalDOMTokenListRemove = DOMTokenList.prototype.remove;
+
+    DOMTokenList.prototype.add = function () {
+      for (var _len = arguments.length, tokens = new Array(_len), _key = 0; _key < _len; _key++) {
+        tokens[_key] = arguments[_key];
+      }
+
+      for (var _i = 0, _tokens = tokens; _i < _tokens.length; _i++) {
+        var token = _tokens[_i];
+        OriginalDOMTokenListAdd.call(this, token);
+      }
+    };
+
+    DOMTokenList.prototype.remove = function () {
+      for (var _len2 = arguments.length, tokens = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        tokens[_key2] = arguments[_key2];
+      }
+
+      for (var _i2 = 0, _tokens2 = tokens; _i2 < _tokens2.length; _i2++) {
+        var token = _tokens2[_i2];
+        OriginalDOMTokenListRemove.call(this, token);
+      }
+    };
+  })();
+
+  (function checkDOMTokenListToggle() {
+    if (!hasDOM || isNodeJS()) {
+      return;
+    }
+
+    var div = document.createElement('div');
+
+    if (div.classList.toggle('test', 0) === false) {
+      return;
+    }
+
+    DOMTokenList.prototype.toggle = function (token) {
+      var force = arguments.length > 1 ? !!arguments[1] : !this.contains(token);
+      return this[force ? 'add' : 'remove'](token), force;
+    };
+  })();
+
+  (function checkStringStartsWith() {
+    if (String.prototype.startsWith) {
+      return;
+    }
+
+    require('core-js/es/string/starts-with');
+  })();
+
+  (function checkStringEndsWith() {
+    if (String.prototype.endsWith) {
+      return;
+    }
+
+    require('core-js/es/string/ends-with');
+  })();
+
+  (function checkStringIncludes() {
+    if (String.prototype.includes) {
+      return;
+    }
+
+    require('core-js/es/string/includes');
+  })();
+
+  (function checkArrayIncludes() {
+    if (Array.prototype.includes) {
+      return;
+    }
+
+    require('core-js/es/array/includes');
+  })();
+
+  (function checkArrayFrom() {
+    if (Array.from) {
+      return;
+    }
+
+    require('core-js/es/array/from');
+  })();
+
+  (function checkObjectAssign() {
+    if (Object.assign) {
+      return;
+    }
+
+    require('core-js/es/object/assign');
+  })();
+
+  (function checkMathLog2() {
+    if (Math.log2) {
+      return;
+    }
+
+    Math.log2 = require('core-js/es/math/log2');
+  })();
+
+  (function checkNumberIsNaN() {
+    if (Number.isNaN) {
+      return;
+    }
+
+    Number.isNaN = require('core-js/es/number/is-nan');
+  })();
+
+  (function checkNumberIsInteger() {
+    if (Number.isInteger) {
+      return;
+    }
+
+    Number.isInteger = require('core-js/es/number/is-integer');
+  })();
+
+  (function checkPromise() {
+    if (globalScope.Promise && globalScope.Promise.prototype && globalScope.Promise.prototype["finally"]) {
+      return;
+    }
+
+    globalScope.Promise = require('core-js/es/promise/index');
+  })();
+
+  (function checkURL() {
+    globalScope.URL = require('core-js/web/url');
+  })();
+
+  (function checkWeakMap() {
+    if (globalScope.WeakMap) {
+      return;
+    }
+
+    globalScope.WeakMap = require('core-js/es/weak-map/index');
+  })();
+
+  (function checkWeakSet() {
+    if (globalScope.WeakSet) {
+      return;
+    }
+
+    globalScope.WeakSet = require('core-js/es/weak-set/index');
+  })();
+
+  (function checkStringCodePointAt() {
+    if (String.prototype.codePointAt) {
+      return;
+    }
+
+    require('core-js/es/string/code-point-at');
+  })();
+
+  (function checkStringFromCodePoint() {
+    if (String.fromCodePoint) {
+      return;
+    }
+
+    String.fromCodePoint = require('core-js/es/string/from-code-point');
+  })();
+
+  (function checkSymbol() {
+    if (globalScope.Symbol) {
+      return;
+    }
+
+    require('core-js/es/symbol/index');
+  })();
+
+  (function checkStringPadStart() {
+    if (String.prototype.padStart) {
+      return;
+    }
+
+    require('core-js/es/string/pad-start');
+  })();
+
+  (function checkStringPadEnd() {
+    if (String.prototype.padEnd) {
+      return;
+    }
+
+    require('core-js/es/string/pad-end');
+  })();
+
+  (function checkObjectValues() {
+    if (Object.values) {
+      return;
+    }
+
+    Object.values = require('core-js/es/object/values');
+  })();
+}