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

package/dist/treeshaking/_virtual/crypto-js/mode-ctr-gladman.js.mjs

@@ -1,62 +1,85 @@
-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/mode-ctr-gladman.js
-var require_mode_ctr_gladman = /* @__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) {
-		/** @preserve
-		* Counter block mode compatible with  Dr Brian Gladman fileenc.c
-		* derived from CryptoJS.mode.CTR
-		* Jan Hruby jhruby.web@gmail.com
-		*/
-		CryptoJS.mode.CTRGladman = function() {
-			var CTRGladman = CryptoJS.lib.BlockCipherMode.extend();
-			function incWord(word) {
-				if ((word >> 24 & 255) === 255) {
-					var b1 = word >> 16 & 255;
-					var b2 = word >> 8 & 255;
-					var b3 = word & 255;
-					if (b1 === 255) {
-						b1 = 0;
-						if (b2 === 255) {
-							b2 = 0;
-							if (b3 === 255) b3 = 0;
-							else ++b3;
-						} else ++b2;
-					} else ++b1;
-					word = 0;
-					word += b1 << 16;
-					word += b2 << 8;
-					word += b3;
-				} else word += 1 << 24;
-				return word;
-			}
-			function incCounter(counter) {
-				if ((counter[0] = incWord(counter[0])) === 0) counter[1] = incWord(counter[1]);
-				return counter;
-			}
-			CTRGladman.Decryptor = CTRGladman.Encryptor = CTRGladman.extend({ processBlock: function(words, offset) {
-				var cipher = this._cipher;
-				var blockSize = cipher.blockSize;
-				var iv = this._iv;
-				var counter = this._counter;
-				if (iv) {
-					counter = this._counter = iv.slice(0);
-					this._iv = void 0;
-				}
-				incCounter(counter);
-				var keystream = counter.slice(0);
-				cipher.encryptBlock(keystream, 0);
-				for (var i = 0; i < blockSize; i++) words[offset + i] ^= keystream[i];
-			} });
-			return CTRGladman;
-		}();
-		return CryptoJS.mode.CTRGladman;
-	});
-}));
-export default require_mode_ctr_gladman();
-export { require_mode_ctr_gladman };
+import { __module as modeCtrGladman$1 } from "./mode-ctr-gladman.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+import { __require as requireCipherCore } from "./cipher-core.js.mjs";
+var modeCtrGladman = modeCtrGladman$1.exports;
+var hasRequiredModeCtrGladman;
+function requireModeCtrGladman() {
+  if (hasRequiredModeCtrGladman) return modeCtrGladman$1.exports;
+  hasRequiredModeCtrGladman = 1;
+  (function(module, exports) {
+    (function(root, factory, undef) {
+      {
+        module.exports = factory(requireCore(), requireCipherCore());
+      }
+    })(modeCtrGladman, function(CryptoJS) {
+      /** @preserve
+       * Counter block mode compatible with  Dr Brian Gladman fileenc.c
+       * derived from CryptoJS.mode.CTR
+       * Jan Hruby jhruby.web@gmail.com
+       */
+      CryptoJS.mode.CTRGladman = (function() {
+        var CTRGladman = CryptoJS.lib.BlockCipherMode.extend();
+        function incWord(word) {
+          if ((word >> 24 & 255) === 255) {
+            var b1 = word >> 16 & 255;
+            var b2 = word >> 8 & 255;
+            var b3 = word & 255;
+            if (b1 === 255) {
+              b1 = 0;
+              if (b2 === 255) {
+                b2 = 0;
+                if (b3 === 255) {
+                  b3 = 0;
+                } else {
+                  ++b3;
+                }
+              } else {
+                ++b2;
+              }
+            } else {
+              ++b1;
+            }
+            word = 0;
+            word += b1 << 16;
+            word += b2 << 8;
+            word += b3;
+          } else {
+            word += 1 << 24;
+          }
+          return word;
+        }
+        function incCounter(counter) {
+          if ((counter[0] = incWord(counter[0])) === 0) {
+            counter[1] = incWord(counter[1]);
+          }
+          return counter;
+        }
+        var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({
+          processBlock: function(words, offset) {
+            var cipher = this._cipher;
+            var blockSize = cipher.blockSize;
+            var iv = this._iv;
+            var counter = this._counter;
+            if (iv) {
+              counter = this._counter = iv.slice(0);
+              this._iv = void 0;
+            }
+            incCounter(counter);
+            var keystream = counter.slice(0);
+            cipher.encryptBlock(keystream, 0);
+            for (var i = 0; i < blockSize; i++) {
+              words[offset + i] ^= keystream[i];
+            }
+          }
+        });
+        CTRGladman.Decryptor = Encryptor;
+        return CTRGladman;
+      })();
+      return CryptoJS.mode.CTRGladman;
+    });
+  })(modeCtrGladman$1);
+  return modeCtrGladman$1.exports;
+}
+export {
+  requireModeCtrGladman as __require
+};

