zhui-plus 1.0.0 → 1.0.10

package/packages/components/fileViewer/src/liteofd/font/predictor_stream.js

@@ -0,0 +1,234 @@
+/* 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 { DecodeStream } from "./decode_stream.js";
+import { Dict } from "./primitives.js";
+import { FormatError } from "./util.js";
+
+class PredictorStream extends DecodeStream {
+  constructor(str, maybeLength, params) {
+    super(maybeLength);
+
+    if (!(params instanceof Dict)) {
+      return str; // no prediction
+    }
+    const predictor = (this.predictor = params.get("Predictor") || 1);
+
+    if (predictor <= 1) {
+      return str; // no prediction
+    }
+    if (predictor !== 2 && (predictor < 10 || predictor > 15)) {
+      throw new FormatError(`Unsupported predictor: ${predictor}`);
+    }
+
+    this.readBlock = predictor === 2 ? this.readBlockTiff : this.readBlockPng;
+
+    this.str = str;
+    this.dict = str.dict;
+
+    const colors = (this.colors = params.get("Colors") || 1);
+    const bits = (this.bits = params.get("BPC", "BitsPerComponent") || 8);
+    const columns = (this.columns = params.get("Columns") || 1);
+
+    this.pixBytes = (colors * bits + 7) >> 3;
+    this.rowBytes = (columns * colors * bits + 7) >> 3;
+
+    return this;
+  }
+
+  readBlockTiff() {
+    const rowBytes = this.rowBytes;
+
+    const bufferLength = this.bufferLength;
+    const buffer = this.ensureBuffer(bufferLength + rowBytes);
+
+    const bits = this.bits;
+    const colors = this.colors;
+
+    const rawBytes = this.str.getBytes(rowBytes);
+    this.eof = !rawBytes.length;
+    if (this.eof) {
+      return;
+    }
+
+    let inbuf = 0,
+      outbuf = 0;
+    let inbits = 0,
+      outbits = 0;
+    let pos = bufferLength;
+    let i;
+
+    if (bits === 1 && colors === 1) {
+      // Optimized version of the loop in the "else"-branch
+      // for 1 bit-per-component and 1 color TIFF images.
+      for (i = 0; i < rowBytes; ++i) {
+        let c = rawBytes[i] ^ inbuf;
+        c ^= c >> 1;
+        c ^= c >> 2;
+        c ^= c >> 4;
+        inbuf = (c & 1) << 7;
+        buffer[pos++] = c;
+      }
+    } else if (bits === 8) {
+      for (i = 0; i < colors; ++i) {
+        buffer[pos++] = rawBytes[i];
+      }
+      for (; i < rowBytes; ++i) {
+        buffer[pos] = buffer[pos - colors] + rawBytes[i];
+        pos++;
+      }
+    } else if (bits === 16) {
+      const bytesPerPixel = colors * 2;
+      for (i = 0; i < bytesPerPixel; ++i) {
+        buffer[pos++] = rawBytes[i];
+      }
+      for (; i < rowBytes; i += 2) {
+        const sum =
+          ((rawBytes[i] & 0xff) << 8) +
+          (rawBytes[i + 1] & 0xff) +
+          ((buffer[pos - bytesPerPixel] & 0xff) << 8) +
+          (buffer[pos - bytesPerPixel + 1] & 0xff);
+        buffer[pos++] = (sum >> 8) & 0xff;
+        buffer[pos++] = sum & 0xff;
+      }
+    } else {
+      const compArray = new Uint8Array(colors + 1);
+      const bitMask = (1 << bits) - 1;
+      let j = 0,
+        k = bufferLength;
+      const columns = this.columns;
+      for (i = 0; i < columns; ++i) {
+        for (let kk = 0; kk < colors; ++kk) {
+          if (inbits < bits) {
+            inbuf = (inbuf << 8) | (rawBytes[j++] & 0xff);
+            inbits += 8;
+          }
+          compArray[kk] =
+            (compArray[kk] + (inbuf >> (inbits - bits))) & bitMask;
+          inbits -= bits;
+          outbuf = (outbuf << bits) | compArray[kk];
+          outbits += bits;
+          if (outbits >= 8) {
+            buffer[k++] = (outbuf >> (outbits - 8)) & 0xff;
+            outbits -= 8;
+          }
+        }
+      }
+      if (outbits > 0) {
+        buffer[k++] =
+          (outbuf << (8 - outbits)) + (inbuf & ((1 << (8 - outbits)) - 1));
+      }
+    }
+    this.bufferLength += rowBytes;
+  }
+
+  readBlockPng() {
+    const rowBytes = this.rowBytes;
+    const pixBytes = this.pixBytes;
+
+    const predictor = this.str.getByte();
+    const rawBytes = this.str.getBytes(rowBytes);
+    this.eof = !rawBytes.length;
+    if (this.eof) {
+      return;
+    }
+
+    const bufferLength = this.bufferLength;
+    const buffer = this.ensureBuffer(bufferLength + rowBytes);
+
+    let prevRow = buffer.subarray(bufferLength - rowBytes, bufferLength);
+    if (prevRow.length === 0) {
+      prevRow = new Uint8Array(rowBytes);
+    }
+
+    let i,
+      j = bufferLength,
+      up,
+      c;
+    switch (predictor) {
+      case 0:
+        for (i = 0; i < rowBytes; ++i) {
+          buffer[j++] = rawBytes[i];
+        }
+        break;
+      case 1:
+        for (i = 0; i < pixBytes; ++i) {
+          buffer[j++] = rawBytes[i];
+        }
+        for (; i < rowBytes; ++i) {
+          buffer[j] = (buffer[j - pixBytes] + rawBytes[i]) & 0xff;
+          j++;
+        }
+        break;
+      case 2:
+        for (i = 0; i < rowBytes; ++i) {
+          buffer[j++] = (prevRow[i] + rawBytes[i]) & 0xff;
+        }
+        break;
+      case 3:
+        for (i = 0; i < pixBytes; ++i) {
+          buffer[j++] = (prevRow[i] >> 1) + rawBytes[i];
+        }
+        for (; i < rowBytes; ++i) {
+          buffer[j] =
+            (((prevRow[i] + buffer[j - pixBytes]) >> 1) + rawBytes[i]) & 0xff;
+          j++;
+        }
+        break;
+      case 4:
+        // we need to save the up left pixels values. the simplest way
+        // is to create a new buffer
+        for (i = 0; i < pixBytes; ++i) {
+          up = prevRow[i];
+          c = rawBytes[i];
+          buffer[j++] = up + c;
+        }
+        for (; i < rowBytes; ++i) {
+          up = prevRow[i];
+          const upLeft = prevRow[i - pixBytes];
+          const left = buffer[j - pixBytes];
+          const p = left + up - upLeft;
+
+          let pa = p - left;
+          if (pa < 0) {
+            pa = -pa;
+          }
+          let pb = p - up;
+          if (pb < 0) {
+            pb = -pb;
+          }
+          let pc = p - upLeft;
+          if (pc < 0) {
+            pc = -pc;
+          }
+
+          c = rawBytes[i];
+          if (pa <= pb && pa <= pc) {
+            buffer[j++] = left + c;
+          } else if (pb <= pc) {
+            buffer[j++] = up + c;
+          } else {
+            buffer[j++] = upLeft + c;
+          }
+        }
+        break;
+      default:
+        throw new FormatError(`Unsupported predictor: ${predictor}`);
+    }
+    this.bufferLength += rowBytes;
+  }
+}
+
+export { PredictorStream };

package/packages/components/fileViewer/src/liteofd/font/primitives.js

@@ -0,0 +1,354 @@
+/* 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 "./util.js";
+
+const CIRCULAR_REF = Symbol("CIRCULAR_REF");
+const EOF = Symbol("EOF");
+
+let CmdCache = Object.create(null);
+let NameCache = Object.create(null);
+let RefCache = Object.create(null);
+
+function clearPrimitiveCaches() {
+  CmdCache = Object.create(null);
+  NameCache = Object.create(null);
+  RefCache = Object.create(null);
+}
+
+class Name {
+  constructor(name) {
+    this.name = name;
+  }
+
+  static get(name) {
+    // eslint-disable-next-line no-restricted-syntax
+    return (NameCache[name] ||= new Name(name));
+  }
+}
+
+class Cmd {
+  constructor(cmd) {
+    this.cmd = cmd;
+  }
+
+  static get(cmd) {
+    // eslint-disable-next-line no-restricted-syntax
+    return (CmdCache[cmd] ||= new Cmd(cmd));
+  }
+}
+
+const nonSerializable = function nonSerializableClosure() {
+  return nonSerializable; // Creating closure on some variable.
+};
+// 这个是数据字典吗，保存xref和trailerdict，用来定位数据的，通过dict来定位
+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) {
+    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 || !(value instanceof Dict)) {
+          // Ignore additional entries, if either:
+          //  - This is a "shallow" merge, where only the first element matters.
+          //  - The value is *not* a `Dict`, since other types cannot be merged.
+          continue;
+        }
+        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) {
+        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;
+  }
+
+  clone() {
+    const dict = new Dict(this.xref);
+    for (const key of this.getKeys()) {
+      dict.set(key, this.getRaw(key));
+    }
+    return dict;
+  }
+}
+
+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 fromString(str) {
+    const ref = RefCache[str];
+    if (ref) {
+      return ref;
+    }
+    const m = /^(\d+)R(\d*)$/.exec(str);
+    if (!m || m[1] === "0") {
+      return null;
+    }
+
+    // eslint-disable-next-line no-restricted-syntax
+    return (RefCache[str] = new Ref(
+      parseInt(m[1]),
+      !m[2] ? 0 : parseInt(m[2])
+    ));
+  }
+
+  static get(num, gen) {
+    const key = gen === 0 ? `${num}R` : `${num}R${gen}`;
+    // eslint-disable-next-line no-restricted-syntax
+    return (RefCache[key] ||= new Ref(num, gen));
+  }
+}
+
+// The reference is identified by number and generation.
+// This structure stores only one instance of the reference.
+class RefSet {
+  constructor(parent = null) {
+    this._set = new Set(parent?._set);
+  }
+
+  has(ref) {
+    return this._set.has(ref.toString());
+  }
+
+  put(ref) {
+    this._set.add(ref.toString());
+  }
+
+  remove(ref) {
+    this._set.delete(ref.toString());
+  }
+
+  [Symbol.iterator]() {
+    return this._set.values();
+  }
+
+  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));
+  }
+
+  [Symbol.iterator]() {
+    return this._map.values();
+  }
+
+  clear() {
+    this._map.clear();
+  }
+}
+
+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 isRefsEqual(v1, v2) {
+  return v1.num === v2.num && v1.gen === v2.gen;
+}
+
+export {
+  CIRCULAR_REF,
+  clearPrimitiveCaches,
+  Cmd,
+  Dict,
+  EOF,
+  isCmd,
+  isDict,
+  isName,
+  isRefsEqual,
+  Name,
+  Ref,
+  RefSet,
+  RefSetCache,
+};