@opendesign-plus/components 0.0.1-rc.10 → 0.0.1-rc.101

package/dist/treeshaking/_virtual/crypto-js/enc-base64url.js.mjs

@@ -0,0 +1,97 @@
+import { __commonJSMin } from "../_rolldown/runtime.mjs";
+import { require_core } from "./core.js.mjs";
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/enc-base64url.js
+var require_enc_base64url = /* @__PURE__ */ __commonJSMin(((exports, module, this$1) => {
+	(function(root, factory) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core());
+		else if (typeof define === "function" && define.amd) define(["./core"], factory);
+		else factory(root.CryptoJS);
+	})(this$1, function(CryptoJS) {
+		(function() {
+			var C = CryptoJS;
+			var WordArray = C.lib.WordArray;
+			var C_enc = C.enc;
+			C_enc.Base64url = {
+				/**
+				* Converts a word array to a Base64url string.
+				*
+				* @param {WordArray} wordArray The word array.
+				*
+				* @param {boolean} urlSafe Whether to use url safe
+				*
+				* @return {string} The Base64url string.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var base64String = CryptoJS.enc.Base64url.stringify(wordArray);
+				*/
+				stringify: function(wordArray, urlSafe) {
+					if (urlSafe === void 0) urlSafe = true;
+					var words = wordArray.words;
+					var sigBytes = wordArray.sigBytes;
+					var map = urlSafe ? this._safe_map : this._map;
+					wordArray.clamp();
+					var base64Chars = [];
+					for (var i = 0; i < sigBytes; i += 3) {
+						var byte1 = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+						var byte2 = words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
+						var byte3 = words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
+						var triplet = byte1 << 16 | byte2 << 8 | byte3;
+						for (var j = 0; j < 4 && i + j * .75 < sigBytes; j++) base64Chars.push(map.charAt(triplet >>> 6 * (3 - j) & 63));
+					}
+					var paddingChar = map.charAt(64);
+					if (paddingChar) while (base64Chars.length % 4) base64Chars.push(paddingChar);
+					return base64Chars.join("");
+				},
+				/**
+				* Converts a Base64url string to a word array.
+				*
+				* @param {string} base64Str The Base64url string.
+				*
+				* @param {boolean} urlSafe Whether to use url safe
+				*
+				* @return {WordArray} The word array.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var wordArray = CryptoJS.enc.Base64url.parse(base64String);
+				*/
+				parse: function(base64Str, urlSafe) {
+					if (urlSafe === void 0) urlSafe = true;
+					var base64StrLength = base64Str.length;
+					var map = urlSafe ? this._safe_map : this._map;
+					var reverseMap = this._reverseMap;
+					if (!reverseMap) {
+						reverseMap = this._reverseMap = [];
+						for (var j = 0; j < map.length; j++) reverseMap[map.charCodeAt(j)] = j;
+					}
+					var paddingChar = map.charAt(64);
+					if (paddingChar) {
+						var paddingIndex = base64Str.indexOf(paddingChar);
+						if (paddingIndex !== -1) base64StrLength = paddingIndex;
+					}
+					return parseLoop(base64Str, base64StrLength, reverseMap);
+				},
+				_map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+				_safe_map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+			};
+			function parseLoop(base64Str, base64StrLength, reverseMap) {
+				var words = [];
+				var nBytes = 0;
+				for (var i = 0; i < base64StrLength; i++) if (i % 4) {
+					var bitsCombined = reverseMap[base64Str.charCodeAt(i - 1)] << i % 4 * 2 | reverseMap[base64Str.charCodeAt(i)] >>> 6 - i % 4 * 2;
+					words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
+					nBytes++;
+				}
+				return WordArray.create(words, nBytes);
+			}
+		})();
+		return CryptoJS.enc.Base64url;
+	});
+}));
+export default require_enc_base64url();
+export { require_enc_base64url };