package/dist/treeshaking/_virtual/crypto-js/mode-ctr-gladman.js2.mjs

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

package/dist/treeshaking/_virtual/crypto-js/mode-ctr.js.mjs

@@ -1,36 +1,45 @@
-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/mode-ctr.js
-var require_mode_ctr = /* @__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) {
-		/**
-		* Counter block mode.
-		*/
-		CryptoJS.mode.CTR = function() {
-			var CTR = CryptoJS.lib.BlockCipherMode.extend();
-			CTR.Decryptor = CTR.Encryptor = CTR.extend({ processBlock: function(words, offset) {
-				var cipher = this._cipher;
-				var blockSize = cipher.blockSize;
-				var iv = this._iv;
-				var counter = this._counter;
-				if (iv) {
-					counter = this._counter = iv.slice(0);
-					this._iv = void 0;
-				}
-				var keystream = counter.slice(0);
-				cipher.encryptBlock(keystream, 0);
-				counter[blockSize - 1] = counter[blockSize - 1] + 1 | 0;
-				for (var i = 0; i < blockSize; i++) words[offset + i] ^= keystream[i];
-			} });
-			return CTR;
-		}();
-		return CryptoJS.mode.CTR;
-	});
-}));
-export default require_mode_ctr();
-export { require_mode_ctr };
+import { __module as modeCtr$1 } from "./mode-ctr.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+import { __require as requireCipherCore } from "./cipher-core.js.mjs";
+var modeCtr = modeCtr$1.exports;
+var hasRequiredModeCtr;
+function requireModeCtr() {
+  if (hasRequiredModeCtr) return modeCtr$1.exports;
+  hasRequiredModeCtr = 1;
+  (function(module, exports) {
+    (function(root, factory, undef) {
+      {
+        module.exports = factory(requireCore(), requireCipherCore());
+      }
+    })(modeCtr, function(CryptoJS) {
+      CryptoJS.mode.CTR = (function() {
+        var CTR = CryptoJS.lib.BlockCipherMode.extend();
+        var Encryptor = CTR.Encryptor = CTR.extend({
+          processBlock: function(words, offset) {
+            var cipher = this._cipher;
+            var blockSize = cipher.blockSize;
+            var iv = this._iv;
+            var counter = this._counter;
+            if (iv) {
+              counter = this._counter = iv.slice(0);
+              this._iv = void 0;
+            }
+            var keystream = counter.slice(0);
+            cipher.encryptBlock(keystream, 0);
+            counter[blockSize - 1] = counter[blockSize - 1] + 1 | 0;
+            for (var i = 0; i < blockSize; i++) {
+              words[offset + i] ^= keystream[i];
+            }
+          }
+        });
+        CTR.Decryptor = Encryptor;
+        return CTR;
+      })();
+      return CryptoJS.mode.CTR;
+    });
+  })(modeCtr$1);
+  return modeCtr$1.exports;
+}
+export {
+  requireModeCtr as __require
+};

package/dist/treeshaking/_virtual/crypto-js/mode-ctr.js2.mjs

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

