@vaadin-component-factory/vcf-pdf-viewer 0.9.0 → 0.9.4

package/src/core/primitives.js

@@ -1,402 +0,0 @@
-/* Copyright 2012 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.
- */
-
-import { assert, shadow, unreachable } from "../shared/util.js";
-import { BaseStream } from "./base_stream.js";
-
-const EOF = {};
-
-const Name = (function NameClosure() {
-  let nameCache = Object.create(null);
-
-  // eslint-disable-next-line no-shadow
-  class Name {
-    constructor(name) {
-      this.name = name;
-    }
-
-    static get(name) {
-      const nameValue = nameCache[name];
-      // eslint-disable-next-line no-restricted-syntax
-      return nameValue ? nameValue : (nameCache[name] = new Name(name));
-    }
-
-    static _clearCache() {
-      nameCache = Object.create(null);
-    }
-  }
-
-  return Name;
-})();
-
-const Cmd = (function CmdClosure() {
-  let cmdCache = Object.create(null);
-
-  // eslint-disable-next-line no-shadow
-  class Cmd {
-    constructor(cmd) {
-      this.cmd = cmd;
-    }
-
-    static get(cmd) {
-      const cmdValue = cmdCache[cmd];
-      // eslint-disable-next-line no-restricted-syntax
-      return cmdValue ? cmdValue : (cmdCache[cmd] = new Cmd(cmd));
-    }
-
-    static _clearCache() {
-      cmdCache = Object.create(null);
-    }
-  }
-
-  return Cmd;
-})();
-
-const nonSerializable = function nonSerializableClosure() {
-  return nonSerializable; // Creating closure on some variable.
-};
-
-class Dict {
-  constructor(xref = null) {
-    // Map should only be used internally, use functions below to access.
-    this._map = Object.create(null);
-    this.xref = xref;
-    this.objId = null;
-    this.suppressEncryption = false;
-    this.__nonSerializable__ = nonSerializable; // Disable cloning of the Dict.
-  }
-
-  assignXref(newXref) {
-    this.xref = newXref;
-  }
-
-  get size() {
-    return Object.keys(this._map).length;
-  }
-
-  // Automatically dereferences Ref objects.
-  get(key1, key2, key3) {
-    let value = this._map[key1];
-    if (value === undefined && key2 !== undefined) {
-      value = this._map[key2];
-      if (value === undefined && key3 !== undefined) {
-        value = this._map[key3];
-      }
-    }
-    if (value instanceof Ref && this.xref) {
-      return this.xref.fetch(value, this.suppressEncryption);
-    }
-    return value;
-  }
-
-  // Same as get(), but returns a promise and uses fetchIfRefAsync().
-  async getAsync(key1, key2, key3) {
-    let value = this._map[key1];
-    if (value === undefined && key2 !== undefined) {
-      value = this._map[key2];
-      if (value === undefined && key3 !== undefined) {
-        value = this._map[key3];
-      }
-    }
-    if (value instanceof Ref && this.xref) {
-      return this.xref.fetchAsync(value, this.suppressEncryption);
-    }
-    return value;
-  }
-
-  // Same as get(), but dereferences all elements if the result is an Array.
-  getArray(key1, key2, key3) {
-    let value = this._map[key1];
-    if (value === undefined && key2 !== undefined) {
-      value = this._map[key2];
-      if (value === undefined && key3 !== undefined) {
-        value = this._map[key3];
-      }
-    }
-    if (value instanceof Ref && this.xref) {
-      value = this.xref.fetch(value, this.suppressEncryption);
-    }
-
-    if (Array.isArray(value)) {
-      value = value.slice(); // Ensure that we don't modify the Dict data.
-      for (let i = 0, ii = value.length; i < ii; i++) {
-        if (value[i] instanceof Ref && this.xref) {
-          value[i] = this.xref.fetch(value[i], this.suppressEncryption);
-        }
-      }
-    }
-    return value;
-  }
-
-  // No dereferencing.
-  getRaw(key) {
-    return this._map[key];
-  }
-
-  getKeys() {
-    return Object.keys(this._map);
-  }
-
-  // No dereferencing.
-  getRawValues() {
-    return Object.values(this._map);
-  }
-
-  set(key, value) {
-    if (
-      (typeof PDFJSDev === "undefined" ||
-        PDFJSDev.test("!PRODUCTION || TESTING")) &&
-      value === undefined
-    ) {
-      unreachable('Dict.set: The "value" cannot be undefined.');
-    }
-    this._map[key] = value;
-  }
-
-  has(key) {
-    return this._map[key] !== undefined;
-  }
-
-  forEach(callback) {
-    for (const key in this._map) {
-      callback(key, this.get(key));
-    }
-  }
-
-  static get empty() {
-    const emptyDict = new Dict(null);
-
-    emptyDict.set = (key, value) => {
-      unreachable("Should not call `set` on the empty dictionary.");
-    };
-    return shadow(this, "empty", emptyDict);
-  }
-
-  static merge({ xref, dictArray, mergeSubDicts = false }) {
-    const mergedDict = new Dict(xref),
-      properties = new Map();
-
-    for (const dict of dictArray) {
-      if (!(dict instanceof Dict)) {
-        continue;
-      }
-      for (const [key, value] of Object.entries(dict._map)) {
-        let property = properties.get(key);
-        if (property === undefined) {
-          property = [];
-          properties.set(key, property);
-        } else if (!mergeSubDicts) {
-          continue; // Ignore additional entries for a "shallow" merge.
-        }
-        property.push(value);
-      }
-    }
-    for (const [name, values] of properties) {
-      if (values.length === 1 || !(values[0] instanceof Dict)) {
-        mergedDict._map[name] = values[0];
-        continue;
-      }
-      const subDict = new Dict(xref);
-
-      for (const dict of values) {
-        if (!(dict instanceof Dict)) {
-          continue;
-        }
-        for (const [key, value] of Object.entries(dict._map)) {
-          if (subDict._map[key] === undefined) {
-            subDict._map[key] = value;
-          }
-        }
-      }
-      if (subDict.size > 0) {
-        mergedDict._map[name] = subDict;
-      }
-    }
-    properties.clear();
-
-    return mergedDict.size > 0 ? mergedDict : Dict.empty;
-  }
-}
-
-const Ref = (function RefClosure() {
-  let refCache = Object.create(null);
-
-  // eslint-disable-next-line no-shadow
-  class Ref {
-    constructor(num, gen) {
-      this.num = num;
-      this.gen = gen;
-    }
-
-    toString() {
-      // This function is hot, so we make the string as compact as possible.
-      // |this.gen| is almost always zero, so we treat that case specially.
-      if (this.gen === 0) {
-        return `${this.num}R`;
-      }
-      return `${this.num}R${this.gen}`;
-    }
-
-    static get(num, gen) {
-      const key = gen === 0 ? `${num}R` : `${num}R${gen}`;
-      const refValue = refCache[key];
-      // eslint-disable-next-line no-restricted-syntax
-      return refValue ? refValue : (refCache[key] = new Ref(num, gen));
-    }
-
-    static _clearCache() {
-      refCache = Object.create(null);
-    }
-  }
-
-  return Ref;
-})();
-
-// The reference is identified by number and generation.
-// This structure stores only one instance of the reference.
-class RefSet {
-  constructor(parent = null) {
-    if (
-      (typeof PDFJSDev === "undefined" ||
-        PDFJSDev.test("!PRODUCTION || TESTING")) &&
-      parent &&
-      !(parent instanceof RefSet)
-    ) {
-      unreachable('RefSet: Invalid "parent" value.');
-    }
-    this._set = new Set(parent && parent._set);
-  }
-
-  has(ref) {
-    return this._set.has(ref.toString());
-  }
-
-  put(ref) {
-    this._set.add(ref.toString());
-  }
-
-  remove(ref) {
-    this._set.delete(ref.toString());
-  }
-
-  forEach(callback) {
-    for (const ref of this._set.values()) {
-      callback(ref);
-    }
-  }
-
-  clear() {
-    this._set.clear();
-  }
-}
-
-class RefSetCache {
-  constructor() {
-    this._map = new Map();
-  }
-
-  get size() {
-    return this._map.size;
-  }
-
-  get(ref) {
-    return this._map.get(ref.toString());
-  }
-
-  has(ref) {
-    return this._map.has(ref.toString());
-  }
-
-  put(ref, obj) {
-    this._map.set(ref.toString(), obj);
-  }
-
-  putAlias(ref, aliasRef) {
-    this._map.set(ref.toString(), this.get(aliasRef));
-  }
-
-  forEach(callback) {
-    for (const value of this._map.values()) {
-      callback(value);
-    }
-  }
-
-  clear() {
-    this._map.clear();
-  }
-}
-
-function isEOF(v) {
-  return v === EOF;
-}
-
-function isName(v, name) {
-  return v instanceof Name && (name === undefined || v.name === name);
-}
-
-function isCmd(v, cmd) {
-  return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
-}
-
-function isDict(v, type) {
-  return (
-    v instanceof Dict && (type === undefined || isName(v.get("Type"), type))
-  );
-}
-
-function isRef(v) {
-  return v instanceof Ref;
-}
-
-function isRefsEqual(v1, v2) {
-  if (
-    typeof PDFJSDev === "undefined" ||
-    PDFJSDev.test("!PRODUCTION || TESTING")
-  ) {
-    assert(
-      v1 instanceof Ref && v2 instanceof Ref,
-      "isRefsEqual: Both parameters should be `Ref`s."
-    );
-  }
-  return v1.num === v2.num && v1.gen === v2.gen;
-}
-
-function isStream(v) {
-  return v instanceof BaseStream;
-}
-
-function clearPrimitiveCaches() {
-  Cmd._clearCache();
-  Name._clearCache();
-  Ref._clearCache();
-}
-
-export {
-  clearPrimitiveCaches,
-  Cmd,
-  Dict,
-  EOF,
-  isCmd,
-  isDict,
-  isEOF,
-  isName,
-  isRef,
-  isRefsEqual,
-  isStream,
-  Name,
-  Ref,
-  RefSet,
-  RefSetCache,
-};

