@tachybase/plugin-print-template 0.23.8

package/dist/node_modules/pizzip/js/utils.js

@@ -0,0 +1,353 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var support = require("./support.js");
+var compressions = require("./compressions.js");
+var nodeBuffer = require("./nodeBuffer.js");
+/**
+ * Convert a string to a "binary string" : a string containing only char codes between 0 and 255.
+ * @param {string} str the string to transform.
+ * @return {String} the binary string.
+ */
+exports.string2binary = function (str) {
+  var result = "";
+  for (var i = 0; i < str.length; i++) {
+    result += String.fromCharCode(str.charCodeAt(i) & 0xff);
+  }
+  return result;
+};
+exports.arrayBuffer2Blob = function (buffer, mimeType) {
+  exports.checkSupport("blob");
+  mimeType = mimeType || "application/zip";
+  try {
+    // Blob constructor
+    return new Blob([buffer], {
+      type: mimeType
+    });
+  } catch (e) {
+    try {
+      // deprecated, browser only, old way
+      var Builder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
+      var builder = new Builder();
+      builder.append(buffer);
+      return builder.getBlob(mimeType);
+    } catch (e) {
+      // well, fuck ?!
+      throw new Error("Bug : can't construct the Blob.");
+    }
+  }
+};
+/**
+ * The identity function.
+ * @param {Object} input the input.
+ * @return {Object} the same input.
+ */
+function identity(input) {
+  return input;
+}
+
+/**
+ * Fill in an array with a string.
+ * @param {String} str the string to use.
+ * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to fill in (will be mutated).
+ * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated array.
+ */
+function stringToArrayLike(str, array) {
+  for (var i = 0; i < str.length; ++i) {
+    array[i] = str.charCodeAt(i) & 0xff;
+  }
+  return array;
+}
+
+/**
+ * Transform an array-like object to a string.
+ * @param {Array|ArrayBuffer|Uint8Array|Buffer} array the array to transform.
+ * @return {String} the result.
+ */
+function arrayLikeToString(array) {
+  // Performances notes :
+  // --------------------
+  // String.fromCharCode.apply(null, array) is the fastest, see
+  // see http://jsperf.com/converting-a-uint8array-to-a-string/2
+  // but the stack is limited (and we can get huge arrays !).
+  //
+  // result += String.fromCharCode(array[i]); generate too many strings !
+  //
+  // This code is inspired by http://jsperf.com/arraybuffer-to-string-apply-performance/2
+  var chunk = 65536;
+  var result = [],
+    len = array.length,
+    type = exports.getTypeOf(array);
+  var k = 0,
+    canUseApply = true;
+  try {
+    switch (type) {
+      case "uint8array":
+        String.fromCharCode.apply(null, new Uint8Array(0));
+        break;
+      case "nodebuffer":
+        String.fromCharCode.apply(null, nodeBuffer(0));
+        break;
+    }
+  } catch (e) {
+    canUseApply = false;
+  }
+
+  // no apply : slow and painful algorithm
+  // default browser on android 4.*
+  if (!canUseApply) {
+    var resultStr = "";
+    for (var i = 0; i < array.length; i++) {
+      resultStr += String.fromCharCode(array[i]);
+    }
+    return resultStr;
+  }
+  while (k < len && chunk > 1) {
+    try {
+      if (type === "array" || type === "nodebuffer") {
+        result.push(String.fromCharCode.apply(null, array.slice(k, Math.min(k + chunk, len))));
+      } else {
+        result.push(String.fromCharCode.apply(null, array.subarray(k, Math.min(k + chunk, len))));
+      }
+      k += chunk;
+    } catch (e) {
+      chunk = Math.floor(chunk / 2);
+    }
+  }
+  return result.join("");
+}
+exports.applyFromCharCode = arrayLikeToString;
+
+/**
+ * Copy the data from an array-like to an other array-like.
+ * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayFrom the origin array.
+ * @param {Array|ArrayBuffer|Uint8Array|Buffer} arrayTo the destination array which will be mutated.
+ * @return {Array|ArrayBuffer|Uint8Array|Buffer} the updated destination array.
+ */
+function arrayLikeToArrayLike(arrayFrom, arrayTo) {
+  for (var i = 0; i < arrayFrom.length; i++) {
+    arrayTo[i] = arrayFrom[i];
+  }
+  return arrayTo;
+}
+
+// a matrix containing functions to transform everything into everything.
+var transform = {};
+
+// string to ?
+transform.string = {
+  string: identity,
+  array: function array(input) {
+    return stringToArrayLike(input, new Array(input.length));
+  },
+  arraybuffer: function arraybuffer(input) {
+    return transform.string.uint8array(input).buffer;
+  },
+  uint8array: function uint8array(input) {
+    return stringToArrayLike(input, new Uint8Array(input.length));
+  },
+  nodebuffer: function nodebuffer(input) {
+    return stringToArrayLike(input, nodeBuffer(input.length));
+  }
+};
+
+// array to ?
+transform.array = {
+  string: arrayLikeToString,
+  array: identity,
+  arraybuffer: function arraybuffer(input) {
+    return new Uint8Array(input).buffer;
+  },
+  uint8array: function uint8array(input) {
+    return new Uint8Array(input);
+  },
+  nodebuffer: function nodebuffer(input) {
+    return nodeBuffer(input);
+  }
+};
+
+// arraybuffer to ?
+transform.arraybuffer = {
+  string: function string(input) {
+    return arrayLikeToString(new Uint8Array(input));
+  },
+  array: function array(input) {
+    return arrayLikeToArrayLike(new Uint8Array(input), new Array(input.byteLength));
+  },
+  arraybuffer: identity,
+  uint8array: function uint8array(input) {
+    return new Uint8Array(input);
+  },
+  nodebuffer: function nodebuffer(input) {
+    return nodeBuffer(new Uint8Array(input));
+  }
+};
+
+// uint8array to ?
+transform.uint8array = {
+  string: arrayLikeToString,
+  array: function array(input) {
+    return arrayLikeToArrayLike(input, new Array(input.length));
+  },
+  arraybuffer: function arraybuffer(input) {
+    return input.buffer;
+  },
+  uint8array: identity,
+  nodebuffer: function nodebuffer(input) {
+    return nodeBuffer(input);
+  }
+};
+
+// nodebuffer to ?
+transform.nodebuffer = {
+  string: arrayLikeToString,
+  array: function array(input) {
+    return arrayLikeToArrayLike(input, new Array(input.length));
+  },
+  arraybuffer: function arraybuffer(input) {
+    return transform.nodebuffer.uint8array(input).buffer;
+  },
+  uint8array: function uint8array(input) {
+    return arrayLikeToArrayLike(input, new Uint8Array(input.length));
+  },
+  nodebuffer: identity
+};
+
+/**
+ * Transform an input into any type.
+ * The supported output type are : string, array, uint8array, arraybuffer, nodebuffer.
+ * If no output type is specified, the unmodified input will be returned.
+ * @param {String} outputType the output type.
+ * @param {String|Array|ArrayBuffer|Uint8Array|Buffer} input the input to convert.
+ * @throws {Error} an Error if the browser doesn't support the requested output type.
+ */
+exports.transformTo = function (outputType, input) {
+  if (!input) {
+    // undefined, null, etc
+    // an empty string won't harm.
+    input = "";
+  }
+  if (!outputType) {
+    return input;
+  }
+  exports.checkSupport(outputType);
+  var inputType = exports.getTypeOf(input);
+  var result = transform[inputType][outputType](input);
+  return result;
+};
+
+/**
+ * Return the type of the input.
+ * The type will be in a format valid for PizZip.utils.transformTo : string, array, uint8array, arraybuffer.
+ * @param {Object} input the input to identify.
+ * @return {String} the (lowercase) type of the input.
+ */
+exports.getTypeOf = function (input) {
+  if (input == null) {
+    return;
+  }
+  if (typeof input === "string") {
+    return "string";
+  }
+  var protoResult = Object.prototype.toString.call(input);
+  if (protoResult === "[object Array]") {
+    return "array";
+  }
+  if (support.nodebuffer && nodeBuffer.test(input)) {
+    return "nodebuffer";
+  }
+  if (support.uint8array && protoResult === "[object Uint8Array]") {
+    return "uint8array";
+  }
+  if (support.arraybuffer && protoResult === "[object ArrayBuffer]") {
+    return "arraybuffer";
+  }
+  if (protoResult === "[object Promise]") {
+    throw new Error("Cannot read data from a promise, you probably are running new PizZip(data) with a promise");
+  }
+  if (_typeof(input) === "object" && typeof input.file === "function") {
+    throw new Error("Cannot read data from a pizzip instance, you probably are running new PizZip(zip) with a zipinstance");
+  }
+  if (protoResult === "[object Date]") {
+    throw new Error("Cannot read data from a Date, you probably are running new PizZip(data) with a date");
+  }
+  if (_typeof(input) === "object" && input.crc32 == null) {
+    throw new Error("Unsupported data given to new PizZip(data) (object given)");
+  }
+};
+
+/**
+ * Throw an exception if the type is not supported.
+ * @param {String} type the type to check.
+ * @throws {Error} an Error if the browser doesn't support the requested type.
+ */
+exports.checkSupport = function (type) {
+  var supported = support[type.toLowerCase()];
+  if (!supported) {
+    throw new Error(type + " is not supported by this browser");
+  }
+};
+exports.MAX_VALUE_16BITS = 65535;
+exports.MAX_VALUE_32BITS = -1; // well, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF" is parsed as -1
+
+/**
+ * Prettify a string read as binary.
+ * @param {string} str the string to prettify.
+ * @return {string} a pretty string.
+ */
+exports.pretty = function (str) {
+  var res = "",
+    code,
+    i;
+  for (i = 0; i < (str || "").length; i++) {
+    code = str.charCodeAt(i);
+    res += "\\x" + (code < 16 ? "0" : "") + code.toString(16).toUpperCase();
+  }
+  return res;
+};
+
+/**
+ * Find a compression registered in PizZip.
+ * @param {string} compressionMethod the method magic to find.
+ * @return {Object|null} the PizZip compression object, null if none found.
+ */
+exports.findCompression = function (compressionMethod) {
+  for (var method in compressions) {
+    if (!compressions.hasOwnProperty(method)) {
+      continue;
+    }
+    if (compressions[method].magic === compressionMethod) {
+      return compressions[method];
+    }
+  }
+  return null;
+};
+/**
+ * Cross-window, cross-Node-context regular expression detection
+ * @param  {Object}  object Anything
+ * @return {Boolean}        true if the object is a regular expression,
+ * false otherwise
+ */
+exports.isRegExp = function (object) {
+  return Object.prototype.toString.call(object) === "[object RegExp]";
+};
+
+/**
+ * Merge the objects passed as parameters into a new one.
+ * @private
+ * @param {...Object} var_args All objects to merge.
+ * @return {Object} a new object with the data of the others.
+ */
+exports.extend = function () {
+  var result = {};
+  var i, attr;
+  for (i = 0; i < arguments.length; i++) {
+    // arguments is not enumerable in some browsers
+    for (attr in arguments[i]) {
+      if (arguments[i].hasOwnProperty(attr) && typeof result[attr] === "undefined") {
+        result[attr] = arguments[i][attr];
+      }
+    }
+  }
+  return result;
+};

