zhui-plus 1.0.0 → 1.0.10

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

@@ -0,0 +1,296 @@
+/* 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 {
+  CalibriBoldFactors,
+  CalibriBoldItalicFactors,
+  CalibriBoldItalicMetrics,
+  CalibriBoldMetrics,
+  CalibriItalicFactors,
+  CalibriItalicMetrics,
+  CalibriRegularFactors,
+  CalibriRegularMetrics,
+} from "./calibri_factors.js";
+import { Dict, Name } from "./primitives.js";
+import {
+  HelveticaBoldFactors,
+  HelveticaBoldItalicFactors,
+  HelveticaBoldItalicMetrics,
+  HelveticaBoldMetrics,
+  HelveticaItalicFactors,
+  HelveticaItalicMetrics,
+  HelveticaRegularFactors,
+  HelveticaRegularMetrics,
+} from "./helvetica_factors.js";
+import {
+  LiberationSansBoldItalicMapping,
+  LiberationSansBoldItalicWidths,
+  LiberationSansBoldMapping,
+  LiberationSansBoldWidths,
+  LiberationSansItalicMapping,
+  LiberationSansItalicWidths,
+  LiberationSansRegularMapping,
+  LiberationSansRegularWidths,
+} from "./liberationsans_widths.js";
+import {
+  MyriadProBoldFactors,
+  MyriadProBoldItalicFactors,
+  MyriadProBoldItalicMetrics,
+  MyriadProBoldMetrics,
+  MyriadProItalicFactors,
+  MyriadProItalicMetrics,
+  MyriadProRegularFactors,
+  MyriadProRegularMetrics,
+} from "./myriadpro_factors.js";
+import {
+  SegoeuiBoldFactors,
+  SegoeuiBoldItalicFactors,
+  SegoeuiBoldItalicMetrics,
+  SegoeuiBoldMetrics,
+  SegoeuiItalicFactors,
+  SegoeuiItalicMetrics,
+  SegoeuiRegularFactors,
+  SegoeuiRegularMetrics,
+} from "./segoeui_factors.js";
+import { getLookupTableFactory } from "./core_utils.js";
+import { normalizeFontName } from "./fonts_utils.js";
+
+const getXFAFontMap = getLookupTableFactory(function (t) {
+  t["MyriadPro-Regular"] = t["PdfJS-Fallback-Regular"] = {
+    name: "LiberationSans-Regular",
+    factors: MyriadProRegularFactors,
+    baseWidths: LiberationSansRegularWidths,
+    baseMapping: LiberationSansRegularMapping,
+    metrics: MyriadProRegularMetrics,
+  };
+  t["MyriadPro-Bold"] = t["PdfJS-Fallback-Bold"] = {
+    name: "LiberationSans-Bold",
+    factors: MyriadProBoldFactors,
+    baseWidths: LiberationSansBoldWidths,
+    baseMapping: LiberationSansBoldMapping,
+    metrics: MyriadProBoldMetrics,
+  };
+  t["MyriadPro-It"] =
+    t["MyriadPro-Italic"] =
+    t["PdfJS-Fallback-Italic"] =
+      {
+        name: "LiberationSans-Italic",
+        factors: MyriadProItalicFactors,
+        baseWidths: LiberationSansItalicWidths,
+        baseMapping: LiberationSansItalicMapping,
+        metrics: MyriadProItalicMetrics,
+      };
+  t["MyriadPro-BoldIt"] =
+    t["MyriadPro-BoldItalic"] =
+    t["PdfJS-Fallback-BoldItalic"] =
+      {
+        name: "LiberationSans-BoldItalic",
+        factors: MyriadProBoldItalicFactors,
+        baseWidths: LiberationSansBoldItalicWidths,
+        baseMapping: LiberationSansBoldItalicMapping,
+        metrics: MyriadProBoldItalicMetrics,
+      };
+  t.ArialMT =
+    t.Arial =
+    t["Arial-Regular"] =
+      {
+        name: "LiberationSans-Regular",
+        baseWidths: LiberationSansRegularWidths,
+        baseMapping: LiberationSansRegularMapping,
+      };
+  t["Arial-BoldMT"] = t["Arial-Bold"] = {
+    name: "LiberationSans-Bold",
+    baseWidths: LiberationSansBoldWidths,
+    baseMapping: LiberationSansBoldMapping,
+  };
+  t["Arial-ItalicMT"] = t["Arial-Italic"] = {
+    name: "LiberationSans-Italic",
+    baseWidths: LiberationSansItalicWidths,
+    baseMapping: LiberationSansItalicMapping,
+  };
+  t["Arial-BoldItalicMT"] = t["Arial-BoldItalic"] = {
+    name: "LiberationSans-BoldItalic",
+    baseWidths: LiberationSansBoldItalicWidths,
+    baseMapping: LiberationSansBoldItalicMapping,
+  };
+  t["Calibri-Regular"] = {
+    name: "LiberationSans-Regular",
+    factors: CalibriRegularFactors,
+    baseWidths: LiberationSansRegularWidths,
+    baseMapping: LiberationSansRegularMapping,
+    metrics: CalibriRegularMetrics,
+  };
+  t["Calibri-Bold"] = {
+    name: "LiberationSans-Bold",
+    factors: CalibriBoldFactors,
+    baseWidths: LiberationSansBoldWidths,
+    baseMapping: LiberationSansBoldMapping,
+    metrics: CalibriBoldMetrics,
+  };
+  t["Calibri-Italic"] = {
+    name: "LiberationSans-Italic",
+    factors: CalibriItalicFactors,
+    baseWidths: LiberationSansItalicWidths,
+    baseMapping: LiberationSansItalicMapping,
+    metrics: CalibriItalicMetrics,
+  };
+  t["Calibri-BoldItalic"] = {
+    name: "LiberationSans-BoldItalic",
+    factors: CalibriBoldItalicFactors,
+    baseWidths: LiberationSansBoldItalicWidths,
+    baseMapping: LiberationSansBoldItalicMapping,
+    metrics: CalibriBoldItalicMetrics,
+  };
+  t["Segoeui-Regular"] = {
+    name: "LiberationSans-Regular",
+    factors: SegoeuiRegularFactors,
+    baseWidths: LiberationSansRegularWidths,
+    baseMapping: LiberationSansRegularMapping,
+    metrics: SegoeuiRegularMetrics,
+  };
+  t["Segoeui-Bold"] = {
+    name: "LiberationSans-Bold",
+    factors: SegoeuiBoldFactors,
+    baseWidths: LiberationSansBoldWidths,
+    baseMapping: LiberationSansBoldMapping,
+    metrics: SegoeuiBoldMetrics,
+  };
+  t["Segoeui-Italic"] = {
+    name: "LiberationSans-Italic",
+    factors: SegoeuiItalicFactors,
+    baseWidths: LiberationSansItalicWidths,
+    baseMapping: LiberationSansItalicMapping,
+    metrics: SegoeuiItalicMetrics,
+  };
+  t["Segoeui-BoldItalic"] = {
+    name: "LiberationSans-BoldItalic",
+    factors: SegoeuiBoldItalicFactors,
+    baseWidths: LiberationSansBoldItalicWidths,
+    baseMapping: LiberationSansBoldItalicMapping,
+    metrics: SegoeuiBoldItalicMetrics,
+  };
+  t["Helvetica-Regular"] = t.Helvetica = {
+    name: "LiberationSans-Regular",
+    factors: HelveticaRegularFactors,
+    baseWidths: LiberationSansRegularWidths,
+    baseMapping: LiberationSansRegularMapping,
+    metrics: HelveticaRegularMetrics,
+  };
+  t["Helvetica-Bold"] = {
+    name: "LiberationSans-Bold",
+    factors: HelveticaBoldFactors,
+    baseWidths: LiberationSansBoldWidths,
+    baseMapping: LiberationSansBoldMapping,
+    metrics: HelveticaBoldMetrics,
+  };
+  t["Helvetica-Italic"] = {
+    name: "LiberationSans-Italic",
+    factors: HelveticaItalicFactors,
+    baseWidths: LiberationSansItalicWidths,
+    baseMapping: LiberationSansItalicMapping,
+    metrics: HelveticaItalicMetrics,
+  };
+  t["Helvetica-BoldItalic"] = {
+    name: "LiberationSans-BoldItalic",
+    factors: HelveticaBoldItalicFactors,
+    baseWidths: LiberationSansBoldItalicWidths,
+    baseMapping: LiberationSansBoldItalicMapping,
+    metrics: HelveticaBoldItalicMetrics,
+  };
+});
+
+function getXfaFontName(name) {
+  const fontName = normalizeFontName(name);
+  const fontMap = getXFAFontMap();
+  return fontMap[fontName];
+}
+
+function getXfaFontWidths(name) {
+  const info = getXfaFontName(name);
+  if (!info) {
+    return null;
+  }
+
+  const { baseWidths, baseMapping, factors } = info;
+  const rescaledBaseWidths = !factors
+    ? baseWidths
+    : baseWidths.map((w, i) => w * factors[i]);
+
+  let currentCode = -2;
+  let currentArray;
+
+  // Widths array for composite font is:
+  // CharCode1 [10, 20, 30] ...
+  // which means:
+  //   - CharCode1 has a width equal to 10
+  //   - CharCode1+1 has a width equal to 20
+  //   - CharCode1+2 has a width equal to 30
+  //
+  // The baseMapping array contains a map for glyph index to unicode.
+  // So from baseMapping we'll get sorted unicodes and their positions
+  // (i.e. glyph indices) and then we put widths in an array for the
+  // the consecutive unicodes.
+  const newWidths = [];
+  for (const [unicode, glyphIndex] of baseMapping
+    .map(
+      (charUnicode, index) => [
+        charUnicode,
+        index,
+      ] /* collect unicode and glyph index */
+    )
+    .sort(
+      ([unicode1], [unicode2]) =>
+        unicode1 - unicode2 /* order by unicode only */
+    )) {
+    if (unicode === -1) {
+      continue;
+    }
+
+    if (unicode === currentCode + 1) {
+      currentArray.push(rescaledBaseWidths[glyphIndex]);
+      currentCode += 1;
+    } else {
+      currentCode = unicode;
+      currentArray = [rescaledBaseWidths[glyphIndex]];
+      newWidths.push(unicode, currentArray);
+    }
+  }
+
+  return newWidths;
+}
+
+function getXfaFontDict(name) {
+  const widths = getXfaFontWidths(name);
+  const dict = new Dict(null);
+  dict.set("BaseFont", Name.get(name));
+  dict.set("Type", Name.get("Font"));
+  dict.set("Subtype", Name.get("CIDFontType2"));
+  dict.set("Encoding", Name.get("Identity-H"));
+  dict.set("CIDToGIDMap", Name.get("Identity"));
+  dict.set("W", widths);
+  dict.set("FirstChar", widths[0]);
+  dict.set("LastChar", widths.at(-2) + widths.at(-1).length - 1);
+  const descriptor = new Dict(null);
+  dict.set("FontDescriptor", descriptor);
+  const systemInfo = new Dict(null);
+  systemInfo.set("Ordering", "Identity");
+  systemInfo.set("Registry", "Adobe");
+  systemInfo.set("Supplement", 0);
+  dict.set("CIDSystemInfo", systemInfo);
+
+  return dict;
+}
+
+export { getXfaFontDict, getXfaFontName };

