@opendesign-plus-test/components 0.0.1-rc.177 → 0.0.1-rc.178

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

@@ -0,0 +1,112 @@
+import { __module as encBase64$1 } from "./enc-base64.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+var encBase64 = encBase64$1.exports;
+var hasRequiredEncBase64;
+function requireEncBase64() {
+  if (hasRequiredEncBase64) return encBase64$1.exports;
+  hasRequiredEncBase64 = 1;
+  (function(module, exports) {
+    (function(root, factory) {
+      {
+        module.exports = factory(requireCore());
+      }
+    })(encBase64, function(CryptoJS) {
+      (function() {
+        var C = CryptoJS;
+        var C_lib = C.lib;
+        var WordArray = C_lib.WordArray;
+        var C_enc = C.enc;
+        C_enc.Base64 = {
+          /**
+           * Converts a word array to a Base64 string.
+           *
+           * @param {WordArray} wordArray The word array.
+           *
+           * @return {string} The Base64 string.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
+           */
+          stringify: function(wordArray) {
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+            var 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 * 0.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 Base64 string to a word array.
+           *
+           * @param {string} base64Str The Base64 string.
+           *
+           * @return {WordArray} The word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
+           */
+          parse: function(base64Str) {
+            var base64StrLength = base64Str.length;
+            var 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+/="
+        };
+        function parseLoop(base64Str, base64StrLength, reverseMap) {
+          var words = [];
+          var nBytes = 0;
+          for (var i = 0; i < base64StrLength; i++) {
+            if (i % 4) {
+              var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << i % 4 * 2;
+              var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> 6 - i % 4 * 2;
+              var bitsCombined = bits1 | bits2;
+              words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
+              nBytes++;
+            }
+          }
+          return WordArray.create(words, nBytes);
+        }
+      })();
+      return CryptoJS.enc.Base64;
+    });
+  })(encBase64$1);
+  return encBase64$1.exports;
+}
+export {
+  requireEncBase64 as __require
+};

package/dist/treeshaking/_virtual/crypto-js/enc-base64.js2.mjs

@@ -0,0 +1,4 @@
+var encBase64 = { exports: {} };
+export {
+  encBase64 as __module
+};

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

@@ -0,0 +1,123 @@
+import { __module as encBase64url$1 } from "./enc-base64url.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+var encBase64url = encBase64url$1.exports;
+var hasRequiredEncBase64url;
+function requireEncBase64url() {
+  if (hasRequiredEncBase64url) return encBase64url$1.exports;
+  hasRequiredEncBase64url = 1;
+  (function(module, exports) {
+    (function(root, factory) {
+      {
+        module.exports = factory(requireCore());
+      }
+    })(encBase64url, function(CryptoJS) {
+      (function() {
+        var C = CryptoJS;
+        var C_lib = C.lib;
+        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 * 0.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 bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << i % 4 * 2;
+              var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> 6 - i % 4 * 2;
+              var bitsCombined = bits1 | bits2;
+              words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
+              nBytes++;
+            }
+          }
+          return WordArray.create(words, nBytes);
+        }
+      })();
+      return CryptoJS.enc.Base64url;
+    });
+  })(encBase64url$1);
+  return encBase64url$1.exports;
+}
+export {
+  requireEncBase64url as __require
+};

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

@@ -0,0 +1,4 @@
+var encBase64url = { exports: {} };
+export {
+  encBase64url as __module
+};

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

@@ -0,0 +1,122 @@
+import { __module as encUtf16$1 } from "./enc-utf16.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+var encUtf16 = encUtf16$1.exports;
+var hasRequiredEncUtf16;
+function requireEncUtf16() {
+  if (hasRequiredEncUtf16) return encUtf16$1.exports;
+  hasRequiredEncUtf16 = 1;
+  (function(module, exports) {
+    (function(root, factory) {
+      {
+        module.exports = factory(requireCore());
+      }
+    })(encUtf16, function(CryptoJS) {
+      (function() {
+        var C = CryptoJS;
+        var C_lib = C.lib;
+        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);
+          }
+        };
+        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;
+    });
+  })(encUtf16$1);
+  return encUtf16$1.exports;
+}
+export {
+  requireEncUtf16 as __require
+};

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

