pdfjs-dist 2.3.200 → 2.4.456

package/lib/core/ps_parser.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2019 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,110 +26,93 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PostScriptParser = exports.PostScriptLexer = void 0;
 
-var _util = require("../shared/util");
+var _util = require("../shared/util.js");
 
-var _primitives = require("./primitives");
+var _primitives = require("./primitives.js");
 
-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 PostScriptParser =
-/*#__PURE__*/
-function () {
-  function PostScriptParser(lexer) {
-    _classCallCheck(this, PostScriptParser);
+var _core_utils = require("./core_utils.js");
 
+class PostScriptParser {
+  constructor(lexer) {
     this.lexer = lexer;
     this.operators = [];
     this.token = null;
     this.prev = null;
   }
 
-  _createClass(PostScriptParser, [{
-    key: "nextToken",
-    value: function nextToken() {
-      this.prev = this.token;
-      this.token = this.lexer.getToken();
-    }
-  }, {
-    key: "accept",
-    value: function accept(type) {
-      if (this.token.type === type) {
-        this.nextToken();
-        return true;
-      }
+  nextToken() {
+    this.prev = this.token;
+    this.token = this.lexer.getToken();
+  }
 
-      return false;
+  accept(type) {
+    if (this.token.type === type) {
+      this.nextToken();
+      return true;
     }
-  }, {
-    key: "expect",
-    value: function expect(type) {
-      if (this.accept(type)) {
-        return true;
-      }
 
-      throw new _util.FormatError("Unexpected symbol: found ".concat(this.token.type, " expected ").concat(type, "."));
-    }
-  }, {
-    key: "parse",
-    value: function parse() {
-      this.nextToken();
-      this.expect(PostScriptTokenTypes.LBRACE);
-      this.parseBlock();
-      this.expect(PostScriptTokenTypes.RBRACE);
-      return this.operators;
+    return false;
+  }
+
+  expect(type) {
+    if (this.accept(type)) {
+      return true;
     }
-  }, {
-    key: "parseBlock",
-    value: function parseBlock() {
-      while (true) {
-        if (this.accept(PostScriptTokenTypes.NUMBER)) {
-          this.operators.push(this.prev.value);
-        } else if (this.accept(PostScriptTokenTypes.OPERATOR)) {
-          this.operators.push(this.prev.value);
-        } else if (this.accept(PostScriptTokenTypes.LBRACE)) {
-          this.parseCondition();
-        } else {
-          return;
-        }
+
+    throw new _util.FormatError(`Unexpected symbol: found ${this.token.type} expected ${type}.`);
+  }
+
+  parse() {
+    this.nextToken();
+    this.expect(PostScriptTokenTypes.LBRACE);
+    this.parseBlock();
+    this.expect(PostScriptTokenTypes.RBRACE);
+    return this.operators;
+  }
+
+  parseBlock() {
+    while (true) {
+      if (this.accept(PostScriptTokenTypes.NUMBER)) {
+        this.operators.push(this.prev.value);
+      } else if (this.accept(PostScriptTokenTypes.OPERATOR)) {
+        this.operators.push(this.prev.value);
+      } else if (this.accept(PostScriptTokenTypes.LBRACE)) {
+        this.parseCondition();
+      } else {
+        return;
       }
     }
-  }, {
-    key: "parseCondition",
-    value: function parseCondition() {
-      var conditionLocation = this.operators.length;
+  }
+
+  parseCondition() {
+    const conditionLocation = this.operators.length;
+    this.operators.push(null, null);
+    this.parseBlock();
+    this.expect(PostScriptTokenTypes.RBRACE);
+
+    if (this.accept(PostScriptTokenTypes.IF)) {
+      this.operators[conditionLocation] = this.operators.length;
+      this.operators[conditionLocation + 1] = "jz";
+    } else if (this.accept(PostScriptTokenTypes.LBRACE)) {
+      const jumpLocation = this.operators.length;
       this.operators.push(null, null);
+      const endOfTrue = this.operators.length;
       this.parseBlock();
       this.expect(PostScriptTokenTypes.RBRACE);
-
-      if (this.accept(PostScriptTokenTypes.IF)) {
-        this.operators[conditionLocation] = this.operators.length;
-        this.operators[conditionLocation + 1] = 'jz';
-      } else if (this.accept(PostScriptTokenTypes.LBRACE)) {
-        var jumpLocation = this.operators.length;
-        this.operators.push(null, null);
-        var endOfTrue = this.operators.length;
-        this.parseBlock();
-        this.expect(PostScriptTokenTypes.RBRACE);
-        this.expect(PostScriptTokenTypes.IFELSE);
-        this.operators[jumpLocation] = this.operators.length;
-        this.operators[jumpLocation + 1] = 'j';
-        this.operators[conditionLocation] = endOfTrue;
-        this.operators[conditionLocation + 1] = 'jz';
-      } else {
-        throw new _util.FormatError('PS Function: error parsing conditional.');
-      }
+      this.expect(PostScriptTokenTypes.IFELSE);
+      this.operators[jumpLocation] = this.operators.length;
+      this.operators[jumpLocation + 1] = "j";
+      this.operators[conditionLocation] = endOfTrue;
+      this.operators[conditionLocation + 1] = "jz";
+    } else {
+      throw new _util.FormatError("PS Function: error parsing conditional.");
     }
-  }]);
+  }
 
-  return PostScriptParser;
-}();
+}
 
 exports.PostScriptParser = PostScriptParser;
-var PostScriptTokenTypes = {
+const PostScriptTokenTypes = {
   LBRACE: 0,
   RBRACE: 1,
   NUMBER: 2,
@@ -138,171 +121,149 @@ var PostScriptTokenTypes = {
   IFELSE: 5
 };
 
-var PostScriptToken = function PostScriptTokenClosure() {
-  var opCache = Object.create(null);
-
-  var PostScriptToken =
-  /*#__PURE__*/
-  function () {
-    function PostScriptToken(type, value) {
-      _classCallCheck(this, PostScriptToken);
+const PostScriptToken = function PostScriptTokenClosure() {
+  const opCache = Object.create(null);
 
+  class PostScriptToken {
+    constructor(type, value) {
       this.type = type;
       this.value = value;
     }
 
-    _createClass(PostScriptToken, null, [{
-      key: "getOperator",
-      value: function getOperator(op) {
-        var opValue = opCache[op];
+    static getOperator(op) {
+      const opValue = opCache[op];
 
-        if (opValue) {
-          return opValue;
-        }
-
-        return opCache[op] = new PostScriptToken(PostScriptTokenTypes.OPERATOR, op);
-      }
-    }, {
-      key: "LBRACE",
-      get: function get() {
-        return (0, _util.shadow)(this, 'LBRACE', new PostScriptToken(PostScriptTokenTypes.LBRACE, '{'));
-      }
-    }, {
-      key: "RBRACE",
-      get: function get() {
-        return (0, _util.shadow)(this, 'RBRACE', new PostScriptToken(PostScriptTokenTypes.RBRACE, '}'));
-      }
-    }, {
-      key: "IF",
-      get: function get() {
-        return (0, _util.shadow)(this, 'IF', new PostScriptToken(PostScriptTokenTypes.IF, 'IF'));
+      if (opValue) {
+        return opValue;
       }
-    }, {
-      key: "IFELSE",
-      get: function get() {
-        return (0, _util.shadow)(this, 'IFELSE', new PostScriptToken(PostScriptTokenTypes.IFELSE, 'IFELSE'));
-      }
-    }]);
 
-    return PostScriptToken;
-  }();
+      return opCache[op] = new PostScriptToken(PostScriptTokenTypes.OPERATOR, op);
+    }
+
+    static get LBRACE() {
+      return (0, _util.shadow)(this, "LBRACE", new PostScriptToken(PostScriptTokenTypes.LBRACE, "{"));
+    }
+
+    static get RBRACE() {
+      return (0, _util.shadow)(this, "RBRACE", new PostScriptToken(PostScriptTokenTypes.RBRACE, "}"));
+    }
+
+    static get IF() {
+      return (0, _util.shadow)(this, "IF", new PostScriptToken(PostScriptTokenTypes.IF, "IF"));
+    }
+
+    static get IFELSE() {
+      return (0, _util.shadow)(this, "IFELSE", new PostScriptToken(PostScriptTokenTypes.IFELSE, "IFELSE"));
+    }
+
+  }
 
   return PostScriptToken;
 }();
 
-var PostScriptLexer =
-/*#__PURE__*/
-function () {
-  function PostScriptLexer(stream) {
-    _classCallCheck(this, PostScriptLexer);
-
+class PostScriptLexer {
+  constructor(stream) {
     this.stream = stream;
     this.nextChar();
     this.strBuf = [];
   }
 
-  _createClass(PostScriptLexer, [{
-    key: "nextChar",
-    value: function nextChar() {
-      return this.currentChar = this.stream.getByte();
-    }
-  }, {
-    key: "getToken",
-    value: function getToken() {
-      var comment = false;
-      var ch = this.currentChar;
-
-      while (true) {
-        if (ch < 0) {
-          return _primitives.EOF;
-        }
+  nextChar() {
+    return this.currentChar = this.stream.getByte();
+  }
 
-        if (comment) {
-          if (ch === 0x0A || ch === 0x0D) {
-            comment = false;
-          }
-        } else if (ch === 0x25) {
-          comment = true;
-        } else if (!(0, _util.isSpace)(ch)) {
-          break;
-        }
+  getToken() {
+    let comment = false;
+    let ch = this.currentChar;
 
-        ch = this.nextChar();
+    while (true) {
+      if (ch < 0) {
+        return _primitives.EOF;
       }
 
-      switch (ch | 0) {
-        case 0x30:
-        case 0x31:
-        case 0x32:
-        case 0x33:
-        case 0x34:
-        case 0x35:
-        case 0x36:
-        case 0x37:
-        case 0x38:
-        case 0x39:
-        case 0x2B:
-        case 0x2D:
-        case 0x2E:
-          return new PostScriptToken(PostScriptTokenTypes.NUMBER, this.getNumber());
-
-        case 0x7B:
-          this.nextChar();
-          return PostScriptToken.LBRACE;
-
-        case 0x7D:
-          this.nextChar();
-          return PostScriptToken.RBRACE;
+      if (comment) {
+        if (ch === 0x0a || ch === 0x0d) {
+          comment = false;
+        }
+      } else if (ch === 0x25) {
+        comment = true;
+      } else if (!(0, _core_utils.isWhiteSpace)(ch)) {
+        break;
       }
 
-      var strBuf = this.strBuf;
-      strBuf.length = 0;
-      strBuf[0] = String.fromCharCode(ch);
+      ch = this.nextChar();
+    }
 
-      while ((ch = this.nextChar()) >= 0 && (ch >= 0x41 && ch <= 0x5A || ch >= 0x61 && ch <= 0x7A)) {
-        strBuf.push(String.fromCharCode(ch));
-      }
+    switch (ch | 0) {
+      case 0x30:
+      case 0x31:
+      case 0x32:
+      case 0x33:
+      case 0x34:
+      case 0x35:
+      case 0x36:
+      case 0x37:
+      case 0x38:
+      case 0x39:
+      case 0x2b:
+      case 0x2d:
+      case 0x2e:
+        return new PostScriptToken(PostScriptTokenTypes.NUMBER, this.getNumber());
+
+      case 0x7b:
+        this.nextChar();
+        return PostScriptToken.LBRACE;
+
+      case 0x7d:
+        this.nextChar();
+        return PostScriptToken.RBRACE;
+    }
 
-      var str = strBuf.join('');
+    const strBuf = this.strBuf;
+    strBuf.length = 0;
+    strBuf[0] = String.fromCharCode(ch);
 
-      switch (str.toLowerCase()) {
-        case 'if':
-          return PostScriptToken.IF;
+    while ((ch = this.nextChar()) >= 0 && (ch >= 0x41 && ch <= 0x5a || ch >= 0x61 && ch <= 0x7a)) {
+      strBuf.push(String.fromCharCode(ch));
+    }
 
-        case 'ifelse':
-          return PostScriptToken.IFELSE;
+    const str = strBuf.join("");
 
-        default:
-          return PostScriptToken.getOperator(str);
-      }
+    switch (str.toLowerCase()) {
+      case "if":
+        return PostScriptToken.IF;
+
+      case "ifelse":
+        return PostScriptToken.IFELSE;
+
+      default:
+        return PostScriptToken.getOperator(str);
     }
-  }, {
-    key: "getNumber",
-    value: function getNumber() {
-      var ch = this.currentChar;
-      var strBuf = this.strBuf;
-      strBuf.length = 0;
-      strBuf[0] = String.fromCharCode(ch);
-
-      while ((ch = this.nextChar()) >= 0) {
-        if (ch >= 0x30 && ch <= 0x39 || ch === 0x2D || ch === 0x2E) {
-          strBuf.push(String.fromCharCode(ch));
-        } else {
-          break;
-        }
-      }
+  }
 
-      var value = parseFloat(strBuf.join(''));
+  getNumber() {
+    let ch = this.currentChar;
+    const strBuf = this.strBuf;
+    strBuf.length = 0;
+    strBuf[0] = String.fromCharCode(ch);
 
-      if (isNaN(value)) {
-        throw new _util.FormatError("Invalid floating point number: ".concat(value));
+    while ((ch = this.nextChar()) >= 0) {
+      if (ch >= 0x30 && ch <= 0x39 || ch === 0x2d || ch === 0x2e) {
+        strBuf.push(String.fromCharCode(ch));
+      } else {
+        break;
       }
+    }
 
-      return value;
+    const value = parseFloat(strBuf.join(""));
+
+    if (isNaN(value)) {
+      throw new _util.FormatError(`Invalid floating point number: ${value}`);
     }
-  }]);
 
-  return PostScriptLexer;
-}();
+    return value;
+  }
+
+}
 
 exports.PostScriptLexer = PostScriptLexer;