package/dist/treeshaking/_virtual/crypto-js/enc-utf16.js.mjs

@@ -0,0 +1,113 @@
+import { __commonJSMin } from "../_rolldown/runtime.mjs";
+import { require_core } from "./core.js.mjs";
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/enc-utf16.js
+var require_enc_utf16 = /* @__PURE__ */ __commonJSMin(((exports, module, this$1) => {
+	(function(root, factory) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core());
+		else if (typeof define === "function" && define.amd) define(["./core"], factory);
+		else factory(root.CryptoJS);
+	})(this$1, function(CryptoJS) {
+		(function() {
+			var C = CryptoJS;
+			var WordArray = C.lib.WordArray;
+			var C_enc = C.enc;
+			C_enc.Utf16 = C_enc.Utf16BE = {
+				/**
+				* Converts a word array to a UTF-16 BE string.
+				*
+				* @param {WordArray} wordArray The word array.
+				*
+				* @return {string} The UTF-16 BE string.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var utf16String = CryptoJS.enc.Utf16.stringify(wordArray);
+				*/
+				stringify: function(wordArray) {
+					var words = wordArray.words;
+					var sigBytes = wordArray.sigBytes;
+					var utf16Chars = [];
+					for (var i = 0; i < sigBytes; i += 2) {
+						var codePoint = words[i >>> 2] >>> 16 - i % 4 * 8 & 65535;
+						utf16Chars.push(String.fromCharCode(codePoint));
+					}
+					return utf16Chars.join("");
+				},
+				/**
+				* Converts a UTF-16 BE string to a word array.
+				*
+				* @param {string} utf16Str The UTF-16 BE string.
+				*
+				* @return {WordArray} The word array.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var wordArray = CryptoJS.enc.Utf16.parse(utf16String);
+				*/
+				parse: function(utf16Str) {
+					var utf16StrLength = utf16Str.length;
+					var words = [];
+					for (var i = 0; i < utf16StrLength; i++) words[i >>> 1] |= utf16Str.charCodeAt(i) << 16 - i % 2 * 16;
+					return WordArray.create(words, utf16StrLength * 2);
+				}
+			};
+			/**
+			* UTF-16 LE encoding strategy.
+			*/
+			C_enc.Utf16LE = {
+				/**
+				* Converts a word array to a UTF-16 LE string.
+				*
+				* @param {WordArray} wordArray The word array.
+				*
+				* @return {string} The UTF-16 LE string.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray);
+				*/
+				stringify: function(wordArray) {
+					var words = wordArray.words;
+					var sigBytes = wordArray.sigBytes;
+					var utf16Chars = [];
+					for (var i = 0; i < sigBytes; i += 2) {
+						var codePoint = swapEndian(words[i >>> 2] >>> 16 - i % 4 * 8 & 65535);
+						utf16Chars.push(String.fromCharCode(codePoint));
+					}
+					return utf16Chars.join("");
+				},
+				/**
+				* Converts a UTF-16 LE string to a word array.
+				*
+				* @param {string} utf16Str The UTF-16 LE string.
+				*
+				* @return {WordArray} The word array.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str);
+				*/
+				parse: function(utf16Str) {
+					var utf16StrLength = utf16Str.length;
+					var words = [];
+					for (var i = 0; i < utf16StrLength; i++) words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << 16 - i % 2 * 16);
+					return WordArray.create(words, utf16StrLength * 2);
+				}
+			};
+			function swapEndian(word) {
+				return word << 8 & 4278255360 | word >>> 8 & 16711935;
+			}
+		})();
+		return CryptoJS.enc.Utf16;
+	});
+}));
+export default require_enc_utf16();
+export { require_enc_utf16 };

package/dist/treeshaking/_virtual/crypto-js/evpkdf.js.mjs

