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

package/src/core/stream.js

@@ -1,103 +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 { BaseStream } from "./base_stream.js";
-import { stringToBytes } from "../shared/util.js";
-
-class Stream extends BaseStream {
-  constructor(arrayBuffer, start, length, dict) {
-    super();
-
-    this.bytes =
-      arrayBuffer instanceof Uint8Array
-        ? arrayBuffer
-        : new Uint8Array(arrayBuffer);
-    this.start = start || 0;
-    this.pos = this.start;
-    this.end = start + length || this.bytes.length;
-    this.dict = dict;
-  }
-
-  get length() {
-    return this.end - this.start;
-  }
-
-  get isEmpty() {
-    return this.length === 0;
-  }
-
-  getByte() {
-    if (this.pos >= this.end) {
-      return -1;
-    }
-    return this.bytes[this.pos++];
-  }
-
-  getBytes(length, forceClamped = false) {
-    const bytes = this.bytes;
-    const pos = this.pos;
-    const strEnd = this.end;
-
-    if (!length) {
-      const subarray = bytes.subarray(pos, strEnd);
-      // `this.bytes` is always a `Uint8Array` here.
-      return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
-    }
-    let end = pos + length;
-    if (end > strEnd) {
-      end = strEnd;
-    }
-    this.pos = end;
-    const subarray = bytes.subarray(pos, end);
-    // `this.bytes` is always a `Uint8Array` here.
-    return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
-  }
-
-  getByteRange(begin, end) {
-    if (begin < 0) {
-      begin = 0;
-    }
-    if (end > this.end) {
-      end = this.end;
-    }
-    return this.bytes.subarray(begin, end);
-  }
-
-  reset() {
-    this.pos = this.start;
-  }
-
-  moveStart() {
-    this.start = this.pos;
-  }
-
-  makeSubStream(start, length, dict = null) {
-    return new Stream(this.bytes.buffer, start, length, dict);
-  }
-}
-
-class StringStream extends Stream {
-  constructor(str) {
-    super(stringToBytes(str));
-  }
-}
-
-class NullStream extends Stream {
-  constructor() {
-    super(new Uint8Array(0));
-  }
-}
-
-export { NullStream, Stream, StringStream };

package/src/core/struct_tree.js

