@gct-paas/core 0.1.4-dev.2 → 0.1.4-dev.3

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

@@ -0,0 +1,98 @@
+import '../../../../../_virtual/_commonjsHelpers.mjs';
+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) {
+			if ('object' === "object") {
+				// CommonJS
+				module.exports = exports = factory(requireCore(), requireCipherCore());
+			}
+			else if (typeof undefined === "function" && undefined.amd) {
+				// AMD
+				undefined(["./core", "./cipher-core"], factory);
+			}
+			else {
+				// Global (browser)
+				factory(root.CryptoJS);
+			}
+		}(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, modeCfb$1.exports));
+	return modeCfb$1.exports;
+}
+
+export { requireModeCfb as __require };

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

@@ -0,0 +1,134 @@
+import '../../../../../_virtual/_commonjsHelpers.mjs';
+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) {
+			if ('object' === "object") {
+				// CommonJS
+				module.exports = exports = factory(requireCore(), requireCipherCore());
+			}
+			else if (typeof undefined === "function" && undefined.amd) {
+				// AMD
+				undefined(["./core", "./cipher-core"], factory);
+			}
+			else {
+				// Global (browser)
+				factory(root.CryptoJS);
+			}
+		}(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, modeCtrGladman$1.exports));
+	return modeCtrGladman$1.exports;
+}
+
+export { requireModeCtrGladman as __require };

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

@@ -0,0 +1,76 @@
+import '../../../../../_virtual/_commonjsHelpers.mjs';
+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) {
+			if ('object' === "object") {
+				// CommonJS
+				module.exports = exports = factory(requireCore(), requireCipherCore());
+			}
+			else if (typeof undefined === "function" && undefined.amd) {
+				// AMD
+				undefined(["./core", "./cipher-core"], factory);
+			}
+			else {
+				// Global (browser)
+				factory(root.CryptoJS);
+			}
+		}(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, modeCtr$1.exports));
+	return modeCtr$1.exports;
+}
+
+export { requireModeCtr as __require };

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

@@ -0,0 +1,58 @@
+import '../../../../../_virtual/_commonjsHelpers.mjs';
+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) {
+			if ('object' === "object") {
+				// CommonJS
+				module.exports = exports = factory(requireCore(), requireCipherCore());
+			}
+			else if (typeof undefined === "function" && undefined.amd) {
+				// AMD
+				undefined(["./core", "./cipher-core"], factory);
+			}
+			else {
+				// Global (browser)
+				factory(root.CryptoJS);
+			}
+		}(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, modeEcb$1.exports));
+	return modeEcb$1.exports;
+}
+
+export { requireModeEcb as __require };

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

@@ -0,0 +1,72 @@
+import '../../../../../_virtual/_commonjsHelpers.mjs';
+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) {
+			if ('object' === "object") {
+				// CommonJS
+				module.exports = exports = factory(requireCore(), requireCipherCore());
+			}
+			else if (typeof undefined === "function" && undefined.amd) {
+				// AMD
+				undefined(["./core", "./cipher-core"], factory);
+			}
+			else {
+				// Global (browser)
+				factory(root.CryptoJS);
+			}
+		}(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, modeOfb$1.exports));
+	return modeOfb$1.exports;
+}
+
+export { requireModeOfb as __require };

package/es/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-ansix923.mjs

@@ -0,0 +1,67 @@
+import '../../../../../_virtual/_commonjsHelpers.mjs';
+import { __module as padAnsix923$1 } from '../../../../../_virtual/pad-ansix923.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.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) {
+			if ('object' === "object") {
+				// CommonJS
+				module.exports = exports = factory(requireCore(), requireCipherCore());
+			}
+			else if (typeof undefined === "function" && undefined.amd) {
+				// AMD
+				undefined(["./core", "./cipher-core"], factory);
+			}
+			else {
+				// Global (browser)
+				factory(root.CryptoJS);
+			}
+		}(padAnsix923, function (CryptoJS) {
+
+			/**
+			 * ANSI X.923 padding strategy.
+			 */
+			CryptoJS.pad.AnsiX923 = {
+			    pad: function (data, blockSize) {
+			        // Shortcuts
+			        var dataSigBytes = data.sigBytes;
+			        var blockSizeBytes = blockSize * 4;
+
+			        // Count padding bytes
+			        var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
+
+			        // Compute last byte position
+			        var lastBytePos = dataSigBytes + nPaddingBytes - 1;
+
+			        // Pad
+			        data.clamp();
+			        data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8);
+			        data.sigBytes += nPaddingBytes;
+			    },
+
+			    unpad: function (data) {
+			        // Get number of padding bytes from last byte
+			        var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
+
+			        // Remove padding
+			        data.sigBytes -= nPaddingBytes;
+			    }
+			};
+
+
+			return CryptoJS.pad.Ansix923;
+
+		})); 
+	} (padAnsix923$1, padAnsix923$1.exports));
+	return padAnsix923$1.exports;
+}
+
+export { requirePadAnsix923 as __require };