@@ -0,0 +1,113 @@
+import { __commonJSMin } from "../_rolldown/runtime.mjs";
+import { require_core } from "./core.js.mjs";
+import { require_sha1 } from "./sha1.js.mjs";
+import { require_hmac } from "./hmac.js.mjs";
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/evpkdf.js
+var require_evpkdf = /* @__PURE__ */ __commonJSMin(((exports, module, this$1) => {
+	(function(root, factory, undef) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core(), require_sha1(), require_hmac());
+		else if (typeof define === "function" && define.amd) define([
+			"./core",
+			"./sha1",
+			"./hmac"
+		], factory);
+		else factory(root.CryptoJS);
+	})(this$1, function(CryptoJS) {
+		(function() {
+			var C = CryptoJS;
+			var C_lib = C.lib;
+			var Base = C_lib.Base;
+			var WordArray = C_lib.WordArray;
+			var C_algo = C.algo;
+			var MD5 = C_algo.MD5;
+			/**
+			* This key derivation function is meant to conform with EVP_BytesToKey.
+			* www.openssl.org/docs/crypto/EVP_BytesToKey.html
+			*/
+			var EvpKDF = C_algo.EvpKDF = Base.extend({
+				/**
+				* Configuration options.
+				*
+				* @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
+				* @property {Hasher} hasher The hash algorithm to use. Default: MD5
+				* @property {number} iterations The number of iterations to perform. Default: 1
+				*/
+				cfg: Base.extend({
+					keySize: 4,
+					hasher: MD5,
+					iterations: 1
+				}),
+				/**
+				* Initializes a newly created key derivation function.
+				*
+				* @param {Object} cfg (Optional) The configuration options to use for the derivation.
+				*
+				* @example
+				*
+				*     var kdf = CryptoJS.algo.EvpKDF.create();
+				*     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
+				*     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
+				*/
+				init: function(cfg) {
+					this.cfg = this.cfg.extend(cfg);
+				},
+				/**
+				* Derives a key from a password.
+				*
+				* @param {WordArray|string} password The password.
+				* @param {WordArray|string} salt A salt.
+				*
+				* @return {WordArray} The derived key.
+				*
+				* @example
+				*
+				*     var key = kdf.compute(password, salt);
+				*/
+				compute: function(password, salt) {
+					var block;
+					var cfg = this.cfg;
+					var hasher = cfg.hasher.create();
+					var derivedKey = WordArray.create();
+					var derivedKeyWords = derivedKey.words;
+					var keySize = cfg.keySize;
+					var iterations = cfg.iterations;
+					while (derivedKeyWords.length < keySize) {
+						if (block) hasher.update(block);
+						block = hasher.update(password).finalize(salt);
+						hasher.reset();
+						for (var i = 1; i < iterations; i++) {
+							block = hasher.finalize(block);
+							hasher.reset();
+						}
+						derivedKey.concat(block);
+					}
+					derivedKey.sigBytes = keySize * 4;
+					return derivedKey;
+				}
+			});
+			/**
+			* Derives a key from a password.
+			*
+			* @param {WordArray|string} password The password.
+			* @param {WordArray|string} salt A salt.
+			* @param {Object} cfg (Optional) The configuration options to use for this computation.
+			*
+			* @return {WordArray} The derived key.
+			*
+			* @static
+			*
+			* @example
+			*
+			*     var key = CryptoJS.EvpKDF(password, salt);
+			*     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });
+			*     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });
+			*/
+			C.EvpKDF = function(password, salt, cfg) {
+				return EvpKDF.create(cfg).compute(password, salt);
+			};
+		})();
+		return CryptoJS.EvpKDF;
+	});
+}));
+export default require_evpkdf();
+export { require_evpkdf };

package/dist/treeshaking/_virtual/crypto-js/format-hex.js.mjs

