@windrun-huaiin/backend-core 12.0.0 → 13.0.0

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/mode-cfb.mjs

@@ -0,0 +1,89 @@
+import { __module as modeCfb$1 } from '../../../../../_virtual/mode-cfb.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.mjs';
+
+var modeCfb = modeCfb$1.exports;
+
+var hasRequiredModeCfb;
+
+function requireModeCfb () {
+	if (hasRequiredModeCfb) return modeCfb$1.exports;
+	hasRequiredModeCfb = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore(), requireCipherCore());
+			}
+		}(modeCfb, function (CryptoJS) {
+
+			/**
+			 * Cipher Feedback block mode.
+			 */
+			CryptoJS.mode.CFB = (function () {
+			    var CFB = CryptoJS.lib.BlockCipherMode.extend();
+
+			    CFB.Encryptor = CFB.extend({
+			        processBlock: function (words, offset) {
+			            // Shortcuts
+			            var cipher = this._cipher;
+			            var blockSize = cipher.blockSize;
+
+			            generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
+
+			            // Remember this block to use with next block
+			            this._prevBlock = words.slice(offset, offset + blockSize);
+			        }
+			    });
+
+			    CFB.Decryptor = CFB.extend({
+			        processBlock: function (words, offset) {
+			            // Shortcuts
+			            var cipher = this._cipher;
+			            var blockSize = cipher.blockSize;
+
+			            // Remember this block to use with next block
+			            var thisBlock = words.slice(offset, offset + blockSize);
+
+			            generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
+
+			            // This block becomes the previous block
+			            this._prevBlock = thisBlock;
+			        }
+			    });
+
+			    function generateKeystreamAndEncrypt(words, offset, blockSize, cipher) {
+			        var keystream;
+
+			        // Shortcut
+			        var iv = this._iv;
+
+			        // Generate keystream
+			        if (iv) {
+			            keystream = iv.slice(0);
+
+			            // Remove IV for subsequent blocks
+			            this._iv = undefined;
+			        } else {
+			            keystream = this._prevBlock;
+			        }
+			        cipher.encryptBlock(keystream, 0);
+
+			        // Encrypt
+			        for (var i = 0; i < blockSize; i++) {
+			            words[offset + i] ^= keystream[i];
+			        }
+			    }
+
+			    return CFB;
+			}());
+
+
+			return CryptoJS.mode.CFB;
+
+		})); 
+	} (modeCfb$1));
+	return modeCfb$1.exports;
+}
+
+export { requireModeCfb as __require };

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/mode-ctr-gladman.js

@@ -0,0 +1,127 @@
+'use strict';
+
+var modeCtrGladman$1 = require('../../../../../_virtual/mode-ctr-gladman.js');
+var core = require('./core.js');
+var cipherCore = require('./cipher-core.js');
+
+var modeCtrGladman = modeCtrGladman$1.__module.exports;
+
+var hasRequiredModeCtrGladman;
+
+function requireModeCtrGladman () {
+	if (hasRequiredModeCtrGladman) return modeCtrGladman$1.__module.exports;
+	hasRequiredModeCtrGladman = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), cipherCore.__require());
+			}
+		}(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) & 0xff) === 0xff) { //overflow
+					var b1 = (word >> 16)&0xff;
+					var b2 = (word >> 8)&0xff;
+					var b3 = word & 0xff;
+
+					if (b1 === 0xff) // overflow b1
+					{
+					b1 = 0;
+					if (b2 === 0xff)
+					{
+						b2 = 0;
+						if (b3 === 0xff)
+						{
+							b3 = 0;
+						}
+						else
+						{
+							++b3;
+						}
+					}
+					else
+					{
+						++b2;
+					}
+					}
+					else
+					{
+					++b1;
+					}
+
+					word = 0;
+					word += (b1 << 16);
+					word += (b2 << 8);
+					word += b3;
+					}
+					else
+					{
+					word += (0x01 << 24);
+					}
+					return word;
+				}
+
+				function incCounter(counter)
+				{
+					if ((counter[0] = incWord(counter[0])) === 0)
+					{
+						// encr_data in fileenc.c from  Dr Brian Gladman's counts only with DWORD j < 8
+						counter[1] = incWord(counter[1]);
+					}
+					return counter;
+				}
+
+			    var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({
+			        processBlock: function (words, offset) {
+			            // Shortcuts
+			            var cipher = this._cipher;
+			            var blockSize = cipher.blockSize;
+			            var iv = this._iv;
+			            var counter = this._counter;
+
+			            // Generate keystream
+			            if (iv) {
+			                counter = this._counter = iv.slice(0);
+
+			                // Remove IV for subsequent blocks
+			                this._iv = undefined;
+			            }
+
+						incCounter(counter);
+
+						var keystream = counter.slice(0);
+			            cipher.encryptBlock(keystream, 0);
+
+			            // Encrypt
+			            for (var i = 0; i < blockSize; i++) {
+			                words[offset + i] ^= keystream[i];
+			            }
+			        }
+			    });
+
+			    CTRGladman.Decryptor = Encryptor;
+
+			    return CTRGladman;
+			}());
+
+
+
+
+			return CryptoJS.mode.CTRGladman;
+
+		})); 
+	} (modeCtrGladman$1.__module));
+	return modeCtrGladman$1.__module.exports;
+}
+
+exports.__require = requireModeCtrGladman;

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/mode-ctr-gladman.mjs