@@ -1,335 +0,0 @@
-/* Copyright 2021 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 { isDict, isName, isRef } from "./primitives.js";
-import { isString, stringToPDFString, warn } from "../shared/util.js";
-import { NumberTree } from "./name_number_tree.js";
-
-const MAX_DEPTH = 40;
-
-const StructElementType = {
-  PAGE_CONTENT: "PAGE_CONTENT",
-  STREAM_CONTENT: "STREAM_CONTENT",
-  OBJECT: "OBJECT",
-  ELEMENT: "ELEMENT",
-};
-
-class StructTreeRoot {
-  constructor(rootDict) {
-    this.dict = rootDict;
-    this.roleMap = new Map();
-  }
-
-  init() {
-    this.readRoleMap();
-  }
-
-  readRoleMap() {
-    const roleMapDict = this.dict.get("RoleMap");
-    if (!isDict(roleMapDict)) {
-      return;
-    }
-    roleMapDict.forEach((key, value) => {
-      if (!isName(value)) {
-        return;
-      }
-      this.roleMap.set(key, value.name);
-    });
-  }
-}
-
-/**
- * Instead of loading the whole tree we load just the page's relevant structure
- * elements, which means we need a wrapper structure to represent the tree.
- */
-class StructElementNode {
-  constructor(tree, dict) {
-    this.tree = tree;
-    this.dict = dict;
-    this.kids = [];
-    this.parseKids();
-  }
-
-  get role() {
-    const nameObj = this.dict.get("S");
-    const name = isName(nameObj) ? nameObj.name : "";
-    const { root } = this.tree;
-    if (root.roleMap.has(name)) {
-      return root.roleMap.get(name);
-    }
-    return name;
-  }
-
-  parseKids() {
-    let pageObjId = null;
-    const objRef = this.dict.getRaw("Pg");
-    if (isRef(objRef)) {
-      pageObjId = objRef.toString();
-    }
-    const kids = this.dict.get("K");
-    if (Array.isArray(kids)) {
-      for (const kid of kids) {
-        const element = this.parseKid(pageObjId, kid);
-        if (element) {
-          this.kids.push(element);
-        }
-      }
-    } else {
-      const element = this.parseKid(pageObjId, kids);
-      if (element) {
-        this.kids.push(element);
-      }
-    }
-  }
-
-  parseKid(pageObjId, kid) {
-    // A direct link to content, the integer is an mcid.
-    if (Number.isInteger(kid)) {
-      if (this.tree.pageDict.objId !== pageObjId) {
-        return null;
-      }
-
-      return new StructElement({
-        type: StructElementType.PAGE_CONTENT,
-        mcid: kid,
-        pageObjId,
-      });
-    }
-
-    // Find the dictionary for the kid.
-    let kidDict = null;
-    if (isRef(kid)) {
-      kidDict = this.dict.xref.fetch(kid);
-    } else if (isDict(kid)) {
-      kidDict = kid;
-    }
-    if (!kidDict) {
-      return null;
-    }
-    const pageRef = kidDict.getRaw("Pg");
-    if (isRef(pageRef)) {
-      pageObjId = pageRef.toString();
-    }
-
-    const type = isName(kidDict.get("Type")) ? kidDict.get("Type").name : null;
-    if (type === "MCR") {
-      if (this.tree.pageDict.objId !== pageObjId) {
-        return null;
-      }
-      return new StructElement({
-        type: StructElementType.STREAM_CONTENT,
-        refObjId: isRef(kidDict.getRaw("Stm"))
-          ? kidDict.getRaw("Stm").toString()
-          : null,
-        pageObjId,
-        mcid: kidDict.get("MCID"),
-      });
-    }
-
-    if (type === "OBJR") {
-      if (this.tree.pageDict.objId !== pageObjId) {
-        return null;
-      }
-      return new StructElement({
-        type: StructElementType.OBJECT,
-        refObjId: isRef(kidDict.getRaw("Obj"))
-          ? kidDict.getRaw("Obj").toString()
-          : null,
-        pageObjId,
-      });
-    }
-
-    return new StructElement({
-      type: StructElementType.ELEMENT,
-      dict: kidDict,
-    });
-  }
-}
-
-class StructElement {
-  constructor({
-    type,
-    dict = null,
-    mcid = null,
-    pageObjId = null,
-    refObjId = null,
-  }) {
-    this.type = type;
-    this.dict = dict;
-    this.mcid = mcid;
-    this.pageObjId = pageObjId;
-    this.refObjId = refObjId;
-    this.parentNode = null;
-  }
-}
-
-class StructTreePage {
-  constructor(structTreeRoot, pageDict) {
-    this.root = structTreeRoot;
-    this.rootDict = structTreeRoot ? structTreeRoot.dict : null;
-    this.pageDict = pageDict;
-    this.nodes = [];
-  }
-
-  parse() {
-    if (!this.root || !this.rootDict) {
-      return;
-    }
-
-    const parentTree = this.rootDict.get("ParentTree");
-    if (!parentTree) {
-      return;
-    }
-    const id = this.pageDict.get("StructParents");
-    if (!Number.isInteger(id)) {
-      return;
-    }
-    const numberTree = new NumberTree(parentTree, this.rootDict.xref);
-    const parentArray = numberTree.get(id);
-    if (!Array.isArray(parentArray)) {
-      return;
-    }
-    const map = new Map();
-    for (const ref of parentArray) {
-      if (isRef(ref)) {
-        this.addNode(this.rootDict.xref.fetch(ref), map);
-      }
-    }
-  }
-
-  addNode(dict, map, level = 0) {
-    if (level > MAX_DEPTH) {
-      warn("StructTree MAX_DEPTH reached.");
-      return null;
-    }
-
-    if (map.has(dict)) {
-      return map.get(dict);
-    }
-
-    const element = new StructElementNode(this, dict);
-    map.set(dict, element);
-
-    const parent = dict.get("P");
-
-    if (!parent || isName(parent.get("Type"), "StructTreeRoot")) {
-      if (!this.addTopLevelNode(dict, element)) {
-        map.delete(dict);
-      }
-      return element;
-    }
-
-    const parentNode = this.addNode(parent, map, level + 1);
-    if (!parentNode) {
-      return element;
-    }
-    let save = false;
-    for (const kid of parentNode.kids) {
-      if (kid.type === StructElementType.ELEMENT && kid.dict === dict) {
-        kid.parentNode = element;
-        save = true;
-      }
-    }
-    if (!save) {
-      map.delete(dict);
-    }
-    return element;
-  }
-
-  addTopLevelNode(dict, element) {
-    const obj = this.rootDict.get("K");
-    if (!obj) {
-      return false;
-    }
-
-    if (isDict(obj)) {
-      if (obj.objId !== dict.objId) {
-        return false;
-      }
-      this.nodes[0] = element;
-      return true;
-    }
-
-    if (!Array.isArray(obj)) {
-      return true;
-    }
-    let save = false;
-    for (let i = 0; i < obj.length; i++) {
-      const kidRef = obj[i];
-      if (kidRef && kidRef.toString() === dict.objId) {
-        this.nodes[i] = element;
-        save = true;
-      }
-    }
-    return save;
-  }
-
-  /**
-   * Convert the tree structure into a simplifed object literal that can
-   * be sent to the main thread.
-   * @returns {Object}
-   */
-  get serializable() {
-    function nodeToSerializable(node, parent, level = 0) {
-      if (level > MAX_DEPTH) {
-        warn("StructTree too deep to be fully serialized.");
-        return;
-      }
-      const obj = Object.create(null);
-      obj.role = node.role;
-      obj.children = [];
-      parent.children.push(obj);
-      const alt = node.dict.get("Alt");
-      if (isString(alt)) {
-        obj.alt = stringToPDFString(alt);
-      }
-
-      for (const kid of node.kids) {
-        const kidElement =
-          kid.type === StructElementType.ELEMENT ? kid.parentNode : null;
-        if (kidElement) {
-          nodeToSerializable(kidElement, obj, level + 1);
-          continue;
-        } else if (
-          kid.type === StructElementType.PAGE_CONTENT ||
-          kid.type === StructElementType.STREAM_CONTENT
-        ) {
-          obj.children.push({
-            type: "content",
-            id: `page${kid.pageObjId}_mcid${kid.mcid}`,
-          });
-        } else if (kid.type === StructElementType.OBJECT) {
-          obj.children.push({
-            type: "object",
-            id: kid.refObjId,
-          });
-        }
-      }
-    }
-
-    const root = Object.create(null);
-    root.children = [];
-    root.role = "Root";
-    for (const child of this.nodes) {
-      if (!child) {
-        continue;
-      }
-      nodeToSerializable(child, root);
-    }
-    return root;
-  }
-}
-
-export { StructTreePage, StructTreeRoot };