@@ -0,0 +1,56 @@
+import { __commonJSMin } from "../_rolldown/runtime.mjs";
+import { require_core } from "./core.js.mjs";
+import { require_cipher_core } from "./cipher-core.js.mjs";
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/format-hex.js
+var require_format_hex = /* @__PURE__ */ __commonJSMin(((exports, module, this$1) => {
+	(function(root, factory, undef) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core(), require_cipher_core());
+		else if (typeof define === "function" && define.amd) define(["./core", "./cipher-core"], factory);
+		else factory(root.CryptoJS);
+	})(this$1, function(CryptoJS) {
+		(function(undefined) {
+			var C = CryptoJS;
+			var CipherParams = C.lib.CipherParams;
+			var Hex = C.enc.Hex;
+			var C_format = C.format;
+			C_format.Hex = {
+				/**
+				* Converts the ciphertext of a cipher params object to a hexadecimally encoded string.
+				*
+				* @param {CipherParams} cipherParams The cipher params object.
+				*
+				* @return {string} The hexadecimally encoded string.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var hexString = CryptoJS.format.Hex.stringify(cipherParams);
+				*/
+				stringify: function(cipherParams) {
+					return cipherParams.ciphertext.toString(Hex);
+				},
+				/**
+				* Converts a hexadecimally encoded ciphertext string to a cipher params object.
+				*
+				* @param {string} input The hexadecimally encoded string.
+				*
+				* @return {CipherParams} The cipher params object.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var cipherParams = CryptoJS.format.Hex.parse(hexString);
+				*/
+				parse: function(input) {
+					var ciphertext = Hex.parse(input);
+					return CipherParams.create({ ciphertext });
+				}
+			};
+		})();
+		return CryptoJS.format.Hex;
+	});
+}));
+export default require_format_hex();
+export { require_format_hex };

package/dist/treeshaking/_virtual/crypto-js/hmac.js.mjs

@@ -0,0 +1,97 @@
+import { __commonJSMin } from "../_rolldown/runtime.mjs";
+import { require_core } from "./core.js.mjs";
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/hmac.js
+var require_hmac = /* @__PURE__ */ __commonJSMin(((exports, module, this$1) => {
+	(function(root, factory) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core());
+		else if (typeof define === "function" && define.amd) define(["./core"], factory);
+		else factory(root.CryptoJS);
+	})(this$1, function(CryptoJS) {
+		(function() {
+			var C = CryptoJS;
+			var Base = C.lib.Base;
+			var Utf8 = C.enc.Utf8;
+			var C_algo = C.algo;
+			C_algo.HMAC = Base.extend({
+				/**
+				* Initializes a newly created HMAC.
+				*
+				* @param {Hasher} hasher The hash algorithm to use.
+				* @param {WordArray|string} key The secret key.
+				*
+				* @example
+				*
+				*     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
+				*/
+				init: function(hasher, key) {
+					hasher = this._hasher = new hasher.init();
+					if (typeof key == "string") key = Utf8.parse(key);
+					var hasherBlockSize = hasher.blockSize;
+					var hasherBlockSizeBytes = hasherBlockSize * 4;
+					if (key.sigBytes > hasherBlockSizeBytes) key = hasher.finalize(key);
+					key.clamp();
+					var oKey = this._oKey = key.clone();
+					var iKey = this._iKey = key.clone();
+					var oKeyWords = oKey.words;
+					var iKeyWords = iKey.words;
+					for (var i = 0; i < hasherBlockSize; i++) {
+						oKeyWords[i] ^= 1549556828;
+						iKeyWords[i] ^= 909522486;
+					}
+					oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
+					this.reset();
+				},
+				/**
+				* Resets this HMAC to its initial state.
+				*
+				* @example
+				*
+				*     hmacHasher.reset();
+				*/
+				reset: function() {
+					var hasher = this._hasher;
+					hasher.reset();
+					hasher.update(this._iKey);
+				},
+				/**
+				* Updates this HMAC with a message.
+				*
+				* @param {WordArray|string} messageUpdate The message to append.
+				*
+				* @return {HMAC} This HMAC instance.
+				*
+				* @example
+				*
+				*     hmacHasher.update('message');
+				*     hmacHasher.update(wordArray);
+				*/
+				update: function(messageUpdate) {
+					this._hasher.update(messageUpdate);
+					return this;
+				},
+				/**
+				* Finalizes the HMAC computation.
+				* Note that the finalize operation is effectively a destructive, read-once operation.
+				*
+				* @param {WordArray|string} messageUpdate (Optional) A final message update.
+				*
+				* @return {WordArray} The HMAC.
+				*
+				* @example
+				*
+				*     var hmac = hmacHasher.finalize();
+				*     var hmac = hmacHasher.finalize('message');
+				*     var hmac = hmacHasher.finalize(wordArray);
+				*/
+				finalize: function(messageUpdate) {
+					var hasher = this._hasher;
+					var innerHash = hasher.finalize(messageUpdate);
+					hasher.reset();
+					return hasher.finalize(this._oKey.clone().concat(innerHash));
+				}
+			});
+		})();
+	});
+}));
+export default require_hmac();
+export { require_hmac };