package/dist/treeshaking/_virtual/crypto-js/mode-ecb.js.mjs

@@ -1,28 +1,36 @@
-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/mode-ecb.js
-var require_mode_ecb = /* @__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) {
-		/**
-		* Electronic Codebook block mode.
-		*/
-		CryptoJS.mode.ECB = function() {
-			var ECB = CryptoJS.lib.BlockCipherMode.extend();
-			ECB.Encryptor = ECB.extend({ processBlock: function(words, offset) {
-				this._cipher.encryptBlock(words, offset);
-			} });
-			ECB.Decryptor = ECB.extend({ processBlock: function(words, offset) {
-				this._cipher.decryptBlock(words, offset);
-			} });
-			return ECB;
-		}();
-		return CryptoJS.mode.ECB;
-	});
-}));
-export default require_mode_ecb();
-export { require_mode_ecb };
+import { __module as modeEcb$1 } from "./mode-ecb.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+import { __require as requireCipherCore } from "./cipher-core.js.mjs";
+var modeEcb = modeEcb$1.exports;
+var hasRequiredModeEcb;
+function requireModeEcb() {
+  if (hasRequiredModeEcb) return modeEcb$1.exports;
+  hasRequiredModeEcb = 1;
+  (function(module, exports) {
+    (function(root, factory, undef) {
+      {
+        module.exports = factory(requireCore(), requireCipherCore());
+      }
+    })(modeEcb, function(CryptoJS) {
+      CryptoJS.mode.ECB = (function() {
+        var ECB = CryptoJS.lib.BlockCipherMode.extend();
+        ECB.Encryptor = ECB.extend({
+          processBlock: function(words, offset) {
+            this._cipher.encryptBlock(words, offset);
+          }
+        });
+        ECB.Decryptor = ECB.extend({
+          processBlock: function(words, offset) {
+            this._cipher.decryptBlock(words, offset);
+          }
+        });
+        return ECB;
+      })();
+      return CryptoJS.mode.ECB;
+    });
+  })(modeEcb$1);
+  return modeEcb$1.exports;
+}
+export {
+  requireModeEcb as __require
+};

package/dist/treeshaking/_virtual/crypto-js/mode-ecb.js2.mjs

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

package/dist/treeshaking/_virtual/crypto-js/mode-ofb.js.mjs

@@ -1,34 +1,43 @@
-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/mode-ofb.js
-var require_mode_ofb = /* @__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) {
-		/**
-		* Output Feedback block mode.
-		*/
-		CryptoJS.mode.OFB = function() {
-			var OFB = CryptoJS.lib.BlockCipherMode.extend();
-			OFB.Decryptor = OFB.Encryptor = OFB.extend({ processBlock: function(words, offset) {
-				var cipher = this._cipher;
-				var blockSize = cipher.blockSize;
-				var iv = this._iv;
-				var keystream = this._keystream;
-				if (iv) {
-					keystream = this._keystream = iv.slice(0);
-					this._iv = void 0;
-				}
-				cipher.encryptBlock(keystream, 0);
-				for (var i = 0; i < blockSize; i++) words[offset + i] ^= keystream[i];
-			} });
-			return OFB;
-		}();
-		return CryptoJS.mode.OFB;
-	});
-}));
-export default require_mode_ofb();
-export { require_mode_ofb };
+import { __module as modeOfb$1 } from "./mode-ofb.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+import { __require as requireCipherCore } from "./cipher-core.js.mjs";
+var modeOfb = modeOfb$1.exports;
+var hasRequiredModeOfb;
+function requireModeOfb() {
+  if (hasRequiredModeOfb) return modeOfb$1.exports;
+  hasRequiredModeOfb = 1;
+  (function(module, exports) {
+    (function(root, factory, undef) {
+      {
+        module.exports = factory(requireCore(), requireCipherCore());
+      }
+    })(modeOfb, function(CryptoJS) {
+      CryptoJS.mode.OFB = (function() {
+        var OFB = CryptoJS.lib.BlockCipherMode.extend();
+        var Encryptor = OFB.Encryptor = OFB.extend({
+          processBlock: function(words, offset) {
+            var cipher = this._cipher;
+            var blockSize = cipher.blockSize;
+            var iv = this._iv;
+            var keystream = this._keystream;
+            if (iv) {
+              keystream = this._keystream = iv.slice(0);
+              this._iv = void 0;
+            }
+            cipher.encryptBlock(keystream, 0);
+            for (var i = 0; i < blockSize; i++) {
+              words[offset + i] ^= keystream[i];
+            }
+          }
+        });
+        OFB.Decryptor = Encryptor;
+        return OFB;
+      })();
+      return CryptoJS.mode.OFB;
+    });
+  })(modeOfb$1);
+  return modeOfb$1.exports;
+}
+export {
+  requireModeOfb as __require
+};