@@ -0,0 +1,125 @@
+import { __module as modeCtrGladman$1 } from '../../../../../_virtual/mode-ctr-gladman.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.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) {
+			{
+				// CommonJS
+				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) & 0xff) === 0xff) { //overflow
+					var b1 = (word >> 16)&0xff;
+					var b2 = (word >> 8)&0xff;
+					var b3 = word & 0xff;
+
+					if (b1 === 0xff) // overflow b1
+					{
+					b1 = 0;
+					if (b2 === 0xff)
+					{
+						b2 = 0;
+						if (b3 === 0xff)
+						{
+							b3 = 0;
+						}
+						else
+						{
+							++b3;
+						}
+					}
+					else
+					{
+						++b2;
+					}
+					}
+					else
+					{
+					++b1;
+					}
+
+					word = 0;
+					word += (b1 << 16);
+					word += (b2 << 8);
+					word += b3;
+					}
+					else
+					{
+					word += (0x01 << 24);
+					}
+					return word;
+				}
+
+				function incCounter(counter)
+				{
+					if ((counter[0] = incWord(counter[0])) === 0)
+					{
+						// encr_data in fileenc.c from  Dr Brian Gladman's counts only with DWORD j < 8
+						counter[1] = incWord(counter[1]);
+					}
+					return counter;
+				}
+
+			    var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({
+			        processBlock: function (words, offset) {
+			            // Shortcuts
+			            var cipher = this._cipher;
+			            var blockSize = cipher.blockSize;
+			            var iv = this._iv;
+			            var counter = this._counter;
+
+			            // Generate keystream
+			            if (iv) {
+			                counter = this._counter = iv.slice(0);
+
+			                // Remove IV for subsequent blocks
+			                this._iv = undefined;
+			            }
+
+						incCounter(counter);
+
+						var keystream = counter.slice(0);
+			            cipher.encryptBlock(keystream, 0);
+
+			            // Encrypt
+			            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/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/mode-ctr.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var modeCtr$1 = require('../../../../../_virtual/mode-ctr.js');
+var core = require('./core.js');
+var cipherCore = require('./cipher-core.js');
+
+var modeCtr = modeCtr$1.__module.exports;
+
+var hasRequiredModeCtr;
+
+function requireModeCtr () {
+	if (hasRequiredModeCtr) return modeCtr$1.__module.exports;
+	hasRequiredModeCtr = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), cipherCore.__require());
+			}
+		}(modeCtr, function (CryptoJS) {
+
+			/**
+			 * Counter block mode.
+			 */
+			CryptoJS.mode.CTR = (function () {
+			    var CTR = CryptoJS.lib.BlockCipherMode.extend();
+
+			    var Encryptor = CTR.Encryptor = CTR.extend({
+			        processBlock: function (words, offset) {
+			            // Shortcuts
+			            var cipher = this._cipher;
+			            var blockSize = cipher.blockSize;
+			            var iv = this._iv;
+			            var counter = this._counter;
+
+			            // Generate keystream
+			            if (iv) {
+			                counter = this._counter = iv.slice(0);
+
+			                // Remove IV for subsequent blocks
+			                this._iv = undefined;
+			            }
+			            var keystream = counter.slice(0);
+			            cipher.encryptBlock(keystream, 0);
+
+			            // Increment counter
+			            counter[blockSize - 1] = (counter[blockSize - 1] + 1) | 0;
+
+			            // Encrypt
+			            for (var i = 0; i < blockSize; i++) {
+			                words[offset + i] ^= keystream[i];
+			            }
+			        }
+			    });
+
+			    CTR.Decryptor = Encryptor;
+
+			    return CTR;
+			}());
+
+
+			return CryptoJS.mode.CTR;
+
+		})); 
+	} (modeCtr$1.__module));
+	return modeCtr$1.__module.exports;
+}
+
+exports.__require = requireModeCtr;

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/mode-ctr.mjs