package/dist/treeshaking/_virtual/crypto-js/index.js.mjs

@@ -0,0 +1,84 @@
+import { __commonJSMin } from "../_rolldown/runtime.mjs";
+import { require_core } from "./core.js.mjs";
+import { require_x64_core } from "./x64-core.js.mjs";
+import { require_lib_typedarrays } from "./lib-typedarrays.js.mjs";
+import { require_enc_utf16 } from "./enc-utf16.js.mjs";
+import { require_enc_base64 } from "./enc-base64.js.mjs";
+import { require_enc_base64url } from "./enc-base64url.js.mjs";
+import { require_md5 } from "./md5.js.mjs";
+import { require_sha1 } from "./sha1.js.mjs";
+import { require_sha256 } from "./sha256.js.mjs";
+import { require_sha224 } from "./sha224.js.mjs";
+import { require_sha512 } from "./sha512.js.mjs";
+import { require_sha384 } from "./sha384.js.mjs";
+import { require_sha3 } from "./sha3.js.mjs";
+import { require_ripemd160 } from "./ripemd160.js.mjs";
+import { require_hmac } from "./hmac.js.mjs";
+import { require_pbkdf2 } from "./pbkdf2.js.mjs";
+import { require_evpkdf } from "./evpkdf.js.mjs";
+import { require_cipher_core } from "./cipher-core.js.mjs";
+import { require_mode_cfb } from "./mode-cfb.js.mjs";
+import { require_mode_ctr } from "./mode-ctr.js.mjs";
+import { require_mode_ctr_gladman } from "./mode-ctr-gladman.js.mjs";
+import { require_mode_ofb } from "./mode-ofb.js.mjs";
+import { require_mode_ecb } from "./mode-ecb.js.mjs";
+import { require_pad_ansix923 } from "./pad-ansix923.js.mjs";
+import { require_pad_iso10126 } from "./pad-iso10126.js.mjs";
+import { require_pad_iso97971 } from "./pad-iso97971.js.mjs";
+import { require_pad_zeropadding } from "./pad-zeropadding.js.mjs";
+import { require_pad_nopadding } from "./pad-nopadding.js.mjs";
+import { require_format_hex } from "./format-hex.js.mjs";
+import { require_aes } from "./aes.js.mjs";
+import { require_tripledes } from "./tripledes.js.mjs";
+import { require_rc4 } from "./rc4.js.mjs";
+import { require_rabbit } from "./rabbit.js.mjs";
+import { require_rabbit_legacy } from "./rabbit-legacy.js.mjs";
+import { require_blowfish } from "./blowfish.js.mjs";
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/index.js
+var require_crypto_js = /* @__PURE__ */ __commonJSMin(((exports, module, this$1) => {
+	(function(root, factory, undef) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core(), require_x64_core(), require_lib_typedarrays(), require_enc_utf16(), require_enc_base64(), require_enc_base64url(), require_md5(), require_sha1(), require_sha256(), require_sha224(), require_sha512(), require_sha384(), require_sha3(), require_ripemd160(), require_hmac(), require_pbkdf2(), require_evpkdf(), require_cipher_core(), require_mode_cfb(), require_mode_ctr(), require_mode_ctr_gladman(), require_mode_ofb(), require_mode_ecb(), require_pad_ansix923(), require_pad_iso10126(), require_pad_iso97971(), require_pad_zeropadding(), require_pad_nopadding(), require_format_hex(), require_aes(), require_tripledes(), require_rc4(), require_rabbit(), require_rabbit_legacy(), require_blowfish());
+		else if (typeof define === "function" && define.amd) define([
+			"./core",
+			"./x64-core",
+			"./lib-typedarrays",
+			"./enc-utf16",
+			"./enc-base64",
+			"./enc-base64url",
+			"./md5",
+			"./sha1",
+			"./sha256",
+			"./sha224",
+			"./sha512",
+			"./sha384",
+			"./sha3",
+			"./ripemd160",
+			"./hmac",
+			"./pbkdf2",
+			"./evpkdf",
+			"./cipher-core",
+			"./mode-cfb",
+			"./mode-ctr",
+			"./mode-ctr-gladman",
+			"./mode-ofb",
+			"./mode-ecb",
+			"./pad-ansix923",
+			"./pad-iso10126",
+			"./pad-iso97971",
+			"./pad-zeropadding",
+			"./pad-nopadding",
+			"./format-hex",
+			"./aes",
+			"./tripledes",
+			"./rc4",
+			"./rabbit",
+			"./rabbit-legacy",
+			"./blowfish"
+		], factory);
+		else root.CryptoJS = factory(root.CryptoJS);
+	})(this$1, function(CryptoJS) {
+		return CryptoJS;
+	});
+}));
+export default require_crypto_js();
+export { require_crypto_js };