@@ -0,0 +1,4 @@
+var encUtf16 = { exports: {} };
+export {
+  encUtf16 as __module
+};

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

@@ -0,0 +1,97 @@
+import { __module as evpkdf$1 } from "./evpkdf.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+import { __require as requireSha1 } from "./sha1.js.mjs";
+import { __require as requireHmac } from "./hmac.js.mjs";
+var evpkdf = evpkdf$1.exports;
+var hasRequiredEvpkdf;
+function requireEvpkdf() {
+  if (hasRequiredEvpkdf) return evpkdf$1.exports;
+  hasRequiredEvpkdf = 1;
+  (function(module, exports) {
+    (function(root, factory, undef) {
+      {
+        module.exports = factory(requireCore(), requireSha1(), requireHmac());
+      }
+    })(evpkdf, 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;
+        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: 128 / 32,
+            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;
+          }
+        });
+        C.EvpKDF = function(password, salt, cfg) {
+          return EvpKDF.create(cfg).compute(password, salt);
+        };
+      })();
+      return CryptoJS.EvpKDF;
+    });
+  })(evpkdf$1);
+  return evpkdf$1.exports;
+}
+export {
+  requireEvpkdf as __require
+};

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

@@ -0,0 +1,4 @@
+var evpkdf = { exports: {} };
+export {
+  evpkdf as __module
+};

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

@@ -0,0 +1,65 @@
+import { __module as formatHex$1 } from "./format-hex.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+import { __require as requireCipherCore } from "./cipher-core.js.mjs";
+var formatHex = formatHex$1.exports;
+var hasRequiredFormatHex;
+function requireFormatHex() {
+  if (hasRequiredFormatHex) return formatHex$1.exports;
+  hasRequiredFormatHex = 1;
+  (function(module, exports) {
+    (function(root, factory, undef) {
+      {
+        module.exports = factory(requireCore(), requireCipherCore());
+      }
+    })(formatHex, function(CryptoJS) {
+      (function(undefined$1) {
+        var C = CryptoJS;
+        var C_lib = C.lib;
+        var CipherParams = C_lib.CipherParams;
+        var C_enc = C.enc;
+        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;
+    });
+  })(formatHex$1);
+  return formatHex$1.exports;
+}
+export {
+  requireFormatHex as __require
+};

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

@@ -0,0 +1,4 @@
+var formatHex = { exports: {} };
+export {
+  formatHex as __module
+};

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

@@ -0,0 +1,111 @@
+import { __module as hmac$1 } from "./hmac.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+var hmac = hmac$1.exports;
+var hasRequiredHmac;
+function requireHmac() {
+  if (hasRequiredHmac) return hmac$1.exports;
+  hasRequiredHmac = 1;
+  (function(module, exports) {
+    (function(root, factory) {
+      {
+        module.exports = factory(requireCore());
+      }
+    })(hmac, function(CryptoJS) {
+      (function() {
+        var C = CryptoJS;
+        var C_lib = C.lib;
+        var Base = C_lib.Base;
+        var C_enc = C.enc;
+        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();
+            var hmac2 = hasher.finalize(this._oKey.clone().concat(innerHash));
+            return hmac2;
+          }
+        });
+      })();
+    });
+  })(hmac$1);
+  return hmac$1.exports;
+}
+export {
+  requireHmac as __require
+};

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

@@ -0,0 +1,4 @@
+var hmac = { exports: {} };
+export {
+  hmac as __module
+};

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

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from "../_commonjsHelpers.mjs";
+import { __require as requireCryptoJs } from "./index.js2.mjs";
+var cryptoJsExports = requireCryptoJs();
+const CryptoJS = /* @__PURE__ */ getDefaultExportFromCjs(cryptoJsExports);
+export {
+  CryptoJS as default
+};