package/es/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-iso10126.mjs

@@ -0,0 +1,62 @@
+import '../../../../../_virtual/_commonjsHelpers.mjs';
+import { __module as padIso10126$1 } from '../../../../../_virtual/pad-iso10126.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.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) {
+			if ('object' === "object") {
+				// CommonJS
+				module.exports = exports = factory(requireCore(), requireCipherCore());
+			}
+			else if (typeof undefined === "function" && undefined.amd) {
+				// AMD
+				undefined(["./core", "./cipher-core"], factory);
+			}
+			else {
+				// Global (browser)
+				factory(root.CryptoJS);
+			}
+		}(padIso10126, function (CryptoJS) {
+
+			/**
+			 * ISO 10126 padding strategy.
+			 */
+			CryptoJS.pad.Iso10126 = {
+			    pad: function (data, blockSize) {
+			        // Shortcut
+			        var blockSizeBytes = blockSize * 4;
+
+			        // Count padding bytes
+			        var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
+
+			        // Pad
+			        data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)).
+			             concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1));
+			    },
+
+			    unpad: function (data) {
+			        // Get number of padding bytes from last byte
+			        var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
+
+			        // Remove padding
+			        data.sigBytes -= nPaddingBytes;
+			    }
+			};
+
+
+			return CryptoJS.pad.Iso10126;
+
+		})); 
+	} (padIso10126$1, padIso10126$1.exports));
+	return padIso10126$1.exports;
+}
+
+export { requirePadIso10126 as __require };

package/es/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-iso97971.mjs

@@ -0,0 +1,58 @@
+import '../../../../../_virtual/_commonjsHelpers.mjs';
+import { __module as padIso97971$1 } from '../../../../../_virtual/pad-iso97971.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.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) {
+			if ('object' === "object") {
+				// CommonJS
+				module.exports = exports = factory(requireCore(), requireCipherCore());
+			}
+			else if (typeof undefined === "function" && undefined.amd) {
+				// AMD
+				undefined(["./core", "./cipher-core"], factory);
+			}
+			else {
+				// Global (browser)
+				factory(root.CryptoJS);
+			}
+		}(padIso97971, function (CryptoJS) {
+
+			/**
+			 * ISO/IEC 9797-1 Padding Method 2.
+			 */
+			CryptoJS.pad.Iso97971 = {
+			    pad: function (data, blockSize) {
+			        // Add 0x80 byte
+			        data.concat(CryptoJS.lib.WordArray.create([0x80000000], 1));
+
+			        // Zero pad the rest
+			        CryptoJS.pad.ZeroPadding.pad(data, blockSize);
+			    },
+
+			    unpad: function (data) {
+			        // Remove zero padding
+			        CryptoJS.pad.ZeroPadding.unpad(data);
+
+			        // Remove one more byte -- the 0x80 byte
+			        data.sigBytes--;
+			    }
+			};
+
+
+			return CryptoJS.pad.Iso97971;
+
+		})); 
+	} (padIso97971$1, padIso97971$1.exports));
+	return padIso97971$1.exports;
+}
+
+export { requirePadIso97971 as __require };

package/es/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-nopadding.mjs

@@ -0,0 +1,48 @@
+import '../../../../../_virtual/_commonjsHelpers.mjs';
+import { __module as padNopadding$1 } from '../../../../../_virtual/pad-nopadding.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.mjs';
+
+var padNopadding = padNopadding$1.exports;
+
+var hasRequiredPadNopadding;
+
+function requirePadNopadding () {
+	if (hasRequiredPadNopadding) return padNopadding$1.exports;
+	hasRequiredPadNopadding = 1;
+	(function (module, exports) {
+		;(function (root, factory, undef) {
+			if ('object' === "object") {
+				// CommonJS
+				module.exports = exports = factory(requireCore(), requireCipherCore());
+			}
+			else if (typeof undefined === "function" && undefined.amd) {
+				// AMD
+				undefined(["./core", "./cipher-core"], factory);
+			}
+			else {
+				// Global (browser)
+				factory(root.CryptoJS);
+			}
+		}(padNopadding, function (CryptoJS) {
+
+			/**
+			 * A noop padding strategy.
+			 */
+			CryptoJS.pad.NoPadding = {
+			    pad: function () {
+			    },
+
+			    unpad: function () {
+			    }
+			};
+
+
+			return CryptoJS.pad.NoPadding;
+
+		})); 
+	} (padNopadding$1, padNopadding$1.exports));
+	return padNopadding$1.exports;
+}
+
+export { requirePadNopadding as __require };