@@ -0,0 +1,67 @@
+import { __module as modeCtr$1 } from '../../../../../_virtual/mode-ctr.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.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) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore(), requireCipherCore());
+			}
+		}(modeCtr, function (CryptoJS) {
+
+			/**
+			 * Counter block mode.
+			 */
+			CryptoJS.mode.CTR = (function () {
+			    var CTR = CryptoJS.lib.BlockCipherMode.extend();
+
+			    var Encryptor = CTR.Encryptor = CTR.extend({
+			        processBlock: function (words, offset) {
+			            // Shortcuts
+			            var cipher = this._cipher;
+			            var blockSize = cipher.blockSize;
+			            var iv = this._iv;
+			            var counter = this._counter;
+
+			            // Generate keystream
+			            if (iv) {
+			                counter = this._counter = iv.slice(0);
+
+			                // Remove IV for subsequent blocks
+			                this._iv = undefined;
+			            }
+			            var keystream = counter.slice(0);
+			            cipher.encryptBlock(keystream, 0);
+
+			            // Increment counter
+			            counter[blockSize - 1] = (counter[blockSize - 1] + 1) | 0;
+
+			            // Encrypt
+			            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/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/mode-ecb.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var modeEcb$1 = require('../../../../../_virtual/mode-ecb.js');
+var core = require('./core.js');
+var cipherCore = require('./cipher-core.js');
+
+var modeEcb = modeEcb$1.__module.exports;
+
+var hasRequiredModeEcb;
+
+function requireModeEcb () {
+	if (hasRequiredModeEcb) return modeEcb$1.__module.exports;
+	hasRequiredModeEcb = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), cipherCore.__require());
+			}
+		}(modeEcb, 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;
+
+		})); 
+	} (modeEcb$1.__module));
+	return modeEcb$1.__module.exports;
+}
+
+exports.__require = requireModeEcb;

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/mode-ecb.mjs

@@ -0,0 +1,49 @@
+import { __module as modeEcb$1 } from '../../../../../_virtual/mode-ecb.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.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) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore(), requireCipherCore());
+			}
+		}(modeEcb, 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;
+
+		})); 
+	} (modeEcb$1));
+	return modeEcb$1.exports;
+}
+
+export { requireModeEcb as __require };

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/mode-ofb.js

@@ -0,0 +1,65 @@
+'use strict';
+
+var modeOfb$1 = require('../../../../../_virtual/mode-ofb.js');
+var core = require('./core.js');
+var cipherCore = require('./cipher-core.js');
+
+var modeOfb = modeOfb$1.__module.exports;
+
+var hasRequiredModeOfb;
+
+function requireModeOfb () {
+	if (hasRequiredModeOfb) return modeOfb$1.__module.exports;
+	hasRequiredModeOfb = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), cipherCore.__require());
+			}
+		}(modeOfb, function (CryptoJS) {
+
+			/**
+			 * Output Feedback block mode.
+			 */
+			CryptoJS.mode.OFB = (function () {
+			    var OFB = CryptoJS.lib.BlockCipherMode.extend();
+
+			    var Encryptor = OFB.Encryptor = OFB.extend({
+			        processBlock: function (words, offset) {
+			            // Shortcuts
+			            var cipher = this._cipher;
+			            var blockSize = cipher.blockSize;
+			            var iv = this._iv;
+			            var keystream = this._keystream;
+
+			            // Generate keystream
+			            if (iv) {
+			                keystream = this._keystream = iv.slice(0);
+
+			                // Remove IV for subsequent blocks
+			                this._iv = undefined;
+			            }
+			            cipher.encryptBlock(keystream, 0);
+
+			            // Encrypt
+			            for (var i = 0; i < blockSize; i++) {
+			                words[offset + i] ^= keystream[i];
+			            }
+			        }
+			    });
+
+			    OFB.Decryptor = Encryptor;
+
+			    return OFB;
+			}());
+
+
+			return CryptoJS.mode.OFB;
+
+		})); 
+	} (modeOfb$1.__module));
+	return modeOfb$1.__module.exports;
+}
+
+exports.__require = requireModeOfb;

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/mode-ofb.mjs

@@ -0,0 +1,63 @@
+import { __module as modeOfb$1 } from '../../../../../_virtual/mode-ofb.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.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) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore(), requireCipherCore());
+			}
+		}(modeOfb, function (CryptoJS) {
+
+			/**
+			 * Output Feedback block mode.
+			 */
+			CryptoJS.mode.OFB = (function () {
+			    var OFB = CryptoJS.lib.BlockCipherMode.extend();
+
+			    var Encryptor = OFB.Encryptor = OFB.extend({
+			        processBlock: function (words, offset) {
+			            // Shortcuts
+			            var cipher = this._cipher;
+			            var blockSize = cipher.blockSize;
+			            var iv = this._iv;
+			            var keystream = this._keystream;
+
+			            // Generate keystream
+			            if (iv) {
+			                keystream = this._keystream = iv.slice(0);
+
+			                // Remove IV for subsequent blocks
+			                this._iv = undefined;
+			            }
+			            cipher.encryptBlock(keystream, 0);
+
+			            // Encrypt
+			            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 };