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

package/src/core/xfa_fonts.js

@@ -1,208 +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 {
-  CalibriBoldFactors,
-  CalibriBoldItalicFactors,
-  CalibriBoldItalicLineHeight,
-  CalibriBoldLineHeight,
-  CalibriItalicFactors,
-  CalibriItalicLineHeight,
-  CalibriRegularFactors,
-  CalibriRegularLineHeight,
-} from "./calibri_factors.js";
-import {
-  HelveticaBoldFactors,
-  HelveticaBoldItalicFactors,
-  HelveticaBoldItalicLineHeight,
-  HelveticaBoldLineHeight,
-  HelveticaItalicFactors,
-  HelveticaItalicLineHeight,
-  HelveticaRegularFactors,
-  HelveticaRegularLineHeight,
-} from "./helvetica_factors.js";
-import {
-  LiberationSansBoldItalicWidths,
-  LiberationSansBoldWidths,
-  LiberationSansItalicWidths,
-  LiberationSansRegularWidths,
-} from "./liberationsans_widths.js";
-import {
-  MyriadProBoldFactors,
-  MyriadProBoldItalicFactors,
-  MyriadProBoldItalicLineHeight,
-  MyriadProBoldLineHeight,
-  MyriadProItalicFactors,
-  MyriadProItalicLineHeight,
-  MyriadProRegularFactors,
-  MyriadProRegularLineHeight,
-} from "./myriadpro_factors.js";
-import {
-  SegoeuiBoldFactors,
-  SegoeuiBoldItalicFactors,
-  SegoeuiBoldItalicLineHeight,
-  SegoeuiBoldLineHeight,
-  SegoeuiItalicFactors,
-  SegoeuiItalicLineHeight,
-  SegoeuiRegularFactors,
-  SegoeuiRegularLineHeight,
-} 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,
-    lineHeight: MyriadProRegularLineHeight,
-  };
-  t["MyriadPro-Bold"] = t["PdfJS-Fallback-Bold"] = {
-    name: "LiberationSans-Bold",
-    factors: MyriadProBoldFactors,
-    baseWidths: LiberationSansBoldWidths,
-    lineHeight: MyriadProBoldLineHeight,
-  };
-  t["MyriadPro-It"] =
-    t["MyriadPro-Italic"] =
-    t["PdfJS-Fallback-Italic"] =
-      {
-        name: "LiberationSans-Italic",
-        factors: MyriadProItalicFactors,
-        baseWidths: LiberationSansItalicWidths,
-        lineHeight: MyriadProItalicLineHeight,
-      };
-  t["MyriadPro-BoldIt"] =
-    t["MyriadPro-BoldItalic"] =
-    t["PdfJS-Fallback-BoldItalic"] =
-      {
-        name: "LiberationSans-BoldItalic",
-        factors: MyriadProBoldItalicFactors,
-        baseWidths: LiberationSansBoldItalicWidths,
-        lineHeight: MyriadProBoldItalicLineHeight,
-      };
-  t.ArialMT =
-    t.Arial =
-    t["Arial-Regular"] =
-      {
-        name: "LiberationSans-Regular",
-        baseWidths: LiberationSansRegularWidths,
-      };
-  t["Arial-BoldMT"] = t["Arial-Bold"] = {
-    name: "LiberationSans-Bold",
-    baseWidths: LiberationSansBoldWidths,
-  };
-  t["Arial-ItalicMT"] = t["Arial-Italic"] = {
-    name: "LiberationSans-Italic",
-    baseWidths: LiberationSansItalicWidths,
-  };
-  t["Arial-BoldItalicMT"] = t["Arial-BoldItalic"] = {
-    name: "LiberationSans-BoldItalic",
-    baseWidths: LiberationSansBoldItalicWidths,
-  };
-  t["Calibri-Regular"] = {
-    name: "LiberationSans-Regular",
-    factors: CalibriRegularFactors,
-    baseWidths: LiberationSansRegularWidths,
-    lineHeight: CalibriRegularLineHeight,
-  };
-  t["Calibri-Bold"] = {
-    name: "LiberationSans-Bold",
-    factors: CalibriBoldFactors,
-    baseWidths: LiberationSansBoldWidths,
-    lineHeight: CalibriBoldLineHeight,
-  };
-  t["Calibri-Italic"] = {
-    name: "LiberationSans-Italic",
-    factors: CalibriItalicFactors,
-    baseWidths: LiberationSansItalicWidths,
-    lineHeight: CalibriItalicLineHeight,
-  };
-  t["Calibri-BoldItalic"] = {
-    name: "LiberationSans-BoldItalic",
-    factors: CalibriBoldItalicFactors,
-    baseWidths: LiberationSansBoldItalicWidths,
-    lineHeight: CalibriBoldItalicLineHeight,
-  };
-  t["Segoeui-Regular"] = {
-    name: "LiberationSans-Regular",
-    factors: SegoeuiRegularFactors,
-    baseWidths: LiberationSansRegularWidths,
-    lineHeight: SegoeuiRegularLineHeight,
-  };
-  t["Segoeui-Bold"] = {
-    name: "LiberationSans-Bold",
-    factors: SegoeuiBoldFactors,
-    baseWidths: LiberationSansBoldWidths,
-    lineHeight: SegoeuiBoldLineHeight,
-  };
-  t["Segoeui-Italic"] = {
-    name: "LiberationSans-Italic",
-    factors: SegoeuiItalicFactors,
-    baseWidths: LiberationSansItalicWidths,
-    lineHeight: SegoeuiItalicLineHeight,
-  };
-  t["Segoeui-BoldItalic"] = {
-    name: "LiberationSans-BoldItalic",
-    factors: SegoeuiBoldItalicFactors,
-    baseWidths: LiberationSansBoldItalicWidths,
-    lineHeight: SegoeuiBoldItalicLineHeight,
-  };
-  t["Helvetica-Regular"] = t.Helvetica = {
-    name: "LiberationSans-Regular",
-    factors: HelveticaRegularFactors,
-    baseWidths: LiberationSansRegularWidths,
-    lineHeight: HelveticaRegularLineHeight,
-  };
-  t["Helvetica-Bold"] = {
-    name: "LiberationSans-Bold",
-    factors: HelveticaBoldFactors,
-    baseWidths: LiberationSansBoldWidths,
-    lineHeight: HelveticaBoldLineHeight,
-  };
-  t["Helvetica-Italic"] = {
-    name: "LiberationSans-Italic",
-    factors: HelveticaItalicFactors,
-    baseWidths: LiberationSansItalicWidths,
-    lineHeight: HelveticaItalicLineHeight,
-  };
-  t["Helvetica-BoldItalic"] = {
-    name: "LiberationSans-BoldItalic",
-    factors: HelveticaBoldItalicFactors,
-    baseWidths: LiberationSansBoldItalicWidths,
-    lineHeight: HelveticaBoldItalicLineHeight,
-  };
-});
-
-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, factors } = info;
-  if (!factors) {
-    return baseWidths;
-  }
-  return baseWidths.map((w, i) => w * factors[i]);
-}
-
-export { getXfaFontName, getXfaFontWidths };