package/dist/treeshaking/_virtual/crypto-js/mode-ofb.js2.mjs

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

package/dist/treeshaking/_virtual/crypto-js/pad-ansix923.js.mjs

@@ -1,33 +1,37 @@
-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/pad-ansix923.js
-var require_pad_ansix923 = /* @__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) {
-		/**
-		* ANSI X.923 padding strategy.
-		*/
-		CryptoJS.pad.AnsiX923 = {
-			pad: function(data, blockSize) {
-				var dataSigBytes = data.sigBytes;
-				var blockSizeBytes = blockSize * 4;
-				var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
-				var lastBytePos = dataSigBytes + nPaddingBytes - 1;
-				data.clamp();
-				data.words[lastBytePos >>> 2] |= nPaddingBytes << 24 - lastBytePos % 4 * 8;
-				data.sigBytes += nPaddingBytes;
-			},
-			unpad: function(data) {
-				var nPaddingBytes = data.words[data.sigBytes - 1 >>> 2] & 255;
-				data.sigBytes -= nPaddingBytes;
-			}
-		};
-		return CryptoJS.pad.Ansix923;
-	});
-}));
-export default require_pad_ansix923();
-export { require_pad_ansix923 };
+import { __module as padAnsix923$1 } from "./pad-ansix923.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+import { __require as requireCipherCore } from "./cipher-core.js.mjs";
+var padAnsix923 = padAnsix923$1.exports;
+var hasRequiredPadAnsix923;
+function requirePadAnsix923() {
+  if (hasRequiredPadAnsix923) return padAnsix923$1.exports;
+  hasRequiredPadAnsix923 = 1;
+  (function(module, exports) {
+    (function(root, factory, undef) {
+      {
+        module.exports = factory(requireCore(), requireCipherCore());
+      }
+    })(padAnsix923, function(CryptoJS) {
+      CryptoJS.pad.AnsiX923 = {
+        pad: function(data, blockSize) {
+          var dataSigBytes = data.sigBytes;
+          var blockSizeBytes = blockSize * 4;
+          var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
+          var lastBytePos = dataSigBytes + nPaddingBytes - 1;
+          data.clamp();
+          data.words[lastBytePos >>> 2] |= nPaddingBytes << 24 - lastBytePos % 4 * 8;
+          data.sigBytes += nPaddingBytes;
+        },
+        unpad: function(data) {
+          var nPaddingBytes = data.words[data.sigBytes - 1 >>> 2] & 255;
+          data.sigBytes -= nPaddingBytes;
+        }
+      };
+      return CryptoJS.pad.Ansix923;
+    });
+  })(padAnsix923$1);
+  return padAnsix923$1.exports;
+}
+export {
+  requirePadAnsix923 as __require
+};

package/dist/treeshaking/_virtual/crypto-js/pad-ansix923.js2.mjs

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

package/dist/treeshaking/_virtual/crypto-js/pad-iso10126.js.mjs