package/packages/components/fileViewer/src/liteofd/jbig2/arithmetic_decoder.js

@@ -0,0 +1,183 @@
+/* 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.
+ */
+/* eslint no-var: error */
+
+// Table C-2
+const QeTable = [
+  { qe: 0x5601, nmps: 1, nlps: 1, switchFlag: 1 },
+  { qe: 0x3401, nmps: 2, nlps: 6, switchFlag: 0 },
+  { qe: 0x1801, nmps: 3, nlps: 9, switchFlag: 0 },
+  { qe: 0x0ac1, nmps: 4, nlps: 12, switchFlag: 0 },
+  { qe: 0x0521, nmps: 5, nlps: 29, switchFlag: 0 },
+  { qe: 0x0221, nmps: 38, nlps: 33, switchFlag: 0 },
+  { qe: 0x5601, nmps: 7, nlps: 6, switchFlag: 1 },
+  { qe: 0x5401, nmps: 8, nlps: 14, switchFlag: 0 },
+  { qe: 0x4801, nmps: 9, nlps: 14, switchFlag: 0 },
+  { qe: 0x3801, nmps: 10, nlps: 14, switchFlag: 0 },
+  { qe: 0x3001, nmps: 11, nlps: 17, switchFlag: 0 },
+  { qe: 0x2401, nmps: 12, nlps: 18, switchFlag: 0 },
+  { qe: 0x1c01, nmps: 13, nlps: 20, switchFlag: 0 },
+  { qe: 0x1601, nmps: 29, nlps: 21, switchFlag: 0 },
+  { qe: 0x5601, nmps: 15, nlps: 14, switchFlag: 1 },
+  { qe: 0x5401, nmps: 16, nlps: 14, switchFlag: 0 },
+  { qe: 0x5101, nmps: 17, nlps: 15, switchFlag: 0 },
+  { qe: 0x4801, nmps: 18, nlps: 16, switchFlag: 0 },
+  { qe: 0x3801, nmps: 19, nlps: 17, switchFlag: 0 },
+  { qe: 0x3401, nmps: 20, nlps: 18, switchFlag: 0 },
+  { qe: 0x3001, nmps: 21, nlps: 19, switchFlag: 0 },
+  { qe: 0x2801, nmps: 22, nlps: 19, switchFlag: 0 },
+  { qe: 0x2401, nmps: 23, nlps: 20, switchFlag: 0 },
+  { qe: 0x2201, nmps: 24, nlps: 21, switchFlag: 0 },
+  { qe: 0x1c01, nmps: 25, nlps: 22, switchFlag: 0 },
+  { qe: 0x1801, nmps: 26, nlps: 23, switchFlag: 0 },
+  { qe: 0x1601, nmps: 27, nlps: 24, switchFlag: 0 },
+  { qe: 0x1401, nmps: 28, nlps: 25, switchFlag: 0 },
+  { qe: 0x1201, nmps: 29, nlps: 26, switchFlag: 0 },
+  { qe: 0x1101, nmps: 30, nlps: 27, switchFlag: 0 },
+  { qe: 0x0ac1, nmps: 31, nlps: 28, switchFlag: 0 },
+  { qe: 0x09c1, nmps: 32, nlps: 29, switchFlag: 0 },
+  { qe: 0x08a1, nmps: 33, nlps: 30, switchFlag: 0 },
+  { qe: 0x0521, nmps: 34, nlps: 31, switchFlag: 0 },
+  { qe: 0x0441, nmps: 35, nlps: 32, switchFlag: 0 },
+  { qe: 0x02a1, nmps: 36, nlps: 33, switchFlag: 0 },
+  { qe: 0x0221, nmps: 37, nlps: 34, switchFlag: 0 },
+  { qe: 0x0141, nmps: 38, nlps: 35, switchFlag: 0 },
+  { qe: 0x0111, nmps: 39, nlps: 36, switchFlag: 0 },
+  { qe: 0x0085, nmps: 40, nlps: 37, switchFlag: 0 },
+  { qe: 0x0049, nmps: 41, nlps: 38, switchFlag: 0 },
+  { qe: 0x0025, nmps: 42, nlps: 39, switchFlag: 0 },
+  { qe: 0x0015, nmps: 43, nlps: 40, switchFlag: 0 },
+  { qe: 0x0009, nmps: 44, nlps: 41, switchFlag: 0 },
+  { qe: 0x0005, nmps: 45, nlps: 42, switchFlag: 0 },
+  { qe: 0x0001, nmps: 45, nlps: 43, switchFlag: 0 },
+  { qe: 0x5601, nmps: 46, nlps: 46, switchFlag: 0 },
+];
+
+/**
+ * This class implements the QM Coder decoding as defined in
+ *   JPEG 2000 Part I Final Committee Draft Version 1.0
+ *   Annex C.3 Arithmetic decoding procedure
+ * available at http://www.jpeg.org/public/fcd15444-1.pdf
+ *
+ * The arithmetic decoder is used in conjunction with context models to decode
+ * JPEG2000 and JBIG2 streams.
+ */
+class ArithmeticDecoder {
+  // C.3.5 Initialisation of the decoder (INITDEC)
+  constructor(data, start, end) {
+    this.data = data;
+    this.bp = start;
+    this.dataEnd = end;
+
+    this.chigh = data[start];
+    this.clow = 0;
+
+    this.byteIn();
+
+    this.chigh = ((this.chigh << 7) & 0xffff) | ((this.clow >> 9) & 0x7f);
+    this.clow = (this.clow << 7) & 0xffff;
+    this.ct -= 7;
+    this.a = 0x8000;
+  }
+
+  // C.3.4 Compressed data input (BYTEIN)
+  byteIn() {
+    const data = this.data;
+    let bp = this.bp;
+
+    if (data[bp] === 0xff) {
+      if (data[bp + 1] > 0x8f) {
+        this.clow += 0xff00;
+        this.ct = 8;
+      } else {
+        bp++;
+        this.clow += data[bp] << 9;
+        this.ct = 7;
+        this.bp = bp;
+      }
+    } else {
+      bp++;
+      this.clow += bp < this.dataEnd ? data[bp] << 8 : 0xff00;
+      this.ct = 8;
+      this.bp = bp;
+    }
+    if (this.clow > 0xffff) {
+      this.chigh += this.clow >> 16;
+      this.clow &= 0xffff;
+    }
+  }
+
+  // C.3.2 Decoding a decision (DECODE)
+  readBit(contexts, pos) {
+    // Contexts are packed into 1 byte:
+    // highest 7 bits carry cx.index, lowest bit carries cx.mps
+    let cx_index = contexts[pos] >> 1,
+      cx_mps = contexts[pos] & 1;
+    const qeTableIcx = QeTable[cx_index];
+    const qeIcx = qeTableIcx.qe;
+    let d;
+    let a = this.a - qeIcx;
+
+    if (this.chigh < qeIcx) {
+      // exchangeLps
+      if (a < qeIcx) {
+        a = qeIcx;
+        d = cx_mps;
+        cx_index = qeTableIcx.nmps;
+      } else {
+        a = qeIcx;
+        d = 1 ^ cx_mps;
+        if (qeTableIcx.switchFlag === 1) {
+          cx_mps = d;
+        }
+        cx_index = qeTableIcx.nlps;
+      }
+    } else {
+      this.chigh -= qeIcx;
+      if ((a & 0x8000) !== 0) {
+        this.a = a;
+        return cx_mps;
+      }
+      // exchangeMps
+      if (a < qeIcx) {
+        d = 1 ^ cx_mps;
+        if (qeTableIcx.switchFlag === 1) {
+          cx_mps = d;
+        }
+        cx_index = qeTableIcx.nlps;
+      } else {
+        d = cx_mps;
+        cx_index = qeTableIcx.nmps;
+      }
+    }
+    // C.3.3 renormD;
+    do {
+      if (this.ct === 0) {
+        this.byteIn();
+      }
+
+      a <<= 1;
+      this.chigh = ((this.chigh << 1) & 0xffff) | ((this.clow >> 15) & 1);
+      this.clow = (this.clow << 1) & 0xffff;
+      this.ct--;
+    } while ((a & 0x8000) === 0);
+    this.a = a;
+
+    contexts[pos] = (cx_index << 1) | cx_mps;
+    return d;
+  }
+}
+
+export { ArithmeticDecoder };