package/dist/node_modules/pizzip/js/zipEntries.js

@@ -0,0 +1,266 @@
+"use strict";
+
+var StringReader = require("./stringReader.js");
+var NodeBufferReader = require("./nodeBufferReader.js");
+var Uint8ArrayReader = require("./uint8ArrayReader.js");
+var ArrayReader = require("./arrayReader.js");
+var utils = require("./utils.js");
+var sig = require("./signature.js");
+var ZipEntry = require("./zipEntry.js");
+var support = require("./support.js");
+//  class ZipEntries {{{
+/**
+ * All the entries in the zip file.
+ * @constructor
+ * @param {String|ArrayBuffer|Uint8Array} data the binary stream to load.
+ * @param {Object} loadOptions Options for loading the stream.
+ */
+function ZipEntries(data, loadOptions) {
+  this.files = [];
+  this.loadOptions = loadOptions;
+  if (data) {
+    this.load(data);
+  }
+}
+ZipEntries.prototype = {
+  /**
+   * Check that the reader is on the speficied signature.
+   * @param {string} expectedSignature the expected signature.
+   * @throws {Error} if it is an other signature.
+   */
+  checkSignature: function checkSignature(expectedSignature) {
+    var signature = this.reader.readString(4);
+    if (signature !== expectedSignature) {
+      throw new Error("Corrupted zip or bug : unexpected signature " + "(" + utils.pretty(signature) + ", expected " + utils.pretty(expectedSignature) + ")");
+    }
+  },
+  /**
+   * Check if the given signature is at the given index.
+   * @param {number} askedIndex the index to check.
+   * @param {string} expectedSignature the signature to expect.
+   * @return {boolean} true if the signature is here, false otherwise.
+   */
+  isSignature: function isSignature(askedIndex, expectedSignature) {
+    var currentIndex = this.reader.index;
+    this.reader.setIndex(askedIndex);
+    var signature = this.reader.readString(4);
+    var result = signature === expectedSignature;
+    this.reader.setIndex(currentIndex);
+    return result;
+  },
+  /**
+   * Read the end of the central directory.
+   */
+  readBlockEndOfCentral: function readBlockEndOfCentral() {
+    this.diskNumber = this.reader.readInt(2);
+    this.diskWithCentralDirStart = this.reader.readInt(2);
+    this.centralDirRecordsOnThisDisk = this.reader.readInt(2);
+    this.centralDirRecords = this.reader.readInt(2);
+    this.centralDirSize = this.reader.readInt(4);
+    this.centralDirOffset = this.reader.readInt(4);
+    this.zipCommentLength = this.reader.readInt(2);
+    // warning : the encoding depends of the system locale
+    // On a linux machine with LANG=en_US.utf8, this field is utf8 encoded.
+    // On a windows machine, this field is encoded with the localized windows code page.
+    var zipComment = this.reader.readData(this.zipCommentLength);
+    var decodeParamType = support.uint8array ? "uint8array" : "array";
+    // To get consistent behavior with the generation part, we will assume that
+    // this is utf8 encoded unless specified otherwise.
+    var decodeContent = utils.transformTo(decodeParamType, zipComment);
+    this.zipComment = this.loadOptions.decodeFileName(decodeContent);
+  },
+  /**
+   * Read the end of the Zip 64 central directory.
+   * Not merged with the method readEndOfCentral :
+   * The end of central can coexist with its Zip64 brother,
+   * I don't want to read the wrong number of bytes !
+   */
+  readBlockZip64EndOfCentral: function readBlockZip64EndOfCentral() {
+    this.zip64EndOfCentralSize = this.reader.readInt(8);
+    this.versionMadeBy = this.reader.readString(2);
+    this.versionNeeded = this.reader.readInt(2);
+    this.diskNumber = this.reader.readInt(4);
+    this.diskWithCentralDirStart = this.reader.readInt(4);
+    this.centralDirRecordsOnThisDisk = this.reader.readInt(8);
+    this.centralDirRecords = this.reader.readInt(8);
+    this.centralDirSize = this.reader.readInt(8);
+    this.centralDirOffset = this.reader.readInt(8);
+    this.zip64ExtensibleData = {};
+    var extraDataSize = this.zip64EndOfCentralSize - 44;
+    var index = 0;
+    var extraFieldId, extraFieldLength, extraFieldValue;
+    while (index < extraDataSize) {
+      extraFieldId = this.reader.readInt(2);
+      extraFieldLength = this.reader.readInt(4);
+      extraFieldValue = this.reader.readString(extraFieldLength);
+      this.zip64ExtensibleData[extraFieldId] = {
+        id: extraFieldId,
+        length: extraFieldLength,
+        value: extraFieldValue
+      };
+    }
+  },
+  /**
+   * Read the end of the Zip 64 central directory locator.
+   */
+  readBlockZip64EndOfCentralLocator: function readBlockZip64EndOfCentralLocator() {
+    this.diskWithZip64CentralDirStart = this.reader.readInt(4);
+    this.relativeOffsetEndOfZip64CentralDir = this.reader.readInt(8);
+    this.disksCount = this.reader.readInt(4);
+    if (this.disksCount > 1) {
+      throw new Error("Multi-volumes zip are not supported");
+    }
+  },
+  /**
+   * Read the local files, based on the offset read in the central part.
+   */
+  readLocalFiles: function readLocalFiles() {
+    var i, file;
+    for (i = 0; i < this.files.length; i++) {
+      file = this.files[i];
+      this.reader.setIndex(file.localHeaderOffset);
+      this.checkSignature(sig.LOCAL_FILE_HEADER);
+      file.readLocalPart(this.reader);
+      file.handleUTF8();
+      file.processAttributes();
+    }
+  },
+  /**
+   * Read the central directory.
+   */
+  readCentralDir: function readCentralDir() {
+    var file;
+    this.reader.setIndex(this.centralDirOffset);
+    while (this.reader.readString(4) === sig.CENTRAL_FILE_HEADER) {
+      file = new ZipEntry({
+        zip64: this.zip64
+      }, this.loadOptions);
+      file.readCentralPart(this.reader);
+      this.files.push(file);
+    }
+    if (this.centralDirRecords !== this.files.length) {
+      if (this.centralDirRecords !== 0 && this.files.length === 0) {
+        // We expected some records but couldn't find ANY.
+        // This is really suspicious, as if something went wrong.
+        throw new Error("Corrupted zip or bug: expected " + this.centralDirRecords + " records in central dir, got " + this.files.length);
+      } else {
+        // We found some records but not all.
+        // Something is wrong but we got something for the user: no error here.
+        // console.warn("expected", this.centralDirRecords, "records in central dir, got", this.files.length);
+      }
+    }
+  },
+  /**
+   * Read the end of central directory.
+   */
+  readEndOfCentral: function readEndOfCentral() {
+    var offset = this.reader.lastIndexOfSignature(sig.CENTRAL_DIRECTORY_END);
+    if (offset < 0) {
+      // Check if the content is a truncated zip or complete garbage.
+      // A "LOCAL_FILE_HEADER" is not required at the beginning (auto
+      // extractible zip for example) but it can give a good hint.
+      // If an ajax request was used without responseType, we will also
+      // get unreadable data.
+      var isGarbage = !this.isSignature(0, sig.LOCAL_FILE_HEADER);
+      if (isGarbage) {
+        throw new Error("Can't find end of central directory : is this a zip file ?");
+      } else {
+        throw new Error("Corrupted zip : can't find end of central directory");
+      }
+    }
+    this.reader.setIndex(offset);
+    var endOfCentralDirOffset = offset;
+    this.checkSignature(sig.CENTRAL_DIRECTORY_END);
+    this.readBlockEndOfCentral();
+
+    /* extract from the zip spec :
+              4)  If one of the fields in the end of central directory
+                  record is too small to hold required data, the field
+                  should be set to -1 (0xFFFF or 0xFFFFFFFF) and the
+                  ZIP64 format record should be created.
+              5)  The end of central directory record and the
+                  Zip64 end of central directory locator record must
+                  reside on the same disk when splitting or spanning
+                  an archive.
+           */
+    if (this.diskNumber === utils.MAX_VALUE_16BITS || this.diskWithCentralDirStart === utils.MAX_VALUE_16BITS || this.centralDirRecordsOnThisDisk === utils.MAX_VALUE_16BITS || this.centralDirRecords === utils.MAX_VALUE_16BITS || this.centralDirSize === utils.MAX_VALUE_32BITS || this.centralDirOffset === utils.MAX_VALUE_32BITS) {
+      this.zip64 = true;
+
+      /*
+               Warning : the zip64 extension is supported, but ONLY if the 64bits integer read from
+               the zip file can fit into a 32bits integer. This cannot be solved : Javascript represents
+               all numbers as 64-bit double precision IEEE 754 floating point numbers.
+               So, we have 53bits for integers and bitwise operations treat everything as 32bits.
+               see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Operators/Bitwise_Operators
+               and http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf section 8.5
+               */
+
+      // should look for a zip64 EOCD locator
+      offset = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
+      if (offset < 0) {
+        throw new Error("Corrupted zip : can't find the ZIP64 end of central directory locator");
+      }
+      this.reader.setIndex(offset);
+      this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_LOCATOR);
+      this.readBlockZip64EndOfCentralLocator();
+
+      // now the zip64 EOCD record
+      if (!this.isSignature(this.relativeOffsetEndOfZip64CentralDir, sig.ZIP64_CENTRAL_DIRECTORY_END)) {
+        // console.warn("ZIP64 end of central directory not where expected.");
+        this.relativeOffsetEndOfZip64CentralDir = this.reader.lastIndexOfSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
+        if (this.relativeOffsetEndOfZip64CentralDir < 0) {
+          throw new Error("Corrupted zip : can't find the ZIP64 end of central directory");
+        }
+      }
+      this.reader.setIndex(this.relativeOffsetEndOfZip64CentralDir);
+      this.checkSignature(sig.ZIP64_CENTRAL_DIRECTORY_END);
+      this.readBlockZip64EndOfCentral();
+    }
+    var expectedEndOfCentralDirOffset = this.centralDirOffset + this.centralDirSize;
+    if (this.zip64) {
+      expectedEndOfCentralDirOffset += 20; // end of central dir 64 locator
+      expectedEndOfCentralDirOffset += 12 /* should not include the leading 12 bytes */ + this.zip64EndOfCentralSize;
+    }
+    var extraBytes = endOfCentralDirOffset - expectedEndOfCentralDirOffset;
+    if (extraBytes > 0) {
+      // console.warn(extraBytes, "extra bytes at beginning or within zipfile");
+      if (this.isSignature(endOfCentralDirOffset, sig.CENTRAL_FILE_HEADER)) {
+        // The offsets seem wrong, but we have something at the specified offset.
+        // So… we keep it.
+      } else {
+        // the offset is wrong, update the "zero" of the reader
+        // this happens if data has been prepended (crx files for example)
+        this.reader.zero = extraBytes;
+      }
+    } else if (extraBytes < 0) {
+      throw new Error("Corrupted zip: missing " + Math.abs(extraBytes) + " bytes.");
+    }
+  },
+  prepareReader: function prepareReader(data) {
+    var type = utils.getTypeOf(data);
+    utils.checkSupport(type);
+    if (type === "string" && !support.uint8array) {
+      this.reader = new StringReader(data, this.loadOptions.optimizedBinaryString);
+    } else if (type === "nodebuffer") {
+      this.reader = new NodeBufferReader(data);
+    } else if (support.uint8array) {
+      this.reader = new Uint8ArrayReader(utils.transformTo("uint8array", data));
+    } else if (support.array) {
+      this.reader = new ArrayReader(utils.transformTo("array", data));
+    } else {
+      throw new Error("Unexpected error: unsupported type '" + type + "'");
+    }
+  },
+  /**
+   * Read a zip file and create ZipEntries.
+   * @param {String|ArrayBuffer|Uint8Array|Buffer} data the binary string representing a zip file.
+   */
+  load: function load(data) {
+    this.prepareReader(data);
+    this.readEndOfCentral();
+    this.readCentralDir();
+    this.readLocalFiles();
+  }
+};
+// }}} end of ZipEntries
+module.exports = ZipEntries;