package/dist/treeshaking/_virtual/crypto-js/lib-typedarrays.js.mjs

@@ -0,0 +1,30 @@
+import { __commonJSMin } from "../_rolldown/runtime.mjs";
+import { require_core } from "./core.js.mjs";
+// ../../node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/lib-typedarrays.js
+var require_lib_typedarrays = /* @__PURE__ */ __commonJSMin(((exports, module, this$1) => {
+	(function(root, factory) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core());
+		else if (typeof define === "function" && define.amd) define(["./core"], factory);
+		else factory(root.CryptoJS);
+	})(this$1, function(CryptoJS) {
+		(function() {
+			if (typeof ArrayBuffer != "function") return;
+			var WordArray = CryptoJS.lib.WordArray;
+			var superInit = WordArray.init;
+			var subInit = WordArray.init = function(typedArray) {
+				if (typedArray instanceof ArrayBuffer) typedArray = new Uint8Array(typedArray);
+				if (typedArray instanceof Int8Array || typeof Uint8ClampedArray !== "undefined" && typedArray instanceof Uint8ClampedArray || typedArray instanceof Int16Array || typedArray instanceof Uint16Array || typedArray instanceof Int32Array || typedArray instanceof Uint32Array || typedArray instanceof Float32Array || typedArray instanceof Float64Array) typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
+				if (typedArray instanceof Uint8Array) {
+					var typedArrayByteLength = typedArray.byteLength;
+					var words = [];
+					for (var i = 0; i < typedArrayByteLength; i++) words[i >>> 2] |= typedArray[i] << 24 - i % 4 * 8;
+					superInit.call(this, words, typedArrayByteLength);
+				} else superInit.apply(this, arguments);
+			};
+			subInit.prototype = WordArray;
+		})();
+		return CryptoJS.lib.WordArray;
+	});
+}));
+export default require_lib_typedarrays();
+export { require_lib_typedarrays };