@tachybase/plugin-print-template 0.23.8

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

@@ -0,0 +1,381 @@
+"use strict";
+const support = require("./support.js");
+const compressions = require("./compressions.js");
+const 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) {
+	let result = "";
+	for (let 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
+			const Builder =
+				window.BlobBuilder ||
+				window.WebKitBlobBuilder ||
+				window.MozBlobBuilder ||
+				window.MSBlobBuilder;
+			const 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 (let 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
+	let chunk = 65536;
+	const result = [],
+		len = array.length,
+		type = exports.getTypeOf(array);
+	let 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) {
+		let resultStr = "";
+		for (let 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 (let i = 0; i < arrayFrom.length; i++) {
+		arrayTo[i] = arrayFrom[i];
+	}
+	return arrayTo;
+}
+
+// a matrix containing functions to transform everything into everything.
+const transform = {};
+
+// string to ?
+transform.string = {
+	string: identity,
+	array(input) {
+		return stringToArrayLike(input, new Array(input.length));
+	},
+	arraybuffer(input) {
+		return transform.string.uint8array(input).buffer;
+	},
+	uint8array(input) {
+		return stringToArrayLike(input, new Uint8Array(input.length));
+	},
+	nodebuffer(input) {
+		return stringToArrayLike(input, nodeBuffer(input.length));
+	},
+};
+
+// array to ?
+transform.array = {
+	string: arrayLikeToString,
+	array: identity,
+	arraybuffer(input) {
+		return new Uint8Array(input).buffer;
+	},
+	uint8array(input) {
+		return new Uint8Array(input);
+	},
+	nodebuffer(input) {
+		return nodeBuffer(input);
+	},
+};
+
+// arraybuffer to ?
+transform.arraybuffer = {
+	string(input) {
+		return arrayLikeToString(new Uint8Array(input));
+	},
+	array(input) {
+		return arrayLikeToArrayLike(
+			new Uint8Array(input),
+			new Array(input.byteLength)
+		);
+	},
+	arraybuffer: identity,
+	uint8array(input) {
+		return new Uint8Array(input);
+	},
+	nodebuffer(input) {
+		return nodeBuffer(new Uint8Array(input));
+	},
+};
+
+// uint8array to ?
+transform.uint8array = {
+	string: arrayLikeToString,
+	array(input) {
+		return arrayLikeToArrayLike(input, new Array(input.length));
+	},
+	arraybuffer(input) {
+		return input.buffer;
+	},
+	uint8array: identity,
+	nodebuffer(input) {
+		return nodeBuffer(input);
+	},
+};
+
+// nodebuffer to ?
+transform.nodebuffer = {
+	string: arrayLikeToString,
+	array(input) {
+		return arrayLikeToArrayLike(input, new Array(input.length));
+	},
+	arraybuffer(input) {
+		return transform.nodebuffer.uint8array(input).buffer;
+	},
+	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);
+	const inputType = exports.getTypeOf(input);
+	const 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";
+	}
+	const 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) {
+	const 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) {
+	let 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 (const 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 () {
+	const result = {};
+	let 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/es6/zipEntries.js

@@ -0,0 +1,317 @@
+"use strict";
+const StringReader = require("./stringReader.js");
+const NodeBufferReader = require("./nodeBufferReader.js");
+const Uint8ArrayReader = require("./uint8ArrayReader.js");
+const ArrayReader = require("./arrayReader.js");
+const utils = require("./utils.js");
+const sig = require("./signature.js");
+const ZipEntry = require("./zipEntry.js");
+const 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(expectedSignature) {
+		const 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(askedIndex, expectedSignature) {
+		const currentIndex = this.reader.index;
+		this.reader.setIndex(askedIndex);
+		const signature = this.reader.readString(4);
+		const result = signature === expectedSignature;
+		this.reader.setIndex(currentIndex);
+		return result;
+	},
+	/**
+	 * Read the end of the central directory.
+	 */
+	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.
+		const zipComment = this.reader.readData(this.zipCommentLength);
+		const decodeParamType = support.uint8array ? "uint8array" : "array";
+		// To get consistent behavior with the generation part, we will assume that
+		// this is utf8 encoded unless specified otherwise.
+		const 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() {
+		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 = {};
+		const extraDataSize = this.zip64EndOfCentralSize - 44;
+		const index = 0;
+		let 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() {
+		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() {
+		let 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() {
+		let 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() {
+		let 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.
+			const 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);
+		const 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();
+		}
+
+		let 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;
+		}
+
+		const 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(data) {
+		const 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(data) {
+		this.prepareReader(data);
+		this.readEndOfCentral();
+		this.readCentralDir();
+		this.readLocalFiles();
+	},
+};
+// }}} end of ZipEntries
+module.exports = ZipEntries;