@@ -1,29 +1,33 @@
-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/pad-iso10126.js
-var require_pad_iso10126 = /* @__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) {
-		/**
-		* ISO 10126 padding strategy.
-		*/
-		CryptoJS.pad.Iso10126 = {
-			pad: function(data, blockSize) {
-				var blockSizeBytes = blockSize * 4;
-				var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
-				data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)).concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1));
-			},
-			unpad: function(data) {
-				var nPaddingBytes = data.words[data.sigBytes - 1 >>> 2] & 255;
-				data.sigBytes -= nPaddingBytes;
-			}
-		};
-		return CryptoJS.pad.Iso10126;
-	});
-}));
-export default require_pad_iso10126();
-export { require_pad_iso10126 };
+import { __module as padIso10126$1 } from "./pad-iso10126.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+import { __require as requireCipherCore } from "./cipher-core.js.mjs";
+var padIso10126 = padIso10126$1.exports;
+var hasRequiredPadIso10126;
+function requirePadIso10126() {
+  if (hasRequiredPadIso10126) return padIso10126$1.exports;
+  hasRequiredPadIso10126 = 1;
+  (function(module, exports) {
+    (function(root, factory, undef) {
+      {
+        module.exports = factory(requireCore(), requireCipherCore());
+      }
+    })(padIso10126, function(CryptoJS) {
+      CryptoJS.pad.Iso10126 = {
+        pad: function(data, blockSize) {
+          var blockSizeBytes = blockSize * 4;
+          var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
+          data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)).concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1));
+        },
+        unpad: function(data) {
+          var nPaddingBytes = data.words[data.sigBytes - 1 >>> 2] & 255;
+          data.sigBytes -= nPaddingBytes;
+        }
+      };
+      return CryptoJS.pad.Iso10126;
+    });
+  })(padIso10126$1);
+  return padIso10126$1.exports;
+}
+export {
+  requirePadIso10126 as __require
+};

package/dist/treeshaking/_virtual/crypto-js/pad-iso10126.js2.mjs

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

package/dist/treeshaking/_virtual/crypto-js/pad-iso97971.js.mjs

@@ -1,28 +1,32 @@
-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/pad-iso97971.js
-var require_pad_iso97971 = /* @__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) {
-		/**
-		* ISO/IEC 9797-1 Padding Method 2.
-		*/
-		CryptoJS.pad.Iso97971 = {
-			pad: function(data, blockSize) {
-				data.concat(CryptoJS.lib.WordArray.create([2147483648], 1));
-				CryptoJS.pad.ZeroPadding.pad(data, blockSize);
-			},
-			unpad: function(data) {
-				CryptoJS.pad.ZeroPadding.unpad(data);
-				data.sigBytes--;
-			}
-		};
-		return CryptoJS.pad.Iso97971;
-	});
-}));
-export default require_pad_iso97971();
-export { require_pad_iso97971 };
+import { __module as padIso97971$1 } from "./pad-iso97971.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+import { __require as requireCipherCore } from "./cipher-core.js.mjs";
+var padIso97971 = padIso97971$1.exports;
+var hasRequiredPadIso97971;
+function requirePadIso97971() {
+  if (hasRequiredPadIso97971) return padIso97971$1.exports;
+  hasRequiredPadIso97971 = 1;
+  (function(module, exports) {
+    (function(root, factory, undef) {
+      {
+        module.exports = factory(requireCore(), requireCipherCore());
+      }
+    })(padIso97971, function(CryptoJS) {
+      CryptoJS.pad.Iso97971 = {
+        pad: function(data, blockSize) {
+          data.concat(CryptoJS.lib.WordArray.create([2147483648], 1));
+          CryptoJS.pad.ZeroPadding.pad(data, blockSize);
+        },
+        unpad: function(data) {
+          CryptoJS.pad.ZeroPadding.unpad(data);
+          data.sigBytes--;
+        }
+      };
+      return CryptoJS.pad.Iso97971;
+    });
+  })(padIso97971$1);
+  return padIso97971$1.exports;
+}
+export {
+  requirePadIso97971 as __require
+};

package/dist/treeshaking/_virtual/crypto-js/pad-iso97971.js2.mjs

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