package/src/core/xml_parser.js

@@ -1,507 +0,0 @@
-/* Copyright 2018 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.
- */
-
-// The code for XMLParserBase copied from
-// https://github.com/mozilla/shumway/blob/16451d8836fa85f4b16eeda8b4bda2fa9e2b22b0/src/avm2/natives/xml.ts
-
-import { encodeToXmlString } from "./core_utils.js";
-
-const XMLParserErrorCode = {
-  NoError: 0,
-  EndOfDocument: -1,
-  UnterminatedCdat: -2,
-  UnterminatedXmlDeclaration: -3,
-  UnterminatedDoctypeDeclaration: -4,
-  UnterminatedComment: -5,
-  MalformedElement: -6,
-  OutOfMemory: -7,
-  UnterminatedAttributeValue: -8,
-  UnterminatedElement: -9,
-  ElementNeverBegun: -10,
-};
-
-function isWhitespace(s, index) {
-  const ch = s[index];
-  return ch === " " || ch === "\n" || ch === "\r" || ch === "\t";
-}
-
-function isWhitespaceString(s) {
-  for (let i = 0, ii = s.length; i < ii; i++) {
-    if (!isWhitespace(s, i)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-class XMLParserBase {
-  _resolveEntities(s) {
-    return s.replace(/&([^;]+);/g, (all, entity) => {
-      if (entity.substring(0, 2) === "#x") {
-        return String.fromCodePoint(parseInt(entity.substring(2), 16));
-      } else if (entity.substring(0, 1) === "#") {
-        return String.fromCodePoint(parseInt(entity.substring(1), 10));
-      }
-      switch (entity) {
-        case "lt":
-          return "<";
-        case "gt":
-          return ">";
-        case "amp":
-          return "&";
-        case "quot":
-          return '"';
-        case "apos":
-          return "'";
-      }
-      return this.onResolveEntity(entity);
-    });
-  }
-
-  _parseContent(s, start) {
-    const attributes = [];
-    let pos = start;
-
-    function skipWs() {
-      while (pos < s.length && isWhitespace(s, pos)) {
-        ++pos;
-      }
-    }
-
-    while (
-      pos < s.length &&
-      !isWhitespace(s, pos) &&
-      s[pos] !== ">" &&
-      s[pos] !== "/"
-    ) {
-      ++pos;
-    }
-    const name = s.substring(start, pos);
-    skipWs();
-    while (
-      pos < s.length &&
-      s[pos] !== ">" &&
-      s[pos] !== "/" &&
-      s[pos] !== "?"
-    ) {
-      skipWs();
-      let attrName = "",
-        attrValue = "";
-      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== "=") {
-        attrName += s[pos];
-        ++pos;
-      }
-      skipWs();
-      if (s[pos] !== "=") {
-        return null;
-      }
-      ++pos;
-      skipWs();
-      const attrEndChar = s[pos];
-      if (attrEndChar !== '"' && attrEndChar !== "'") {
-        return null;
-      }
-      const attrEndIndex = s.indexOf(attrEndChar, ++pos);
-      if (attrEndIndex < 0) {
-        return null;
-      }
-      attrValue = s.substring(pos, attrEndIndex);
-      attributes.push({
-        name: attrName,
-        value: this._resolveEntities(attrValue),
-      });
-      pos = attrEndIndex + 1;
-      skipWs();
-    }
-    return {
-      name,
-      attributes,
-      parsed: pos - start,
-    };
-  }
-
-  _parseProcessingInstruction(s, start) {
-    let pos = start;
-
-    function skipWs() {
-      while (pos < s.length && isWhitespace(s, pos)) {
-        ++pos;
-      }
-    }
-
-    while (
-      pos < s.length &&
-      !isWhitespace(s, pos) &&
-      s[pos] !== ">" &&
-      s[pos] !== "?" &&
-      s[pos] !== "/"
-    ) {
-      ++pos;
-    }
-    const name = s.substring(start, pos);
-    skipWs();
-    const attrStart = pos;
-    while (pos < s.length && (s[pos] !== "?" || s[pos + 1] !== ">")) {
-      ++pos;
-    }
-    const value = s.substring(attrStart, pos);
-    return {
-      name,
-      value,
-      parsed: pos - start,
-    };
-  }
-
-  parseXml(s) {
-    let i = 0;
-    while (i < s.length) {
-      const ch = s[i];
-      let j = i;
-      if (ch === "<") {
-        ++j;
-        const ch2 = s[j];
-        let q;
-        switch (ch2) {
-          case "/":
-            ++j;
-            q = s.indexOf(">", j);
-            if (q < 0) {
-              this.onError(XMLParserErrorCode.UnterminatedElement);
-              return;
-            }
-            this.onEndElement(s.substring(j, q));
-            j = q + 1;
-            break;
-          case "?":
-            ++j;
-            const pi = this._parseProcessingInstruction(s, j);
-            if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== "?>") {
-              this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration);
-              return;
-            }
-            this.onPi(pi.name, pi.value);
-            j += pi.parsed + 2;
-            break;
-          case "!":
-            if (s.substring(j + 1, j + 3) === "--") {
-              q = s.indexOf("-->", j + 3);
-              if (q < 0) {
-                this.onError(XMLParserErrorCode.UnterminatedComment);
-                return;
-              }
-              this.onComment(s.substring(j + 3, q));
-              j = q + 3;
-            } else if (s.substring(j + 1, j + 8) === "[CDATA[") {
-              q = s.indexOf("]]>", j + 8);
-              if (q < 0) {
-                this.onError(XMLParserErrorCode.UnterminatedCdat);
-                return;
-              }
-              this.onCdata(s.substring(j + 8, q));
-              j = q + 3;
-            } else if (s.substring(j + 1, j + 8) === "DOCTYPE") {
-              const q2 = s.indexOf("[", j + 8);
-              let complexDoctype = false;
-              q = s.indexOf(">", j + 8);
-              if (q < 0) {
-                this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
-                return;
-              }
-              if (q2 > 0 && q > q2) {
-                q = s.indexOf("]>", j + 8);
-                if (q < 0) {
-                  this.onError(
-                    XMLParserErrorCode.UnterminatedDoctypeDeclaration
-                  );
-                  return;
-                }
-                complexDoctype = true;
-              }
-              const doctypeContent = s.substring(
-                j + 8,
-                q + (complexDoctype ? 1 : 0)
-              );
-              this.onDoctype(doctypeContent);
-              j = q + (complexDoctype ? 2 : 1);
-            } else {
-              this.onError(XMLParserErrorCode.MalformedElement);
-              return;
-            }
-            break;
-          default:
-            const content = this._parseContent(s, j);
-            if (content === null) {
-              this.onError(XMLParserErrorCode.MalformedElement);
-              return;
-            }
-            let isClosed = false;
-            if (
-              s.substring(j + content.parsed, j + content.parsed + 2) === "/>"
-            ) {
-              isClosed = true;
-            } else if (
-              s.substring(j + content.parsed, j + content.parsed + 1) !== ">"
-            ) {
-              this.onError(XMLParserErrorCode.UnterminatedElement);
-              return;
-            }
-            this.onBeginElement(content.name, content.attributes, isClosed);
-            j += content.parsed + (isClosed ? 2 : 1);
-            break;
-        }
-      } else {
-        while (j < s.length && s[j] !== "<") {
-          j++;
-        }
-        const text = s.substring(i, j);
-        this.onText(this._resolveEntities(text));
-      }
-      i = j;
-    }
-  }
-
-  onResolveEntity(name) {
-    return `&${name};`;
-  }
-
-  onPi(name, value) {}
-
-  onComment(text) {}
-
-  onCdata(text) {}
-
-  onDoctype(doctypeContent) {}
-
-  onText(text) {}
-
-  onBeginElement(name, attributes, isEmpty) {}
-
-  onEndElement(name) {}
-
-  onError(code) {}
-}
-
-class SimpleDOMNode {
-  constructor(nodeName, nodeValue) {
-    this.nodeName = nodeName;
-    this.nodeValue = nodeValue;
-
-    Object.defineProperty(this, "parentNode", { value: null, writable: true });
-  }
-
-  get firstChild() {
-    return this.childNodes && this.childNodes[0];
-  }
-
-  get nextSibling() {
-    const childNodes = this.parentNode.childNodes;
-    if (!childNodes) {
-      return undefined;
-    }
-    const index = childNodes.indexOf(this);
-    if (index === -1) {
-      return undefined;
-    }
-    return childNodes[index + 1];
-  }
-
-  get textContent() {
-    if (!this.childNodes) {
-      return this.nodeValue || "";
-    }
-    return this.childNodes
-      .map(function (child) {
-        return child.textContent;
-      })
-      .join("");
-  }
-
-  hasChildNodes() {
-    return this.childNodes && this.childNodes.length > 0;
-  }
-
-  /**
-   * Search a node in the tree with the given path
-   * foo.bar[nnn], i.e. find the nnn-th node named
-   * bar under a node named foo.
-   *
-   * @param {Array} paths - an array of objects as
-   * returned by {parseXFAPath}.
-   * @param {number} pos - the current position in
-   * the paths array.
-   * @returns {SimpleDOMNode} The node corresponding
-   * to the path or null if not found.
-   */
-  searchNode(paths, pos) {
-    if (pos >= paths.length) {
-      return this;
-    }
-
-    const component = paths[pos];
-    const stack = [];
-    let node = this;
-
-    while (true) {
-      if (component.name === node.nodeName) {
-        if (component.pos === 0) {
-          const res = node.searchNode(paths, pos + 1);
-          if (res !== null) {
-            return res;
-          }
-        } else if (stack.length === 0) {
-          return null;
-        } else {
-          const [parent] = stack.pop();
-          let siblingPos = 0;
-          for (const child of parent.childNodes) {
-            if (component.name === child.nodeName) {
-              if (siblingPos === component.pos) {
-                return child.searchNode(paths, pos + 1);
-              }
-              siblingPos++;
-            }
-          }
-          // We didn't find the correct sibling
-          // so just return the first found node
-          return node.searchNode(paths, pos + 1);
-        }
-      }
-
-      if (node.childNodes && node.childNodes.length !== 0) {
-        stack.push([node, 0]);
-        node = node.childNodes[0];
-      } else if (stack.length === 0) {
-        return null;
-      } else {
-        while (stack.length !== 0) {
-          const [parent, currentPos] = stack.pop();
-          const newPos = currentPos + 1;
-          if (newPos < parent.childNodes.length) {
-            stack.push([parent, newPos]);
-            node = parent.childNodes[newPos];
-            break;
-          }
-        }
-        if (stack.length === 0) {
-          return null;
-        }
-      }
-    }
-  }
-
-  dump(buffer) {
-    if (this.nodeName === "#text") {
-      buffer.push(encodeToXmlString(this.nodeValue));
-      return;
-    }
-
-    buffer.push(`<${this.nodeName}`);
-    if (this.attributes) {
-      for (const attribute of this.attributes) {
-        buffer.push(
-          ` ${attribute.name}="${encodeToXmlString(attribute.value)}"`
-        );
-      }
-    }
-    if (this.hasChildNodes()) {
-      buffer.push(">");
-      for (const child of this.childNodes) {
-        child.dump(buffer);
-      }
-      buffer.push(`</${this.nodeName}>`);
-    } else if (this.nodeValue) {
-      buffer.push(`>${encodeToXmlString(this.nodeValue)}</${this.nodeName}>`);
-    } else {
-      buffer.push("/>");
-    }
-  }
-}
-
-class SimpleXMLParser extends XMLParserBase {
-  constructor({ hasAttributes = false, lowerCaseName = false }) {
-    super();
-    this._currentFragment = null;
-    this._stack = null;
-    this._errorCode = XMLParserErrorCode.NoError;
-    this._hasAttributes = hasAttributes;
-    this._lowerCaseName = lowerCaseName;
-  }
-
-  parseFromString(data) {
-    this._currentFragment = [];
-    this._stack = [];
-    this._errorCode = XMLParserErrorCode.NoError;
-
-    this.parseXml(data);
-
-    if (this._errorCode !== XMLParserErrorCode.NoError) {
-      return undefined; // return undefined on error
-    }
-
-    // We should only have one root.
-    const [documentElement] = this._currentFragment;
-    if (!documentElement) {
-      return undefined; // Return undefined if no root was found.
-    }
-    return { documentElement };
-  }
-
-  onText(text) {
-    if (isWhitespaceString(text)) {
-      return;
-    }
-    const node = new SimpleDOMNode("#text", text);
-    this._currentFragment.push(node);
-  }
-
-  onCdata(text) {
-    const node = new SimpleDOMNode("#text", text);
-    this._currentFragment.push(node);
-  }
-
-  onBeginElement(name, attributes, isEmpty) {
-    if (this._lowerCaseName) {
-      name = name.toLowerCase();
-    }
-    const node = new SimpleDOMNode(name);
-    node.childNodes = [];
-    if (this._hasAttributes) {
-      node.attributes = attributes;
-    }
-    this._currentFragment.push(node);
-    if (isEmpty) {
-      return;
-    }
-    this._stack.push(this._currentFragment);
-    this._currentFragment = node.childNodes;
-  }
-
-  onEndElement(name) {
-    this._currentFragment = this._stack.pop() || [];
-    const lastElement = this._currentFragment[this._currentFragment.length - 1];
-    if (!lastElement) {
-      return;
-    }
-    for (let i = 0, ii = lastElement.childNodes.length; i < ii; i++) {
-      lastElement.childNodes[i].parentNode = lastElement;
-    }
-  }
-
-  onError(code) {
-    this._errorCode = code;
-  }
-}
-
-export { SimpleDOMNode, SimpleXMLParser, XMLParserBase, XMLParserErrorCode };