package/src/core/ps_parser.js

@@ -1,272 +0,0 @@
-/* Copyright 2014 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.
- */
-
-import { FormatError, shadow } from "../shared/util.js";
-import { EOF } from "./primitives.js";
-import { isWhiteSpace } from "./core_utils.js";
-
-class PostScriptParser {
-  constructor(lexer) {
-    this.lexer = lexer;
-    this.operators = [];
-    this.token = null;
-    this.prev = null;
-  }
-
-  nextToken() {
-    this.prev = this.token;
-    this.token = this.lexer.getToken();
-  }
-
-  accept(type) {
-    if (this.token.type === type) {
-      this.nextToken();
-      return true;
-    }
-    return false;
-  }
-
-  expect(type) {
-    if (this.accept(type)) {
-      return true;
-    }
-    throw new 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;
-      }
-    }
-  }
-
-  parseCondition() {
-    // Add two place holders that will be updated later
-    const conditionLocation = this.operators.length;
-    this.operators.push(null, null);
-
-    this.parseBlock();
-    this.expect(PostScriptTokenTypes.RBRACE);
-    if (this.accept(PostScriptTokenTypes.IF)) {
-      // The true block is right after the 'if' so it just falls through on true
-      // else it jumps and skips the true block.
-      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);
-      this.expect(PostScriptTokenTypes.IFELSE);
-      // The jump is added at the end of the true block to skip the false block.
-      this.operators[jumpLocation] = this.operators.length;
-      this.operators[jumpLocation + 1] = "j";
-
-      this.operators[conditionLocation] = endOfTrue;
-      this.operators[conditionLocation + 1] = "jz";
-    } else {
-      throw new FormatError("PS Function: error parsing conditional.");
-    }
-  }
-}
-
-const PostScriptTokenTypes = {
-  LBRACE: 0,
-  RBRACE: 1,
-  NUMBER: 2,
-  OPERATOR: 3,
-  IF: 4,
-  IFELSE: 5,
-};
-
-class PostScriptToken {
-  static get opCache() {
-    return shadow(this, "opCache", Object.create(null));
-  }
-
-  constructor(type, value) {
-    this.type = type;
-    this.value = value;
-  }
-
-  static getOperator(op) {
-    const opValue = PostScriptToken.opCache[op];
-    if (opValue) {
-      return opValue;
-    }
-    return (PostScriptToken.opCache[op] = new PostScriptToken(
-      PostScriptTokenTypes.OPERATOR,
-      op
-    ));
-  }
-
-  static get LBRACE() {
-    return shadow(
-      this,
-      "LBRACE",
-      new PostScriptToken(PostScriptTokenTypes.LBRACE, "{")
-    );
-  }
-
-  static get RBRACE() {
-    return shadow(
-      this,
-      "RBRACE",
-      new PostScriptToken(PostScriptTokenTypes.RBRACE, "}")
-    );
-  }
-
-  static get IF() {
-    return shadow(
-      this,
-      "IF",
-      new PostScriptToken(PostScriptTokenTypes.IF, "IF")
-    );
-  }
-
-  static get IFELSE() {
-    return shadow(
-      this,
-      "IFELSE",
-      new PostScriptToken(PostScriptTokenTypes.IFELSE, "IFELSE")
-    );
-  }
-}
-
-class PostScriptLexer {
-  constructor(stream) {
-    this.stream = stream;
-    this.nextChar();
-
-    this.strBuf = [];
-  }
-
-  nextChar() {
-    return (this.currentChar = this.stream.getByte());
-  }
-
-  getToken() {
-    let comment = false;
-    let ch = this.currentChar;
-
-    // skip comments
-    while (true) {
-      if (ch < 0) {
-        return EOF;
-      }
-
-      if (comment) {
-        if (ch === 0x0a || ch === 0x0d) {
-          comment = false;
-        }
-      } else if (ch === /* '%' = */ 0x25) {
-        comment = true;
-      } else if (!isWhiteSpace(ch)) {
-        break;
-      }
-      ch = this.nextChar();
-    }
-    switch (ch | 0) {
-      case 0x30: // '0'
-      case 0x31: // '1'
-      case 0x32: // '2'
-      case 0x33: // '3'
-      case 0x34: // '4'
-      case 0x35: // '5'
-      case 0x36: // '6'
-      case 0x37: // '7'
-      case 0x38: // '8'
-      case 0x39: // '9'
-      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;
-    }
-    // operator
-    const strBuf = this.strBuf;
-    strBuf.length = 0;
-    strBuf[0] = String.fromCharCode(ch);
-
-    while (
-      (ch = this.nextChar()) >= 0 &&
-      ((ch >= /* 'A' = */ 0x41 && ch <= /* 'Z' = */ 0x5a) ||
-        (ch >= /* 'a' = */ 0x61 && ch <= /* 'z' = */ 0x7a))
-    ) {
-      strBuf.push(String.fromCharCode(ch));
-    }
-    const str = strBuf.join("");
-    switch (str.toLowerCase()) {
-      case "if":
-        return PostScriptToken.IF;
-      case "ifelse":
-        return PostScriptToken.IFELSE;
-      default:
-        return PostScriptToken.getOperator(str);
-    }
-  }
-
-  getNumber() {
-    let ch = this.currentChar;
-    const strBuf = this.strBuf;
-    strBuf.length = 0;
-    strBuf[0] = String.fromCharCode(ch);
-
-    while ((ch = this.nextChar()) >= 0) {
-      if (
-        (ch >= /* '0' = */ 0x30 && ch <= /* '9' = */ 0x39) ||
-        ch === /* '-' = */ 0x2d ||
-        ch === /* '.' = */ 0x2e
-      ) {
-        strBuf.push(String.fromCharCode(ch));
-      } else {
-        break;
-      }
-    }
-    const value = parseFloat(strBuf.join(""));
-    if (isNaN(value)) {
-      throw new FormatError(`Invalid floating point number: ${value}`);
-    }
-    return value;
-  }
-}
-
-export { PostScriptLexer, PostScriptParser };