package/src/core/to_unicode_map.js

@@ -1,103 +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 { unreachable } from "../shared/util.js";
-
-class ToUnicodeMap {
-  constructor(cmap = []) {
-    // The elements of this._map can be integers or strings, depending on how
-    // `cmap` was created.
-    this._map = cmap;
-  }
-
-  get length() {
-    return this._map.length;
-  }
-
-  forEach(callback) {
-    for (const charCode in this._map) {
-      callback(charCode, this._map[charCode].charCodeAt(0));
-    }
-  }
-
-  has(i) {
-    return this._map[i] !== undefined;
-  }
-
-  get(i) {
-    return this._map[i];
-  }
-
-  charCodeOf(value) {
-    // `Array.prototype.indexOf` is *extremely* inefficient for arrays which
-    // are both very sparse and very large (see issue8372.pdf).
-    const map = this._map;
-    if (map.length <= 0x10000) {
-      return map.indexOf(value);
-    }
-    for (const charCode in map) {
-      if (map[charCode] === value) {
-        return charCode | 0;
-      }
-    }
-    return -1;
-  }
-
-  amend(map) {
-    for (const charCode in map) {
-      this._map[charCode] = map[charCode];
-    }
-  }
-}
-
-class IdentityToUnicodeMap {
-  constructor(firstChar, lastChar) {
-    this.firstChar = firstChar;
-    this.lastChar = lastChar;
-  }
-
-  get length() {
-    return this.lastChar + 1 - this.firstChar;
-  }
-
-  forEach(callback) {
-    for (let i = this.firstChar, ii = this.lastChar; i <= ii; i++) {
-      callback(i, i);
-    }
-  }
-
-  has(i) {
-    return this.firstChar <= i && i <= this.lastChar;
-  }
-
-  get(i) {
-    if (this.firstChar <= i && i <= this.lastChar) {
-      return String.fromCharCode(i);
-    }
-    return undefined;
-  }
-
-  charCodeOf(v) {
-    return Number.isInteger(v) && v >= this.firstChar && v <= this.lastChar
-      ? v
-      : -1;
-  }
-
-  amend(map) {
-    unreachable("Should not call amend()");
-  }
-}
-
-export { IdentityToUnicodeMap, ToUnicodeMap };