From 4c365f7a311a8363657cdd241cc9166c3efcb912 Mon Sep 17 00:00:00 2001 From: Kovid Goyal Date: Wed, 26 Jun 2019 20:56:06 +0530 Subject: [PATCH] Remove the rapydscript stdlib from resources It is now bundled inside the compiler --- resources/rapydscript/lib/aes.pyj | 646 --------------------- resources/rapydscript/lib/elementmaker.pyj | 83 --- resources/rapydscript/lib/encodings.pyj | 126 ---- resources/rapydscript/lib/gettext.pyj | 569 ------------------ resources/rapydscript/lib/math.pyj | 192 ------ resources/rapydscript/lib/operator.pyj | 11 - resources/rapydscript/lib/pythonize.pyj | 20 - resources/rapydscript/lib/random.pyj | 94 --- resources/rapydscript/lib/re.pyj | 472 --------------- resources/rapydscript/lib/traceback.pyj | 51 -- resources/rapydscript/lib/uuid.pyj | 77 --- 11 files changed, 2341 deletions(-) delete mode 100644 resources/rapydscript/lib/aes.pyj delete mode 100644 resources/rapydscript/lib/elementmaker.pyj delete mode 100644 resources/rapydscript/lib/encodings.pyj delete mode 100644 resources/rapydscript/lib/gettext.pyj delete mode 100644 resources/rapydscript/lib/math.pyj delete mode 100644 resources/rapydscript/lib/operator.pyj delete mode 100644 resources/rapydscript/lib/pythonize.pyj delete mode 100644 resources/rapydscript/lib/random.pyj delete mode 100644 resources/rapydscript/lib/re.pyj delete mode 100644 resources/rapydscript/lib/traceback.pyj delete mode 100644 resources/rapydscript/lib/uuid.pyj diff --git a/resources/rapydscript/lib/aes.pyj b/resources/rapydscript/lib/aes.pyj deleted file mode 100644 index 666ed42e9b..0000000000 --- a/resources/rapydscript/lib/aes.pyj +++ /dev/null @@ -1,646 +0,0 @@ -# vim:fileencoding=utf-8 -# License: BSD Copyright: 2016, Kovid Goyal - -# globals: crypto - -# Internal API {{{ - -def string_to_bytes_encoder(string): - return TextEncoder('utf-8').encode(string + '') - -def string_to_bytes_slow(string): - escstr = encodeURIComponent(string) - binstr = escstr.replace(/%([0-9A-F]{2})/g, def(match, p1): - return String.fromCharCode('0x' + p1) - ) - ua = Uint8Array(binstr.length) - for i, ch in enumerate(binstr): - ua[i] = ch.charCodeAt(0) - return ua - -def as_hex(array, sep=''): - num = array.BYTES_PER_ELEMENT or 1 - fmt = '{:0' + num * 2 + 'x}' - return [str.format(fmt, x) for x in array].join(sep) - -def bytes_to_string_decoder(bytes, offset): - offset = offset or 0 - if offset: - bytes = bytes.subarray(offset) - return TextDecoder('utf-8').decode(bytes) - -def bytes_to_string_slow(bytes, offset): - ans = v'[]' - i = offset or 0 - while i < bytes.length: - c = bytes[i] - if c < 128: - ans.push(String.fromCharCode(c)) - i += 1 - elif 191 < c < 224: - ans.push(String.fromCharCode(((c & 0x1f) << 6) | (bytes[i + 1] & 0x3f))) - i += 2 - else: - ans.push(String.fromCharCode(((c & 0x0f) << 12) | ((bytes[i + 1] & 0x3f) << 6) | (bytes[i + 2] & 0x3f))) - i += 3 - return ans.join('') - -string_to_bytes = string_to_bytes_encoder if jstype(TextEncoder) is 'function' else string_to_bytes_slow -bytes_to_string = bytes_to_string_decoder if jstype(TextDecoder) is 'function' else bytes_to_string_slow - -def increment_counter(c): - # c must be a Uint8Array of length 16 - for v'var i = 15; i >= 12; i--': - if c[i] is 255: - c[i] = 0 - else: - c[i] += 1 - break - -def convert_to_int32(bytes, output, offset, length): - offset = offset or 0 - length = length or bytes.length - for v'var i = offset, j = 0; i < offset + length; i += 4, j++': - output[j] = (bytes[i] << 24) | (bytes[i + 1] << 16) | (bytes[i + 2] << 8) | bytes[i + 3] - -def convert_to_int32_pad(bytes): - extra = bytes.length % 4 - if extra: - t = Uint8Array(bytes.length + 4 - extra) - t.set(bytes) - bytes = t - ans = Uint32Array(bytes.length / 4) - convert_to_int32(bytes, ans) - return ans - -if not Uint8Array.prototype.fill: - Uint8Array.prototype.fill = Uint32Array.prototype.fill = def(val, start, end): - start = start or 0 - if end is undefined: - end = this.length - if start < 0: - start += this.length - if end < 0: - end += this.length - for v'var i = start; i < end; i++': - this[i] = val - -def from_64_to_32(num): - # convert 64-bit number to two BE Int32s - ans = Uint32Array(2) - ans[0] = (num / 0x100000000) | 0 - ans[1] = num & 0xFFFFFFFF - return ans - -# Lookup tables for AES {{{ -# Number of rounds by keysize -number_of_rounds = {16: 10, 24: 12, 32: 14} -# Round constant words -rcon = v'new Uint32Array([0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91])' - -# S-box and Inverse S-box (S is for Substitution) -S = v'new Uint32Array([0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16])' -Si = v'new Uint32Array([0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d])' - -# Transformations for encryption -T1 = v'new Uint32Array([0xc66363a5, 0xf87c7c84, 0xee777799, 0xf67b7b8d, 0xfff2f20d, 0xd66b6bbd, 0xde6f6fb1, 0x91c5c554, 0x60303050, 0x02010103, 0xce6767a9, 0x562b2b7d, 0xe7fefe19, 0xb5d7d762, 0x4dababe6, 0xec76769a, 0x8fcaca45, 0x1f82829d, 0x89c9c940, 0xfa7d7d87, 0xeffafa15, 0xb25959eb, 0x8e4747c9, 0xfbf0f00b, 0x41adadec, 0xb3d4d467, 0x5fa2a2fd, 0x45afafea, 0x239c9cbf, 0x53a4a4f7, 0xe4727296, 0x9bc0c05b, 0x75b7b7c2, 0xe1fdfd1c, 0x3d9393ae, 0x4c26266a, 0x6c36365a, 0x7e3f3f41, 0xf5f7f702, 0x83cccc4f, 0x6834345c, 0x51a5a5f4, 0xd1e5e534, 0xf9f1f108, 0xe2717193, 0xabd8d873, 0x62313153, 0x2a15153f, 0x0804040c, 0x95c7c752, 0x46232365, 0x9dc3c35e, 0x30181828, 0x379696a1, 0x0a05050f, 0x2f9a9ab5, 0x0e070709, 0x24121236, 0x1b80809b, 0xdfe2e23d, 0xcdebeb26, 0x4e272769, 0x7fb2b2cd, 0xea75759f, 0x1209091b, 0x1d83839e, 0x582c2c74, 0x341a1a2e, 0x361b1b2d, 0xdc6e6eb2, 0xb45a5aee, 0x5ba0a0fb, 0xa45252f6, 0x763b3b4d, 0xb7d6d661, 0x7db3b3ce, 0x5229297b, 0xdde3e33e, 0x5e2f2f71, 0x13848497, 0xa65353f5, 0xb9d1d168, 0x00000000, 0xc1eded2c, 0x40202060, 0xe3fcfc1f, 0x79b1b1c8, 0xb65b5bed, 0xd46a6abe, 0x8dcbcb46, 0x67bebed9, 0x7239394b, 0x944a4ade, 0x984c4cd4, 0xb05858e8, 0x85cfcf4a, 0xbbd0d06b, 0xc5efef2a, 0x4faaaae5, 0xedfbfb16, 0x864343c5, 0x9a4d4dd7, 0x66333355, 0x11858594, 0x8a4545cf, 0xe9f9f910, 0x04020206, 0xfe7f7f81, 0xa05050f0, 0x783c3c44, 0x259f9fba, 0x4ba8a8e3, 0xa25151f3, 0x5da3a3fe, 0x804040c0, 0x058f8f8a, 0x3f9292ad, 0x219d9dbc, 0x70383848, 0xf1f5f504, 0x63bcbcdf, 0x77b6b6c1, 0xafdada75, 0x42212163, 0x20101030, 0xe5ffff1a, 0xfdf3f30e, 0xbfd2d26d, 0x81cdcd4c, 0x180c0c14, 0x26131335, 0xc3ecec2f, 0xbe5f5fe1, 0x359797a2, 0x884444cc, 0x2e171739, 0x93c4c457, 0x55a7a7f2, 0xfc7e7e82, 0x7a3d3d47, 0xc86464ac, 0xba5d5de7, 0x3219192b, 0xe6737395, 0xc06060a0, 0x19818198, 0x9e4f4fd1, 0xa3dcdc7f, 0x44222266, 0x542a2a7e, 0x3b9090ab, 0x0b888883, 0x8c4646ca, 0xc7eeee29, 0x6bb8b8d3, 0x2814143c, 0xa7dede79, 0xbc5e5ee2, 0x160b0b1d, 0xaddbdb76, 0xdbe0e03b, 0x64323256, 0x743a3a4e, 0x140a0a1e, 0x924949db, 0x0c06060a, 0x4824246c, 0xb85c5ce4, 0x9fc2c25d, 0xbdd3d36e, 0x43acacef, 0xc46262a6, 0x399191a8, 0x319595a4, 0xd3e4e437, 0xf279798b, 0xd5e7e732, 0x8bc8c843, 0x6e373759, 0xda6d6db7, 0x018d8d8c, 0xb1d5d564, 0x9c4e4ed2, 0x49a9a9e0, 0xd86c6cb4, 0xac5656fa, 0xf3f4f407, 0xcfeaea25, 0xca6565af, 0xf47a7a8e, 0x47aeaee9, 0x10080818, 0x6fbabad5, 0xf0787888, 0x4a25256f, 0x5c2e2e72, 0x381c1c24, 0x57a6a6f1, 0x73b4b4c7, 0x97c6c651, 0xcbe8e823, 0xa1dddd7c, 0xe874749c, 0x3e1f1f21, 0x964b4bdd, 0x61bdbddc, 0x0d8b8b86, 0x0f8a8a85, 0xe0707090, 0x7c3e3e42, 0x71b5b5c4, 0xcc6666aa, 0x904848d8, 0x06030305, 0xf7f6f601, 0x1c0e0e12, 0xc26161a3, 0x6a35355f, 0xae5757f9, 0x69b9b9d0, 0x17868691, 0x99c1c158, 0x3a1d1d27, 0x279e9eb9, 0xd9e1e138, 0xebf8f813, 0x2b9898b3, 0x22111133, 0xd26969bb, 0xa9d9d970, 0x078e8e89, 0x339494a7, 0x2d9b9bb6, 0x3c1e1e22, 0x15878792, 0xc9e9e920, 0x87cece49, 0xaa5555ff, 0x50282878, 0xa5dfdf7a, 0x038c8c8f, 0x59a1a1f8, 0x09898980, 0x1a0d0d17, 0x65bfbfda, 0xd7e6e631, 0x844242c6, 0xd06868b8, 0x824141c3, 0x299999b0, 0x5a2d2d77, 0x1e0f0f11, 0x7bb0b0cb, 0xa85454fc, 0x6dbbbbd6, 0x2c16163a])' -T2 = v'new Uint32Array([0xa5c66363, 0x84f87c7c, 0x99ee7777, 0x8df67b7b, 0x0dfff2f2, 0xbdd66b6b, 0xb1de6f6f, 0x5491c5c5, 0x50603030, 0x03020101, 0xa9ce6767, 0x7d562b2b, 0x19e7fefe, 0x62b5d7d7, 0xe64dabab, 0x9aec7676, 0x458fcaca, 0x9d1f8282, 0x4089c9c9, 0x87fa7d7d, 0x15effafa, 0xebb25959, 0xc98e4747, 0x0bfbf0f0, 0xec41adad, 0x67b3d4d4, 0xfd5fa2a2, 0xea45afaf, 0xbf239c9c, 0xf753a4a4, 0x96e47272, 0x5b9bc0c0, 0xc275b7b7, 0x1ce1fdfd, 0xae3d9393, 0x6a4c2626, 0x5a6c3636, 0x417e3f3f, 0x02f5f7f7, 0x4f83cccc, 0x5c683434, 0xf451a5a5, 0x34d1e5e5, 0x08f9f1f1, 0x93e27171, 0x73abd8d8, 0x53623131, 0x3f2a1515, 0x0c080404, 0x5295c7c7, 0x65462323, 0x5e9dc3c3, 0x28301818, 0xa1379696, 0x0f0a0505, 0xb52f9a9a, 0x090e0707, 0x36241212, 0x9b1b8080, 0x3ddfe2e2, 0x26cdebeb, 0x694e2727, 0xcd7fb2b2, 0x9fea7575, 0x1b120909, 0x9e1d8383, 0x74582c2c, 0x2e341a1a, 0x2d361b1b, 0xb2dc6e6e, 0xeeb45a5a, 0xfb5ba0a0, 0xf6a45252, 0x4d763b3b, 0x61b7d6d6, 0xce7db3b3, 0x7b522929, 0x3edde3e3, 0x715e2f2f, 0x97138484, 0xf5a65353, 0x68b9d1d1, 0x00000000, 0x2cc1eded, 0x60402020, 0x1fe3fcfc, 0xc879b1b1, 0xedb65b5b, 0xbed46a6a, 0x468dcbcb, 0xd967bebe, 0x4b723939, 0xde944a4a, 0xd4984c4c, 0xe8b05858, 0x4a85cfcf, 0x6bbbd0d0, 0x2ac5efef, 0xe54faaaa, 0x16edfbfb, 0xc5864343, 0xd79a4d4d, 0x55663333, 0x94118585, 0xcf8a4545, 0x10e9f9f9, 0x06040202, 0x81fe7f7f, 0xf0a05050, 0x44783c3c, 0xba259f9f, 0xe34ba8a8, 0xf3a25151, 0xfe5da3a3, 0xc0804040, 0x8a058f8f, 0xad3f9292, 0xbc219d9d, 0x48703838, 0x04f1f5f5, 0xdf63bcbc, 0xc177b6b6, 0x75afdada, 0x63422121, 0x30201010, 0x1ae5ffff, 0x0efdf3f3, 0x6dbfd2d2, 0x4c81cdcd, 0x14180c0c, 0x35261313, 0x2fc3ecec, 0xe1be5f5f, 0xa2359797, 0xcc884444, 0x392e1717, 0x5793c4c4, 0xf255a7a7, 0x82fc7e7e, 0x477a3d3d, 0xacc86464, 0xe7ba5d5d, 0x2b321919, 0x95e67373, 0xa0c06060, 0x98198181, 0xd19e4f4f, 0x7fa3dcdc, 0x66442222, 0x7e542a2a, 0xab3b9090, 0x830b8888, 0xca8c4646, 0x29c7eeee, 0xd36bb8b8, 0x3c281414, 0x79a7dede, 0xe2bc5e5e, 0x1d160b0b, 0x76addbdb, 0x3bdbe0e0, 0x56643232, 0x4e743a3a, 0x1e140a0a, 0xdb924949, 0x0a0c0606, 0x6c482424, 0xe4b85c5c, 0x5d9fc2c2, 0x6ebdd3d3, 0xef43acac, 0xa6c46262, 0xa8399191, 0xa4319595, 0x37d3e4e4, 0x8bf27979, 0x32d5e7e7, 0x438bc8c8, 0x596e3737, 0xb7da6d6d, 0x8c018d8d, 0x64b1d5d5, 0xd29c4e4e, 0xe049a9a9, 0xb4d86c6c, 0xfaac5656, 0x07f3f4f4, 0x25cfeaea, 0xafca6565, 0x8ef47a7a, 0xe947aeae, 0x18100808, 0xd56fbaba, 0x88f07878, 0x6f4a2525, 0x725c2e2e, 0x24381c1c, 0xf157a6a6, 0xc773b4b4, 0x5197c6c6, 0x23cbe8e8, 0x7ca1dddd, 0x9ce87474, 0x213e1f1f, 0xdd964b4b, 0xdc61bdbd, 0x860d8b8b, 0x850f8a8a, 0x90e07070, 0x427c3e3e, 0xc471b5b5, 0xaacc6666, 0xd8904848, 0x05060303, 0x01f7f6f6, 0x121c0e0e, 0xa3c26161, 0x5f6a3535, 0xf9ae5757, 0xd069b9b9, 0x91178686, 0x5899c1c1, 0x273a1d1d, 0xb9279e9e, 0x38d9e1e1, 0x13ebf8f8, 0xb32b9898, 0x33221111, 0xbbd26969, 0x70a9d9d9, 0x89078e8e, 0xa7339494, 0xb62d9b9b, 0x223c1e1e, 0x92158787, 0x20c9e9e9, 0x4987cece, 0xffaa5555, 0x78502828, 0x7aa5dfdf, 0x8f038c8c, 0xf859a1a1, 0x80098989, 0x171a0d0d, 0xda65bfbf, 0x31d7e6e6, 0xc6844242, 0xb8d06868, 0xc3824141, 0xb0299999, 0x775a2d2d, 0x111e0f0f, 0xcb7bb0b0, 0xfca85454, 0xd66dbbbb, 0x3a2c1616])' -T3 = v'new Uint32Array([0x63a5c663, 0x7c84f87c, 0x7799ee77, 0x7b8df67b, 0xf20dfff2, 0x6bbdd66b, 0x6fb1de6f, 0xc55491c5, 0x30506030, 0x01030201, 0x67a9ce67, 0x2b7d562b, 0xfe19e7fe, 0xd762b5d7, 0xabe64dab, 0x769aec76, 0xca458fca, 0x829d1f82, 0xc94089c9, 0x7d87fa7d, 0xfa15effa, 0x59ebb259, 0x47c98e47, 0xf00bfbf0, 0xadec41ad, 0xd467b3d4, 0xa2fd5fa2, 0xafea45af, 0x9cbf239c, 0xa4f753a4, 0x7296e472, 0xc05b9bc0, 0xb7c275b7, 0xfd1ce1fd, 0x93ae3d93, 0x266a4c26, 0x365a6c36, 0x3f417e3f, 0xf702f5f7, 0xcc4f83cc, 0x345c6834, 0xa5f451a5, 0xe534d1e5, 0xf108f9f1, 0x7193e271, 0xd873abd8, 0x31536231, 0x153f2a15, 0x040c0804, 0xc75295c7, 0x23654623, 0xc35e9dc3, 0x18283018, 0x96a13796, 0x050f0a05, 0x9ab52f9a, 0x07090e07, 0x12362412, 0x809b1b80, 0xe23ddfe2, 0xeb26cdeb, 0x27694e27, 0xb2cd7fb2, 0x759fea75, 0x091b1209, 0x839e1d83, 0x2c74582c, 0x1a2e341a, 0x1b2d361b, 0x6eb2dc6e, 0x5aeeb45a, 0xa0fb5ba0, 0x52f6a452, 0x3b4d763b, 0xd661b7d6, 0xb3ce7db3, 0x297b5229, 0xe33edde3, 0x2f715e2f, 0x84971384, 0x53f5a653, 0xd168b9d1, 0x00000000, 0xed2cc1ed, 0x20604020, 0xfc1fe3fc, 0xb1c879b1, 0x5bedb65b, 0x6abed46a, 0xcb468dcb, 0xbed967be, 0x394b7239, 0x4ade944a, 0x4cd4984c, 0x58e8b058, 0xcf4a85cf, 0xd06bbbd0, 0xef2ac5ef, 0xaae54faa, 0xfb16edfb, 0x43c58643, 0x4dd79a4d, 0x33556633, 0x85941185, 0x45cf8a45, 0xf910e9f9, 0x02060402, 0x7f81fe7f, 0x50f0a050, 0x3c44783c, 0x9fba259f, 0xa8e34ba8, 0x51f3a251, 0xa3fe5da3, 0x40c08040, 0x8f8a058f, 0x92ad3f92, 0x9dbc219d, 0x38487038, 0xf504f1f5, 0xbcdf63bc, 0xb6c177b6, 0xda75afda, 0x21634221, 0x10302010, 0xff1ae5ff, 0xf30efdf3, 0xd26dbfd2, 0xcd4c81cd, 0x0c14180c, 0x13352613, 0xec2fc3ec, 0x5fe1be5f, 0x97a23597, 0x44cc8844, 0x17392e17, 0xc45793c4, 0xa7f255a7, 0x7e82fc7e, 0x3d477a3d, 0x64acc864, 0x5de7ba5d, 0x192b3219, 0x7395e673, 0x60a0c060, 0x81981981, 0x4fd19e4f, 0xdc7fa3dc, 0x22664422, 0x2a7e542a, 0x90ab3b90, 0x88830b88, 0x46ca8c46, 0xee29c7ee, 0xb8d36bb8, 0x143c2814, 0xde79a7de, 0x5ee2bc5e, 0x0b1d160b, 0xdb76addb, 0xe03bdbe0, 0x32566432, 0x3a4e743a, 0x0a1e140a, 0x49db9249, 0x060a0c06, 0x246c4824, 0x5ce4b85c, 0xc25d9fc2, 0xd36ebdd3, 0xacef43ac, 0x62a6c462, 0x91a83991, 0x95a43195, 0xe437d3e4, 0x798bf279, 0xe732d5e7, 0xc8438bc8, 0x37596e37, 0x6db7da6d, 0x8d8c018d, 0xd564b1d5, 0x4ed29c4e, 0xa9e049a9, 0x6cb4d86c, 0x56faac56, 0xf407f3f4, 0xea25cfea, 0x65afca65, 0x7a8ef47a, 0xaee947ae, 0x08181008, 0xbad56fba, 0x7888f078, 0x256f4a25, 0x2e725c2e, 0x1c24381c, 0xa6f157a6, 0xb4c773b4, 0xc65197c6, 0xe823cbe8, 0xdd7ca1dd, 0x749ce874, 0x1f213e1f, 0x4bdd964b, 0xbddc61bd, 0x8b860d8b, 0x8a850f8a, 0x7090e070, 0x3e427c3e, 0xb5c471b5, 0x66aacc66, 0x48d89048, 0x03050603, 0xf601f7f6, 0x0e121c0e, 0x61a3c261, 0x355f6a35, 0x57f9ae57, 0xb9d069b9, 0x86911786, 0xc15899c1, 0x1d273a1d, 0x9eb9279e, 0xe138d9e1, 0xf813ebf8, 0x98b32b98, 0x11332211, 0x69bbd269, 0xd970a9d9, 0x8e89078e, 0x94a73394, 0x9bb62d9b, 0x1e223c1e, 0x87921587, 0xe920c9e9, 0xce4987ce, 0x55ffaa55, 0x28785028, 0xdf7aa5df, 0x8c8f038c, 0xa1f859a1, 0x89800989, 0x0d171a0d, 0xbfda65bf, 0xe631d7e6, 0x42c68442, 0x68b8d068, 0x41c38241, 0x99b02999, 0x2d775a2d, 0x0f111e0f, 0xb0cb7bb0, 0x54fca854, 0xbbd66dbb, 0x163a2c16])' -T4 = v'new Uint32Array([0x6363a5c6, 0x7c7c84f8, 0x777799ee, 0x7b7b8df6, 0xf2f20dff, 0x6b6bbdd6, 0x6f6fb1de, 0xc5c55491, 0x30305060, 0x01010302, 0x6767a9ce, 0x2b2b7d56, 0xfefe19e7, 0xd7d762b5, 0xababe64d, 0x76769aec, 0xcaca458f, 0x82829d1f, 0xc9c94089, 0x7d7d87fa, 0xfafa15ef, 0x5959ebb2, 0x4747c98e, 0xf0f00bfb, 0xadadec41, 0xd4d467b3, 0xa2a2fd5f, 0xafafea45, 0x9c9cbf23, 0xa4a4f753, 0x727296e4, 0xc0c05b9b, 0xb7b7c275, 0xfdfd1ce1, 0x9393ae3d, 0x26266a4c, 0x36365a6c, 0x3f3f417e, 0xf7f702f5, 0xcccc4f83, 0x34345c68, 0xa5a5f451, 0xe5e534d1, 0xf1f108f9, 0x717193e2, 0xd8d873ab, 0x31315362, 0x15153f2a, 0x04040c08, 0xc7c75295, 0x23236546, 0xc3c35e9d, 0x18182830, 0x9696a137, 0x05050f0a, 0x9a9ab52f, 0x0707090e, 0x12123624, 0x80809b1b, 0xe2e23ddf, 0xebeb26cd, 0x2727694e, 0xb2b2cd7f, 0x75759fea, 0x09091b12, 0x83839e1d, 0x2c2c7458, 0x1a1a2e34, 0x1b1b2d36, 0x6e6eb2dc, 0x5a5aeeb4, 0xa0a0fb5b, 0x5252f6a4, 0x3b3b4d76, 0xd6d661b7, 0xb3b3ce7d, 0x29297b52, 0xe3e33edd, 0x2f2f715e, 0x84849713, 0x5353f5a6, 0xd1d168b9, 0x00000000, 0xeded2cc1, 0x20206040, 0xfcfc1fe3, 0xb1b1c879, 0x5b5bedb6, 0x6a6abed4, 0xcbcb468d, 0xbebed967, 0x39394b72, 0x4a4ade94, 0x4c4cd498, 0x5858e8b0, 0xcfcf4a85, 0xd0d06bbb, 0xefef2ac5, 0xaaaae54f, 0xfbfb16ed, 0x4343c586, 0x4d4dd79a, 0x33335566, 0x85859411, 0x4545cf8a, 0xf9f910e9, 0x02020604, 0x7f7f81fe, 0x5050f0a0, 0x3c3c4478, 0x9f9fba25, 0xa8a8e34b, 0x5151f3a2, 0xa3a3fe5d, 0x4040c080, 0x8f8f8a05, 0x9292ad3f, 0x9d9dbc21, 0x38384870, 0xf5f504f1, 0xbcbcdf63, 0xb6b6c177, 0xdada75af, 0x21216342, 0x10103020, 0xffff1ae5, 0xf3f30efd, 0xd2d26dbf, 0xcdcd4c81, 0x0c0c1418, 0x13133526, 0xecec2fc3, 0x5f5fe1be, 0x9797a235, 0x4444cc88, 0x1717392e, 0xc4c45793, 0xa7a7f255, 0x7e7e82fc, 0x3d3d477a, 0x6464acc8, 0x5d5de7ba, 0x19192b32, 0x737395e6, 0x6060a0c0, 0x81819819, 0x4f4fd19e, 0xdcdc7fa3, 0x22226644, 0x2a2a7e54, 0x9090ab3b, 0x8888830b, 0x4646ca8c, 0xeeee29c7, 0xb8b8d36b, 0x14143c28, 0xdede79a7, 0x5e5ee2bc, 0x0b0b1d16, 0xdbdb76ad, 0xe0e03bdb, 0x32325664, 0x3a3a4e74, 0x0a0a1e14, 0x4949db92, 0x06060a0c, 0x24246c48, 0x5c5ce4b8, 0xc2c25d9f, 0xd3d36ebd, 0xacacef43, 0x6262a6c4, 0x9191a839, 0x9595a431, 0xe4e437d3, 0x79798bf2, 0xe7e732d5, 0xc8c8438b, 0x3737596e, 0x6d6db7da, 0x8d8d8c01, 0xd5d564b1, 0x4e4ed29c, 0xa9a9e049, 0x6c6cb4d8, 0x5656faac, 0xf4f407f3, 0xeaea25cf, 0x6565afca, 0x7a7a8ef4, 0xaeaee947, 0x08081810, 0xbabad56f, 0x787888f0, 0x25256f4a, 0x2e2e725c, 0x1c1c2438, 0xa6a6f157, 0xb4b4c773, 0xc6c65197, 0xe8e823cb, 0xdddd7ca1, 0x74749ce8, 0x1f1f213e, 0x4b4bdd96, 0xbdbddc61, 0x8b8b860d, 0x8a8a850f, 0x707090e0, 0x3e3e427c, 0xb5b5c471, 0x6666aacc, 0x4848d890, 0x03030506, 0xf6f601f7, 0x0e0e121c, 0x6161a3c2, 0x35355f6a, 0x5757f9ae, 0xb9b9d069, 0x86869117, 0xc1c15899, 0x1d1d273a, 0x9e9eb927, 0xe1e138d9, 0xf8f813eb, 0x9898b32b, 0x11113322, 0x6969bbd2, 0xd9d970a9, 0x8e8e8907, 0x9494a733, 0x9b9bb62d, 0x1e1e223c, 0x87879215, 0xe9e920c9, 0xcece4987, 0x5555ffaa, 0x28287850, 0xdfdf7aa5, 0x8c8c8f03, 0xa1a1f859, 0x89898009, 0x0d0d171a, 0xbfbfda65, 0xe6e631d7, 0x4242c684, 0x6868b8d0, 0x4141c382, 0x9999b029, 0x2d2d775a, 0x0f0f111e, 0xb0b0cb7b, 0x5454fca8, 0xbbbbd66d, 0x16163a2c])' - -# Transformations for decryption -T5 = v'new Uint32Array([0x51f4a750, 0x7e416553, 0x1a17a4c3, 0x3a275e96, 0x3bab6bcb, 0x1f9d45f1, 0xacfa58ab, 0x4be30393, 0x2030fa55, 0xad766df6, 0x88cc7691, 0xf5024c25, 0x4fe5d7fc, 0xc52acbd7, 0x26354480, 0xb562a38f, 0xdeb15a49, 0x25ba1b67, 0x45ea0e98, 0x5dfec0e1, 0xc32f7502, 0x814cf012, 0x8d4697a3, 0x6bd3f9c6, 0x038f5fe7, 0x15929c95, 0xbf6d7aeb, 0x955259da, 0xd4be832d, 0x587421d3, 0x49e06929, 0x8ec9c844, 0x75c2896a, 0xf48e7978, 0x99583e6b, 0x27b971dd, 0xbee14fb6, 0xf088ad17, 0xc920ac66, 0x7dce3ab4, 0x63df4a18, 0xe51a3182, 0x97513360, 0x62537f45, 0xb16477e0, 0xbb6bae84, 0xfe81a01c, 0xf9082b94, 0x70486858, 0x8f45fd19, 0x94de6c87, 0x527bf8b7, 0xab73d323, 0x724b02e2, 0xe31f8f57, 0x6655ab2a, 0xb2eb2807, 0x2fb5c203, 0x86c57b9a, 0xd33708a5, 0x302887f2, 0x23bfa5b2, 0x02036aba, 0xed16825c, 0x8acf1c2b, 0xa779b492, 0xf307f2f0, 0x4e69e2a1, 0x65daf4cd, 0x0605bed5, 0xd134621f, 0xc4a6fe8a, 0x342e539d, 0xa2f355a0, 0x058ae132, 0xa4f6eb75, 0x0b83ec39, 0x4060efaa, 0x5e719f06, 0xbd6e1051, 0x3e218af9, 0x96dd063d, 0xdd3e05ae, 0x4de6bd46, 0x91548db5, 0x71c45d05, 0x0406d46f, 0x605015ff, 0x1998fb24, 0xd6bde997, 0x894043cc, 0x67d99e77, 0xb0e842bd, 0x07898b88, 0xe7195b38, 0x79c8eedb, 0xa17c0a47, 0x7c420fe9, 0xf8841ec9, 0x00000000, 0x09808683, 0x322bed48, 0x1e1170ac, 0x6c5a724e, 0xfd0efffb, 0x0f853856, 0x3daed51e, 0x362d3927, 0x0a0fd964, 0x685ca621, 0x9b5b54d1, 0x24362e3a, 0x0c0a67b1, 0x9357e70f, 0xb4ee96d2, 0x1b9b919e, 0x80c0c54f, 0x61dc20a2, 0x5a774b69, 0x1c121a16, 0xe293ba0a, 0xc0a02ae5, 0x3c22e043, 0x121b171d, 0x0e090d0b, 0xf28bc7ad, 0x2db6a8b9, 0x141ea9c8, 0x57f11985, 0xaf75074c, 0xee99ddbb, 0xa37f60fd, 0xf701269f, 0x5c72f5bc, 0x44663bc5, 0x5bfb7e34, 0x8b432976, 0xcb23c6dc, 0xb6edfc68, 0xb8e4f163, 0xd731dcca, 0x42638510, 0x13972240, 0x84c61120, 0x854a247d, 0xd2bb3df8, 0xaef93211, 0xc729a16d, 0x1d9e2f4b, 0xdcb230f3, 0x0d8652ec, 0x77c1e3d0, 0x2bb3166c, 0xa970b999, 0x119448fa, 0x47e96422, 0xa8fc8cc4, 0xa0f03f1a, 0x567d2cd8, 0x223390ef, 0x87494ec7, 0xd938d1c1, 0x8ccaa2fe, 0x98d40b36, 0xa6f581cf, 0xa57ade28, 0xdab78e26, 0x3fadbfa4, 0x2c3a9de4, 0x5078920d, 0x6a5fcc9b, 0x547e4662, 0xf68d13c2, 0x90d8b8e8, 0x2e39f75e, 0x82c3aff5, 0x9f5d80be, 0x69d0937c, 0x6fd52da9, 0xcf2512b3, 0xc8ac993b, 0x10187da7, 0xe89c636e, 0xdb3bbb7b, 0xcd267809, 0x6e5918f4, 0xec9ab701, 0x834f9aa8, 0xe6956e65, 0xaaffe67e, 0x21bccf08, 0xef15e8e6, 0xbae79bd9, 0x4a6f36ce, 0xea9f09d4, 0x29b07cd6, 0x31a4b2af, 0x2a3f2331, 0xc6a59430, 0x35a266c0, 0x744ebc37, 0xfc82caa6, 0xe090d0b0, 0x33a7d815, 0xf104984a, 0x41ecdaf7, 0x7fcd500e, 0x1791f62f, 0x764dd68d, 0x43efb04d, 0xccaa4d54, 0xe49604df, 0x9ed1b5e3, 0x4c6a881b, 0xc12c1fb8, 0x4665517f, 0x9d5eea04, 0x018c355d, 0xfa877473, 0xfb0b412e, 0xb3671d5a, 0x92dbd252, 0xe9105633, 0x6dd64713, 0x9ad7618c, 0x37a10c7a, 0x59f8148e, 0xeb133c89, 0xcea927ee, 0xb761c935, 0xe11ce5ed, 0x7a47b13c, 0x9cd2df59, 0x55f2733f, 0x1814ce79, 0x73c737bf, 0x53f7cdea, 0x5ffdaa5b, 0xdf3d6f14, 0x7844db86, 0xcaaff381, 0xb968c43e, 0x3824342c, 0xc2a3405f, 0x161dc372, 0xbce2250c, 0x283c498b, 0xff0d9541, 0x39a80171, 0x080cb3de, 0xd8b4e49c, 0x6456c190, 0x7bcb8461, 0xd532b670, 0x486c5c74, 0xd0b85742])' -T6 = v'new Uint32Array([0x5051f4a7, 0x537e4165, 0xc31a17a4, 0x963a275e, 0xcb3bab6b, 0xf11f9d45, 0xabacfa58, 0x934be303, 0x552030fa, 0xf6ad766d, 0x9188cc76, 0x25f5024c, 0xfc4fe5d7, 0xd7c52acb, 0x80263544, 0x8fb562a3, 0x49deb15a, 0x6725ba1b, 0x9845ea0e, 0xe15dfec0, 0x02c32f75, 0x12814cf0, 0xa38d4697, 0xc66bd3f9, 0xe7038f5f, 0x9515929c, 0xebbf6d7a, 0xda955259, 0x2dd4be83, 0xd3587421, 0x2949e069, 0x448ec9c8, 0x6a75c289, 0x78f48e79, 0x6b99583e, 0xdd27b971, 0xb6bee14f, 0x17f088ad, 0x66c920ac, 0xb47dce3a, 0x1863df4a, 0x82e51a31, 0x60975133, 0x4562537f, 0xe0b16477, 0x84bb6bae, 0x1cfe81a0, 0x94f9082b, 0x58704868, 0x198f45fd, 0x8794de6c, 0xb7527bf8, 0x23ab73d3, 0xe2724b02, 0x57e31f8f, 0x2a6655ab, 0x07b2eb28, 0x032fb5c2, 0x9a86c57b, 0xa5d33708, 0xf2302887, 0xb223bfa5, 0xba02036a, 0x5ced1682, 0x2b8acf1c, 0x92a779b4, 0xf0f307f2, 0xa14e69e2, 0xcd65daf4, 0xd50605be, 0x1fd13462, 0x8ac4a6fe, 0x9d342e53, 0xa0a2f355, 0x32058ae1, 0x75a4f6eb, 0x390b83ec, 0xaa4060ef, 0x065e719f, 0x51bd6e10, 0xf93e218a, 0x3d96dd06, 0xaedd3e05, 0x464de6bd, 0xb591548d, 0x0571c45d, 0x6f0406d4, 0xff605015, 0x241998fb, 0x97d6bde9, 0xcc894043, 0x7767d99e, 0xbdb0e842, 0x8807898b, 0x38e7195b, 0xdb79c8ee, 0x47a17c0a, 0xe97c420f, 0xc9f8841e, 0x00000000, 0x83098086, 0x48322bed, 0xac1e1170, 0x4e6c5a72, 0xfbfd0eff, 0x560f8538, 0x1e3daed5, 0x27362d39, 0x640a0fd9, 0x21685ca6, 0xd19b5b54, 0x3a24362e, 0xb10c0a67, 0x0f9357e7, 0xd2b4ee96, 0x9e1b9b91, 0x4f80c0c5, 0xa261dc20, 0x695a774b, 0x161c121a, 0x0ae293ba, 0xe5c0a02a, 0x433c22e0, 0x1d121b17, 0x0b0e090d, 0xadf28bc7, 0xb92db6a8, 0xc8141ea9, 0x8557f119, 0x4caf7507, 0xbbee99dd, 0xfda37f60, 0x9ff70126, 0xbc5c72f5, 0xc544663b, 0x345bfb7e, 0x768b4329, 0xdccb23c6, 0x68b6edfc, 0x63b8e4f1, 0xcad731dc, 0x10426385, 0x40139722, 0x2084c611, 0x7d854a24, 0xf8d2bb3d, 0x11aef932, 0x6dc729a1, 0x4b1d9e2f, 0xf3dcb230, 0xec0d8652, 0xd077c1e3, 0x6c2bb316, 0x99a970b9, 0xfa119448, 0x2247e964, 0xc4a8fc8c, 0x1aa0f03f, 0xd8567d2c, 0xef223390, 0xc787494e, 0xc1d938d1, 0xfe8ccaa2, 0x3698d40b, 0xcfa6f581, 0x28a57ade, 0x26dab78e, 0xa43fadbf, 0xe42c3a9d, 0x0d507892, 0x9b6a5fcc, 0x62547e46, 0xc2f68d13, 0xe890d8b8, 0x5e2e39f7, 0xf582c3af, 0xbe9f5d80, 0x7c69d093, 0xa96fd52d, 0xb3cf2512, 0x3bc8ac99, 0xa710187d, 0x6ee89c63, 0x7bdb3bbb, 0x09cd2678, 0xf46e5918, 0x01ec9ab7, 0xa8834f9a, 0x65e6956e, 0x7eaaffe6, 0x0821bccf, 0xe6ef15e8, 0xd9bae79b, 0xce4a6f36, 0xd4ea9f09, 0xd629b07c, 0xaf31a4b2, 0x312a3f23, 0x30c6a594, 0xc035a266, 0x37744ebc, 0xa6fc82ca, 0xb0e090d0, 0x1533a7d8, 0x4af10498, 0xf741ecda, 0x0e7fcd50, 0x2f1791f6, 0x8d764dd6, 0x4d43efb0, 0x54ccaa4d, 0xdfe49604, 0xe39ed1b5, 0x1b4c6a88, 0xb8c12c1f, 0x7f466551, 0x049d5eea, 0x5d018c35, 0x73fa8774, 0x2efb0b41, 0x5ab3671d, 0x5292dbd2, 0x33e91056, 0x136dd647, 0x8c9ad761, 0x7a37a10c, 0x8e59f814, 0x89eb133c, 0xeecea927, 0x35b761c9, 0xede11ce5, 0x3c7a47b1, 0x599cd2df, 0x3f55f273, 0x791814ce, 0xbf73c737, 0xea53f7cd, 0x5b5ffdaa, 0x14df3d6f, 0x867844db, 0x81caaff3, 0x3eb968c4, 0x2c382434, 0x5fc2a340, 0x72161dc3, 0x0cbce225, 0x8b283c49, 0x41ff0d95, 0x7139a801, 0xde080cb3, 0x9cd8b4e4, 0x906456c1, 0x617bcb84, 0x70d532b6, 0x74486c5c, 0x42d0b857])' -T7 = v'new Uint32Array([0xa75051f4, 0x65537e41, 0xa4c31a17, 0x5e963a27, 0x6bcb3bab, 0x45f11f9d, 0x58abacfa, 0x03934be3, 0xfa552030, 0x6df6ad76, 0x769188cc, 0x4c25f502, 0xd7fc4fe5, 0xcbd7c52a, 0x44802635, 0xa38fb562, 0x5a49deb1, 0x1b6725ba, 0x0e9845ea, 0xc0e15dfe, 0x7502c32f, 0xf012814c, 0x97a38d46, 0xf9c66bd3, 0x5fe7038f, 0x9c951592, 0x7aebbf6d, 0x59da9552, 0x832dd4be, 0x21d35874, 0x692949e0, 0xc8448ec9, 0x896a75c2, 0x7978f48e, 0x3e6b9958, 0x71dd27b9, 0x4fb6bee1, 0xad17f088, 0xac66c920, 0x3ab47dce, 0x4a1863df, 0x3182e51a, 0x33609751, 0x7f456253, 0x77e0b164, 0xae84bb6b, 0xa01cfe81, 0x2b94f908, 0x68587048, 0xfd198f45, 0x6c8794de, 0xf8b7527b, 0xd323ab73, 0x02e2724b, 0x8f57e31f, 0xab2a6655, 0x2807b2eb, 0xc2032fb5, 0x7b9a86c5, 0x08a5d337, 0x87f23028, 0xa5b223bf, 0x6aba0203, 0x825ced16, 0x1c2b8acf, 0xb492a779, 0xf2f0f307, 0xe2a14e69, 0xf4cd65da, 0xbed50605, 0x621fd134, 0xfe8ac4a6, 0x539d342e, 0x55a0a2f3, 0xe132058a, 0xeb75a4f6, 0xec390b83, 0xefaa4060, 0x9f065e71, 0x1051bd6e, 0x8af93e21, 0x063d96dd, 0x05aedd3e, 0xbd464de6, 0x8db59154, 0x5d0571c4, 0xd46f0406, 0x15ff6050, 0xfb241998, 0xe997d6bd, 0x43cc8940, 0x9e7767d9, 0x42bdb0e8, 0x8b880789, 0x5b38e719, 0xeedb79c8, 0x0a47a17c, 0x0fe97c42, 0x1ec9f884, 0x00000000, 0x86830980, 0xed48322b, 0x70ac1e11, 0x724e6c5a, 0xfffbfd0e, 0x38560f85, 0xd51e3dae, 0x3927362d, 0xd9640a0f, 0xa621685c, 0x54d19b5b, 0x2e3a2436, 0x67b10c0a, 0xe70f9357, 0x96d2b4ee, 0x919e1b9b, 0xc54f80c0, 0x20a261dc, 0x4b695a77, 0x1a161c12, 0xba0ae293, 0x2ae5c0a0, 0xe0433c22, 0x171d121b, 0x0d0b0e09, 0xc7adf28b, 0xa8b92db6, 0xa9c8141e, 0x198557f1, 0x074caf75, 0xddbbee99, 0x60fda37f, 0x269ff701, 0xf5bc5c72, 0x3bc54466, 0x7e345bfb, 0x29768b43, 0xc6dccb23, 0xfc68b6ed, 0xf163b8e4, 0xdccad731, 0x85104263, 0x22401397, 0x112084c6, 0x247d854a, 0x3df8d2bb, 0x3211aef9, 0xa16dc729, 0x2f4b1d9e, 0x30f3dcb2, 0x52ec0d86, 0xe3d077c1, 0x166c2bb3, 0xb999a970, 0x48fa1194, 0x642247e9, 0x8cc4a8fc, 0x3f1aa0f0, 0x2cd8567d, 0x90ef2233, 0x4ec78749, 0xd1c1d938, 0xa2fe8cca, 0x0b3698d4, 0x81cfa6f5, 0xde28a57a, 0x8e26dab7, 0xbfa43fad, 0x9de42c3a, 0x920d5078, 0xcc9b6a5f, 0x4662547e, 0x13c2f68d, 0xb8e890d8, 0xf75e2e39, 0xaff582c3, 0x80be9f5d, 0x937c69d0, 0x2da96fd5, 0x12b3cf25, 0x993bc8ac, 0x7da71018, 0x636ee89c, 0xbb7bdb3b, 0x7809cd26, 0x18f46e59, 0xb701ec9a, 0x9aa8834f, 0x6e65e695, 0xe67eaaff, 0xcf0821bc, 0xe8e6ef15, 0x9bd9bae7, 0x36ce4a6f, 0x09d4ea9f, 0x7cd629b0, 0xb2af31a4, 0x23312a3f, 0x9430c6a5, 0x66c035a2, 0xbc37744e, 0xcaa6fc82, 0xd0b0e090, 0xd81533a7, 0x984af104, 0xdaf741ec, 0x500e7fcd, 0xf62f1791, 0xd68d764d, 0xb04d43ef, 0x4d54ccaa, 0x04dfe496, 0xb5e39ed1, 0x881b4c6a, 0x1fb8c12c, 0x517f4665, 0xea049d5e, 0x355d018c, 0x7473fa87, 0x412efb0b, 0x1d5ab367, 0xd25292db, 0x5633e910, 0x47136dd6, 0x618c9ad7, 0x0c7a37a1, 0x148e59f8, 0x3c89eb13, 0x27eecea9, 0xc935b761, 0xe5ede11c, 0xb13c7a47, 0xdf599cd2, 0x733f55f2, 0xce791814, 0x37bf73c7, 0xcdea53f7, 0xaa5b5ffd, 0x6f14df3d, 0xdb867844, 0xf381caaf, 0xc43eb968, 0x342c3824, 0x405fc2a3, 0xc372161d, 0x250cbce2, 0x498b283c, 0x9541ff0d, 0x017139a8, 0xb3de080c, 0xe49cd8b4, 0xc1906456, 0x84617bcb, 0xb670d532, 0x5c74486c, 0x5742d0b8])' -T8 = v'new Uint32Array([0xf4a75051, 0x4165537e, 0x17a4c31a, 0x275e963a, 0xab6bcb3b, 0x9d45f11f, 0xfa58abac, 0xe303934b, 0x30fa5520, 0x766df6ad, 0xcc769188, 0x024c25f5, 0xe5d7fc4f, 0x2acbd7c5, 0x35448026, 0x62a38fb5, 0xb15a49de, 0xba1b6725, 0xea0e9845, 0xfec0e15d, 0x2f7502c3, 0x4cf01281, 0x4697a38d, 0xd3f9c66b, 0x8f5fe703, 0x929c9515, 0x6d7aebbf, 0x5259da95, 0xbe832dd4, 0x7421d358, 0xe0692949, 0xc9c8448e, 0xc2896a75, 0x8e7978f4, 0x583e6b99, 0xb971dd27, 0xe14fb6be, 0x88ad17f0, 0x20ac66c9, 0xce3ab47d, 0xdf4a1863, 0x1a3182e5, 0x51336097, 0x537f4562, 0x6477e0b1, 0x6bae84bb, 0x81a01cfe, 0x082b94f9, 0x48685870, 0x45fd198f, 0xde6c8794, 0x7bf8b752, 0x73d323ab, 0x4b02e272, 0x1f8f57e3, 0x55ab2a66, 0xeb2807b2, 0xb5c2032f, 0xc57b9a86, 0x3708a5d3, 0x2887f230, 0xbfa5b223, 0x036aba02, 0x16825ced, 0xcf1c2b8a, 0x79b492a7, 0x07f2f0f3, 0x69e2a14e, 0xdaf4cd65, 0x05bed506, 0x34621fd1, 0xa6fe8ac4, 0x2e539d34, 0xf355a0a2, 0x8ae13205, 0xf6eb75a4, 0x83ec390b, 0x60efaa40, 0x719f065e, 0x6e1051bd, 0x218af93e, 0xdd063d96, 0x3e05aedd, 0xe6bd464d, 0x548db591, 0xc45d0571, 0x06d46f04, 0x5015ff60, 0x98fb2419, 0xbde997d6, 0x4043cc89, 0xd99e7767, 0xe842bdb0, 0x898b8807, 0x195b38e7, 0xc8eedb79, 0x7c0a47a1, 0x420fe97c, 0x841ec9f8, 0x00000000, 0x80868309, 0x2bed4832, 0x1170ac1e, 0x5a724e6c, 0x0efffbfd, 0x8538560f, 0xaed51e3d, 0x2d392736, 0x0fd9640a, 0x5ca62168, 0x5b54d19b, 0x362e3a24, 0x0a67b10c, 0x57e70f93, 0xee96d2b4, 0x9b919e1b, 0xc0c54f80, 0xdc20a261, 0x774b695a, 0x121a161c, 0x93ba0ae2, 0xa02ae5c0, 0x22e0433c, 0x1b171d12, 0x090d0b0e, 0x8bc7adf2, 0xb6a8b92d, 0x1ea9c814, 0xf1198557, 0x75074caf, 0x99ddbbee, 0x7f60fda3, 0x01269ff7, 0x72f5bc5c, 0x663bc544, 0xfb7e345b, 0x4329768b, 0x23c6dccb, 0xedfc68b6, 0xe4f163b8, 0x31dccad7, 0x63851042, 0x97224013, 0xc6112084, 0x4a247d85, 0xbb3df8d2, 0xf93211ae, 0x29a16dc7, 0x9e2f4b1d, 0xb230f3dc, 0x8652ec0d, 0xc1e3d077, 0xb3166c2b, 0x70b999a9, 0x9448fa11, 0xe9642247, 0xfc8cc4a8, 0xf03f1aa0, 0x7d2cd856, 0x3390ef22, 0x494ec787, 0x38d1c1d9, 0xcaa2fe8c, 0xd40b3698, 0xf581cfa6, 0x7ade28a5, 0xb78e26da, 0xadbfa43f, 0x3a9de42c, 0x78920d50, 0x5fcc9b6a, 0x7e466254, 0x8d13c2f6, 0xd8b8e890, 0x39f75e2e, 0xc3aff582, 0x5d80be9f, 0xd0937c69, 0xd52da96f, 0x2512b3cf, 0xac993bc8, 0x187da710, 0x9c636ee8, 0x3bbb7bdb, 0x267809cd, 0x5918f46e, 0x9ab701ec, 0x4f9aa883, 0x956e65e6, 0xffe67eaa, 0xbccf0821, 0x15e8e6ef, 0xe79bd9ba, 0x6f36ce4a, 0x9f09d4ea, 0xb07cd629, 0xa4b2af31, 0x3f23312a, 0xa59430c6, 0xa266c035, 0x4ebc3774, 0x82caa6fc, 0x90d0b0e0, 0xa7d81533, 0x04984af1, 0xecdaf741, 0xcd500e7f, 0x91f62f17, 0x4dd68d76, 0xefb04d43, 0xaa4d54cc, 0x9604dfe4, 0xd1b5e39e, 0x6a881b4c, 0x2c1fb8c1, 0x65517f46, 0x5eea049d, 0x8c355d01, 0x877473fa, 0x0b412efb, 0x671d5ab3, 0xdbd25292, 0x105633e9, 0xd647136d, 0xd7618c9a, 0xa10c7a37, 0xf8148e59, 0x133c89eb, 0xa927eece, 0x61c935b7, 0x1ce5ede1, 0x47b13c7a, 0xd2df599c, 0xf2733f55, 0x14ce7918, 0xc737bf73, 0xf7cdea53, 0xfdaa5b5f, 0x3d6f14df, 0x44db8678, 0xaff381ca, 0x68c43eb9, 0x24342c38, 0xa3405fc2, 0x1dc37216, 0xe2250cbc, 0x3c498b28, 0x0d9541ff, 0xa8017139, 0x0cb3de08, 0xb4e49cd8, 0x56c19064, 0xcb84617b, 0x32b670d5, 0x6c5c7448, 0xb85742d0])' - -# Transformations for decryption key expansion -U1 = v'new Uint32Array([0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927, 0x24362e3a, 0x2a3f2331, 0x70486858, 0x7e416553, 0x6c5a724e, 0x62537f45, 0x486c5c74, 0x4665517f, 0x547e4662, 0x5a774b69, 0xe090d0b0, 0xee99ddbb, 0xfc82caa6, 0xf28bc7ad, 0xd8b4e49c, 0xd6bde997, 0xc4a6fe8a, 0xcaaff381, 0x90d8b8e8, 0x9ed1b5e3, 0x8ccaa2fe, 0x82c3aff5, 0xa8fc8cc4, 0xa6f581cf, 0xb4ee96d2, 0xbae79bd9, 0xdb3bbb7b, 0xd532b670, 0xc729a16d, 0xc920ac66, 0xe31f8f57, 0xed16825c, 0xff0d9541, 0xf104984a, 0xab73d323, 0xa57ade28, 0xb761c935, 0xb968c43e, 0x9357e70f, 0x9d5eea04, 0x8f45fd19, 0x814cf012, 0x3bab6bcb, 0x35a266c0, 0x27b971dd, 0x29b07cd6, 0x038f5fe7, 0x0d8652ec, 0x1f9d45f1, 0x119448fa, 0x4be30393, 0x45ea0e98, 0x57f11985, 0x59f8148e, 0x73c737bf, 0x7dce3ab4, 0x6fd52da9, 0x61dc20a2, 0xad766df6, 0xa37f60fd, 0xb16477e0, 0xbf6d7aeb, 0x955259da, 0x9b5b54d1, 0x894043cc, 0x87494ec7, 0xdd3e05ae, 0xd33708a5, 0xc12c1fb8, 0xcf2512b3, 0xe51a3182, 0xeb133c89, 0xf9082b94, 0xf701269f, 0x4de6bd46, 0x43efb04d, 0x51f4a750, 0x5ffdaa5b, 0x75c2896a, 0x7bcb8461, 0x69d0937c, 0x67d99e77, 0x3daed51e, 0x33a7d815, 0x21bccf08, 0x2fb5c203, 0x058ae132, 0x0b83ec39, 0x1998fb24, 0x1791f62f, 0x764dd68d, 0x7844db86, 0x6a5fcc9b, 0x6456c190, 0x4e69e2a1, 0x4060efaa, 0x527bf8b7, 0x5c72f5bc, 0x0605bed5, 0x080cb3de, 0x1a17a4c3, 0x141ea9c8, 0x3e218af9, 0x302887f2, 0x223390ef, 0x2c3a9de4, 0x96dd063d, 0x98d40b36, 0x8acf1c2b, 0x84c61120, 0xaef93211, 0xa0f03f1a, 0xb2eb2807, 0xbce2250c, 0xe6956e65, 0xe89c636e, 0xfa877473, 0xf48e7978, 0xdeb15a49, 0xd0b85742, 0xc2a3405f, 0xccaa4d54, 0x41ecdaf7, 0x4fe5d7fc, 0x5dfec0e1, 0x53f7cdea, 0x79c8eedb, 0x77c1e3d0, 0x65daf4cd, 0x6bd3f9c6, 0x31a4b2af, 0x3fadbfa4, 0x2db6a8b9, 0x23bfa5b2, 0x09808683, 0x07898b88, 0x15929c95, 0x1b9b919e, 0xa17c0a47, 0xaf75074c, 0xbd6e1051, 0xb3671d5a, 0x99583e6b, 0x97513360, 0x854a247d, 0x8b432976, 0xd134621f, 0xdf3d6f14, 0xcd267809, 0xc32f7502, 0xe9105633, 0xe7195b38, 0xf5024c25, 0xfb0b412e, 0x9ad7618c, 0x94de6c87, 0x86c57b9a, 0x88cc7691, 0xa2f355a0, 0xacfa58ab, 0xbee14fb6, 0xb0e842bd, 0xea9f09d4, 0xe49604df, 0xf68d13c2, 0xf8841ec9, 0xd2bb3df8, 0xdcb230f3, 0xcea927ee, 0xc0a02ae5, 0x7a47b13c, 0x744ebc37, 0x6655ab2a, 0x685ca621, 0x42638510, 0x4c6a881b, 0x5e719f06, 0x5078920d, 0x0a0fd964, 0x0406d46f, 0x161dc372, 0x1814ce79, 0x322bed48, 0x3c22e043, 0x2e39f75e, 0x2030fa55, 0xec9ab701, 0xe293ba0a, 0xf088ad17, 0xfe81a01c, 0xd4be832d, 0xdab78e26, 0xc8ac993b, 0xc6a59430, 0x9cd2df59, 0x92dbd252, 0x80c0c54f, 0x8ec9c844, 0xa4f6eb75, 0xaaffe67e, 0xb8e4f163, 0xb6edfc68, 0x0c0a67b1, 0x02036aba, 0x10187da7, 0x1e1170ac, 0x342e539d, 0x3a275e96, 0x283c498b, 0x26354480, 0x7c420fe9, 0x724b02e2, 0x605015ff, 0x6e5918f4, 0x44663bc5, 0x4a6f36ce, 0x587421d3, 0x567d2cd8, 0x37a10c7a, 0x39a80171, 0x2bb3166c, 0x25ba1b67, 0x0f853856, 0x018c355d, 0x13972240, 0x1d9e2f4b, 0x47e96422, 0x49e06929, 0x5bfb7e34, 0x55f2733f, 0x7fcd500e, 0x71c45d05, 0x63df4a18, 0x6dd64713, 0xd731dcca, 0xd938d1c1, 0xcb23c6dc, 0xc52acbd7, 0xef15e8e6, 0xe11ce5ed, 0xf307f2f0, 0xfd0efffb, 0xa779b492, 0xa970b999, 0xbb6bae84, 0xb562a38f, 0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3])' -U2 = v'new Uint32Array([0x00000000, 0x0b0e090d, 0x161c121a, 0x1d121b17, 0x2c382434, 0x27362d39, 0x3a24362e, 0x312a3f23, 0x58704868, 0x537e4165, 0x4e6c5a72, 0x4562537f, 0x74486c5c, 0x7f466551, 0x62547e46, 0x695a774b, 0xb0e090d0, 0xbbee99dd, 0xa6fc82ca, 0xadf28bc7, 0x9cd8b4e4, 0x97d6bde9, 0x8ac4a6fe, 0x81caaff3, 0xe890d8b8, 0xe39ed1b5, 0xfe8ccaa2, 0xf582c3af, 0xc4a8fc8c, 0xcfa6f581, 0xd2b4ee96, 0xd9bae79b, 0x7bdb3bbb, 0x70d532b6, 0x6dc729a1, 0x66c920ac, 0x57e31f8f, 0x5ced1682, 0x41ff0d95, 0x4af10498, 0x23ab73d3, 0x28a57ade, 0x35b761c9, 0x3eb968c4, 0x0f9357e7, 0x049d5eea, 0x198f45fd, 0x12814cf0, 0xcb3bab6b, 0xc035a266, 0xdd27b971, 0xd629b07c, 0xe7038f5f, 0xec0d8652, 0xf11f9d45, 0xfa119448, 0x934be303, 0x9845ea0e, 0x8557f119, 0x8e59f814, 0xbf73c737, 0xb47dce3a, 0xa96fd52d, 0xa261dc20, 0xf6ad766d, 0xfda37f60, 0xe0b16477, 0xebbf6d7a, 0xda955259, 0xd19b5b54, 0xcc894043, 0xc787494e, 0xaedd3e05, 0xa5d33708, 0xb8c12c1f, 0xb3cf2512, 0x82e51a31, 0x89eb133c, 0x94f9082b, 0x9ff70126, 0x464de6bd, 0x4d43efb0, 0x5051f4a7, 0x5b5ffdaa, 0x6a75c289, 0x617bcb84, 0x7c69d093, 0x7767d99e, 0x1e3daed5, 0x1533a7d8, 0x0821bccf, 0x032fb5c2, 0x32058ae1, 0x390b83ec, 0x241998fb, 0x2f1791f6, 0x8d764dd6, 0x867844db, 0x9b6a5fcc, 0x906456c1, 0xa14e69e2, 0xaa4060ef, 0xb7527bf8, 0xbc5c72f5, 0xd50605be, 0xde080cb3, 0xc31a17a4, 0xc8141ea9, 0xf93e218a, 0xf2302887, 0xef223390, 0xe42c3a9d, 0x3d96dd06, 0x3698d40b, 0x2b8acf1c, 0x2084c611, 0x11aef932, 0x1aa0f03f, 0x07b2eb28, 0x0cbce225, 0x65e6956e, 0x6ee89c63, 0x73fa8774, 0x78f48e79, 0x49deb15a, 0x42d0b857, 0x5fc2a340, 0x54ccaa4d, 0xf741ecda, 0xfc4fe5d7, 0xe15dfec0, 0xea53f7cd, 0xdb79c8ee, 0xd077c1e3, 0xcd65daf4, 0xc66bd3f9, 0xaf31a4b2, 0xa43fadbf, 0xb92db6a8, 0xb223bfa5, 0x83098086, 0x8807898b, 0x9515929c, 0x9e1b9b91, 0x47a17c0a, 0x4caf7507, 0x51bd6e10, 0x5ab3671d, 0x6b99583e, 0x60975133, 0x7d854a24, 0x768b4329, 0x1fd13462, 0x14df3d6f, 0x09cd2678, 0x02c32f75, 0x33e91056, 0x38e7195b, 0x25f5024c, 0x2efb0b41, 0x8c9ad761, 0x8794de6c, 0x9a86c57b, 0x9188cc76, 0xa0a2f355, 0xabacfa58, 0xb6bee14f, 0xbdb0e842, 0xd4ea9f09, 0xdfe49604, 0xc2f68d13, 0xc9f8841e, 0xf8d2bb3d, 0xf3dcb230, 0xeecea927, 0xe5c0a02a, 0x3c7a47b1, 0x37744ebc, 0x2a6655ab, 0x21685ca6, 0x10426385, 0x1b4c6a88, 0x065e719f, 0x0d507892, 0x640a0fd9, 0x6f0406d4, 0x72161dc3, 0x791814ce, 0x48322bed, 0x433c22e0, 0x5e2e39f7, 0x552030fa, 0x01ec9ab7, 0x0ae293ba, 0x17f088ad, 0x1cfe81a0, 0x2dd4be83, 0x26dab78e, 0x3bc8ac99, 0x30c6a594, 0x599cd2df, 0x5292dbd2, 0x4f80c0c5, 0x448ec9c8, 0x75a4f6eb, 0x7eaaffe6, 0x63b8e4f1, 0x68b6edfc, 0xb10c0a67, 0xba02036a, 0xa710187d, 0xac1e1170, 0x9d342e53, 0x963a275e, 0x8b283c49, 0x80263544, 0xe97c420f, 0xe2724b02, 0xff605015, 0xf46e5918, 0xc544663b, 0xce4a6f36, 0xd3587421, 0xd8567d2c, 0x7a37a10c, 0x7139a801, 0x6c2bb316, 0x6725ba1b, 0x560f8538, 0x5d018c35, 0x40139722, 0x4b1d9e2f, 0x2247e964, 0x2949e069, 0x345bfb7e, 0x3f55f273, 0x0e7fcd50, 0x0571c45d, 0x1863df4a, 0x136dd647, 0xcad731dc, 0xc1d938d1, 0xdccb23c6, 0xd7c52acb, 0xe6ef15e8, 0xede11ce5, 0xf0f307f2, 0xfbfd0eff, 0x92a779b4, 0x99a970b9, 0x84bb6bae, 0x8fb562a3, 0xbe9f5d80, 0xb591548d, 0xa8834f9a, 0xa38d4697])' -U3 = v'new Uint32Array([0x00000000, 0x0d0b0e09, 0x1a161c12, 0x171d121b, 0x342c3824, 0x3927362d, 0x2e3a2436, 0x23312a3f, 0x68587048, 0x65537e41, 0x724e6c5a, 0x7f456253, 0x5c74486c, 0x517f4665, 0x4662547e, 0x4b695a77, 0xd0b0e090, 0xddbbee99, 0xcaa6fc82, 0xc7adf28b, 0xe49cd8b4, 0xe997d6bd, 0xfe8ac4a6, 0xf381caaf, 0xb8e890d8, 0xb5e39ed1, 0xa2fe8cca, 0xaff582c3, 0x8cc4a8fc, 0x81cfa6f5, 0x96d2b4ee, 0x9bd9bae7, 0xbb7bdb3b, 0xb670d532, 0xa16dc729, 0xac66c920, 0x8f57e31f, 0x825ced16, 0x9541ff0d, 0x984af104, 0xd323ab73, 0xde28a57a, 0xc935b761, 0xc43eb968, 0xe70f9357, 0xea049d5e, 0xfd198f45, 0xf012814c, 0x6bcb3bab, 0x66c035a2, 0x71dd27b9, 0x7cd629b0, 0x5fe7038f, 0x52ec0d86, 0x45f11f9d, 0x48fa1194, 0x03934be3, 0x0e9845ea, 0x198557f1, 0x148e59f8, 0x37bf73c7, 0x3ab47dce, 0x2da96fd5, 0x20a261dc, 0x6df6ad76, 0x60fda37f, 0x77e0b164, 0x7aebbf6d, 0x59da9552, 0x54d19b5b, 0x43cc8940, 0x4ec78749, 0x05aedd3e, 0x08a5d337, 0x1fb8c12c, 0x12b3cf25, 0x3182e51a, 0x3c89eb13, 0x2b94f908, 0x269ff701, 0xbd464de6, 0xb04d43ef, 0xa75051f4, 0xaa5b5ffd, 0x896a75c2, 0x84617bcb, 0x937c69d0, 0x9e7767d9, 0xd51e3dae, 0xd81533a7, 0xcf0821bc, 0xc2032fb5, 0xe132058a, 0xec390b83, 0xfb241998, 0xf62f1791, 0xd68d764d, 0xdb867844, 0xcc9b6a5f, 0xc1906456, 0xe2a14e69, 0xefaa4060, 0xf8b7527b, 0xf5bc5c72, 0xbed50605, 0xb3de080c, 0xa4c31a17, 0xa9c8141e, 0x8af93e21, 0x87f23028, 0x90ef2233, 0x9de42c3a, 0x063d96dd, 0x0b3698d4, 0x1c2b8acf, 0x112084c6, 0x3211aef9, 0x3f1aa0f0, 0x2807b2eb, 0x250cbce2, 0x6e65e695, 0x636ee89c, 0x7473fa87, 0x7978f48e, 0x5a49deb1, 0x5742d0b8, 0x405fc2a3, 0x4d54ccaa, 0xdaf741ec, 0xd7fc4fe5, 0xc0e15dfe, 0xcdea53f7, 0xeedb79c8, 0xe3d077c1, 0xf4cd65da, 0xf9c66bd3, 0xb2af31a4, 0xbfa43fad, 0xa8b92db6, 0xa5b223bf, 0x86830980, 0x8b880789, 0x9c951592, 0x919e1b9b, 0x0a47a17c, 0x074caf75, 0x1051bd6e, 0x1d5ab367, 0x3e6b9958, 0x33609751, 0x247d854a, 0x29768b43, 0x621fd134, 0x6f14df3d, 0x7809cd26, 0x7502c32f, 0x5633e910, 0x5b38e719, 0x4c25f502, 0x412efb0b, 0x618c9ad7, 0x6c8794de, 0x7b9a86c5, 0x769188cc, 0x55a0a2f3, 0x58abacfa, 0x4fb6bee1, 0x42bdb0e8, 0x09d4ea9f, 0x04dfe496, 0x13c2f68d, 0x1ec9f884, 0x3df8d2bb, 0x30f3dcb2, 0x27eecea9, 0x2ae5c0a0, 0xb13c7a47, 0xbc37744e, 0xab2a6655, 0xa621685c, 0x85104263, 0x881b4c6a, 0x9f065e71, 0x920d5078, 0xd9640a0f, 0xd46f0406, 0xc372161d, 0xce791814, 0xed48322b, 0xe0433c22, 0xf75e2e39, 0xfa552030, 0xb701ec9a, 0xba0ae293, 0xad17f088, 0xa01cfe81, 0x832dd4be, 0x8e26dab7, 0x993bc8ac, 0x9430c6a5, 0xdf599cd2, 0xd25292db, 0xc54f80c0, 0xc8448ec9, 0xeb75a4f6, 0xe67eaaff, 0xf163b8e4, 0xfc68b6ed, 0x67b10c0a, 0x6aba0203, 0x7da71018, 0x70ac1e11, 0x539d342e, 0x5e963a27, 0x498b283c, 0x44802635, 0x0fe97c42, 0x02e2724b, 0x15ff6050, 0x18f46e59, 0x3bc54466, 0x36ce4a6f, 0x21d35874, 0x2cd8567d, 0x0c7a37a1, 0x017139a8, 0x166c2bb3, 0x1b6725ba, 0x38560f85, 0x355d018c, 0x22401397, 0x2f4b1d9e, 0x642247e9, 0x692949e0, 0x7e345bfb, 0x733f55f2, 0x500e7fcd, 0x5d0571c4, 0x4a1863df, 0x47136dd6, 0xdccad731, 0xd1c1d938, 0xc6dccb23, 0xcbd7c52a, 0xe8e6ef15, 0xe5ede11c, 0xf2f0f307, 0xfffbfd0e, 0xb492a779, 0xb999a970, 0xae84bb6b, 0xa38fb562, 0x80be9f5d, 0x8db59154, 0x9aa8834f, 0x97a38d46])' -U4 = v'new Uint32Array([0x00000000, 0x090d0b0e, 0x121a161c, 0x1b171d12, 0x24342c38, 0x2d392736, 0x362e3a24, 0x3f23312a, 0x48685870, 0x4165537e, 0x5a724e6c, 0x537f4562, 0x6c5c7448, 0x65517f46, 0x7e466254, 0x774b695a, 0x90d0b0e0, 0x99ddbbee, 0x82caa6fc, 0x8bc7adf2, 0xb4e49cd8, 0xbde997d6, 0xa6fe8ac4, 0xaff381ca, 0xd8b8e890, 0xd1b5e39e, 0xcaa2fe8c, 0xc3aff582, 0xfc8cc4a8, 0xf581cfa6, 0xee96d2b4, 0xe79bd9ba, 0x3bbb7bdb, 0x32b670d5, 0x29a16dc7, 0x20ac66c9, 0x1f8f57e3, 0x16825ced, 0x0d9541ff, 0x04984af1, 0x73d323ab, 0x7ade28a5, 0x61c935b7, 0x68c43eb9, 0x57e70f93, 0x5eea049d, 0x45fd198f, 0x4cf01281, 0xab6bcb3b, 0xa266c035, 0xb971dd27, 0xb07cd629, 0x8f5fe703, 0x8652ec0d, 0x9d45f11f, 0x9448fa11, 0xe303934b, 0xea0e9845, 0xf1198557, 0xf8148e59, 0xc737bf73, 0xce3ab47d, 0xd52da96f, 0xdc20a261, 0x766df6ad, 0x7f60fda3, 0x6477e0b1, 0x6d7aebbf, 0x5259da95, 0x5b54d19b, 0x4043cc89, 0x494ec787, 0x3e05aedd, 0x3708a5d3, 0x2c1fb8c1, 0x2512b3cf, 0x1a3182e5, 0x133c89eb, 0x082b94f9, 0x01269ff7, 0xe6bd464d, 0xefb04d43, 0xf4a75051, 0xfdaa5b5f, 0xc2896a75, 0xcb84617b, 0xd0937c69, 0xd99e7767, 0xaed51e3d, 0xa7d81533, 0xbccf0821, 0xb5c2032f, 0x8ae13205, 0x83ec390b, 0x98fb2419, 0x91f62f17, 0x4dd68d76, 0x44db8678, 0x5fcc9b6a, 0x56c19064, 0x69e2a14e, 0x60efaa40, 0x7bf8b752, 0x72f5bc5c, 0x05bed506, 0x0cb3de08, 0x17a4c31a, 0x1ea9c814, 0x218af93e, 0x2887f230, 0x3390ef22, 0x3a9de42c, 0xdd063d96, 0xd40b3698, 0xcf1c2b8a, 0xc6112084, 0xf93211ae, 0xf03f1aa0, 0xeb2807b2, 0xe2250cbc, 0x956e65e6, 0x9c636ee8, 0x877473fa, 0x8e7978f4, 0xb15a49de, 0xb85742d0, 0xa3405fc2, 0xaa4d54cc, 0xecdaf741, 0xe5d7fc4f, 0xfec0e15d, 0xf7cdea53, 0xc8eedb79, 0xc1e3d077, 0xdaf4cd65, 0xd3f9c66b, 0xa4b2af31, 0xadbfa43f, 0xb6a8b92d, 0xbfa5b223, 0x80868309, 0x898b8807, 0x929c9515, 0x9b919e1b, 0x7c0a47a1, 0x75074caf, 0x6e1051bd, 0x671d5ab3, 0x583e6b99, 0x51336097, 0x4a247d85, 0x4329768b, 0x34621fd1, 0x3d6f14df, 0x267809cd, 0x2f7502c3, 0x105633e9, 0x195b38e7, 0x024c25f5, 0x0b412efb, 0xd7618c9a, 0xde6c8794, 0xc57b9a86, 0xcc769188, 0xf355a0a2, 0xfa58abac, 0xe14fb6be, 0xe842bdb0, 0x9f09d4ea, 0x9604dfe4, 0x8d13c2f6, 0x841ec9f8, 0xbb3df8d2, 0xb230f3dc, 0xa927eece, 0xa02ae5c0, 0x47b13c7a, 0x4ebc3774, 0x55ab2a66, 0x5ca62168, 0x63851042, 0x6a881b4c, 0x719f065e, 0x78920d50, 0x0fd9640a, 0x06d46f04, 0x1dc37216, 0x14ce7918, 0x2bed4832, 0x22e0433c, 0x39f75e2e, 0x30fa5520, 0x9ab701ec, 0x93ba0ae2, 0x88ad17f0, 0x81a01cfe, 0xbe832dd4, 0xb78e26da, 0xac993bc8, 0xa59430c6, 0xd2df599c, 0xdbd25292, 0xc0c54f80, 0xc9c8448e, 0xf6eb75a4, 0xffe67eaa, 0xe4f163b8, 0xedfc68b6, 0x0a67b10c, 0x036aba02, 0x187da710, 0x1170ac1e, 0x2e539d34, 0x275e963a, 0x3c498b28, 0x35448026, 0x420fe97c, 0x4b02e272, 0x5015ff60, 0x5918f46e, 0x663bc544, 0x6f36ce4a, 0x7421d358, 0x7d2cd856, 0xa10c7a37, 0xa8017139, 0xb3166c2b, 0xba1b6725, 0x8538560f, 0x8c355d01, 0x97224013, 0x9e2f4b1d, 0xe9642247, 0xe0692949, 0xfb7e345b, 0xf2733f55, 0xcd500e7f, 0xc45d0571, 0xdf4a1863, 0xd647136d, 0x31dccad7, 0x38d1c1d9, 0x23c6dccb, 0x2acbd7c5, 0x15e8e6ef, 0x1ce5ede1, 0x07f2f0f3, 0x0efffbfd, 0x79b492a7, 0x70b999a9, 0x6bae84bb, 0x62a38fb5, 0x5d80be9f, 0x548db591, 0x4f9aa883, 0x4697a38d])' - -# }}} - -class AES: # {{{ - - def __init__(self, key): - self.working_mem = [Uint32Array(4), Uint32Array(4)] - rounds = number_of_rounds[key.length] - if not rounds: - raise ValueError('invalid key size (must be length 16, 24 or 32)') - - # encryption round keys - self._Ke = v'[]' - - # decryption round keys - self._Kd = v'[]' - - for v'var i = 0; i <= rounds; i++': - self._Ke.push(Uint32Array(4)) - self._Kd.push(Uint32Array(4)) - - round_key_count = (rounds + 1) * 4 - KC = key.length / 4 - - # convert the key into ints - tk = Uint32Array(KC) - convert_to_int32(key, tk) - - # copy values into round key arrays - index = 0 - for v'var i = 0; i < KC; i++': - index = i >> 2 - self._Ke[index][i % 4] = tk[i] - self._Kd[rounds - index][i % 4] = tk[i] - - # key expansion (fips-197 section 5.2) - rconpointer = 0 - t = KC - while t < round_key_count: - tt = tk[KC - 1] - tk[0] ^= ((S[(tt >> 16) & 0xFF] << 24) ^ - (S[(tt >> 8) & 0xFF] << 16) ^ - (S[ tt & 0xFF] << 8) ^ - S[(tt >> 24) & 0xFF] ^ - (rcon[rconpointer] << 24)) - rconpointer += 1 - - # key expansion (for non-256 bit) - if KC != 8: - for v'var i = 1; i < KC; i++': - tk[i] ^= tk[i - 1] - - # key expansion for 256-bit keys is "slightly different" (fips-197) - else: - for v'var i = 1; i < (KC / 2); i++': - tk[i] ^= tk[i - 1] - tt = tk[(KC / 2) - 1] - - tk[KC / 2] ^= (S[ tt & 0xFF] ^ - (S[(tt >> 8) & 0xFF] << 8) ^ - (S[(tt >> 16) & 0xFF] << 16) ^ - (S[(tt >> 24) & 0xFF] << 24)) - - for v'var i = (KC / 2) + 1; i < KC; i++': - tk[i] ^= tk[i - 1] - - # copy values into round key arrays - i = 0 - while i < KC and t < round_key_count: - r = t >> 2 - c = t % 4 - self._Ke[r][c] = tk[i] - self._Kd[rounds - r][c] = tk[v'i++'] - t += 1 - - # inverse-cipher-ify the decryption round key (fips-197 section 5.3) - for v'var r = 1; r < rounds; r++': - for v'var c = 0; c < 4; c++': - tt = self._Kd[r][c] - self._Kd[r][c] = (U1[(tt >> 24) & 0xFF] ^ - U2[(tt >> 16) & 0xFF] ^ - U3[(tt >> 8) & 0xFF] ^ - U4[ tt & 0xFF]) - - def _crypt(self, ciphertext, offset, encrypt): - if encrypt: - R1 = T1; R2 = T2; R3 = T3; R4 = T4 - o1 = 1; o3 = 3 - SB = S - K = self._Ke - else: - R1 = T5; R2 = T6; R3 = T7; R4 = T8 - o1 = 3; o3 = 1 - SB = Si - K = self._Kd - rounds = K.length - 1 - a = self.working_mem[0] - t = self.working_mem[1] - - # XOR plaintext with key - for v'var i = 0; i < 4; i++': - t[i] ^= K[0][i] - - # apply round transforms - for v'var r = 1; r < rounds; r++': - for v'var i = 0; i < 4; i++': - a[i] = (R1[(t[i] >> 24) & 0xff] ^ - R2[(t[(i + o1) % 4] >> 16) & 0xff] ^ - R3[(t[(i + 2) % 4] >> 8) & 0xff] ^ - R4[ t[(i + o3) % 4] & 0xff] ^ - K[r][i]) - t.set(a) - - # the last round is special - for v'var i = 0; i < 4; i++': - tt = K[rounds][i] - ciphertext[offset + 4 * i] = (SB[(t[i] >> 24) & 0xff] ^ (tt >> 24)) & 0xff - ciphertext[offset + 4 * i + 1] = (SB[(t[(i + o1) % 4] >> 16) & 0xff] ^ (tt >> 16)) & 0xff - ciphertext[offset + 4 * i + 2] = (SB[(t[(i + 2) % 4] >> 8) & 0xff] ^ (tt >> 8)) & 0xff - ciphertext[offset + 4 * i + 3] = (SB[ t[(i + o3) % 4] & 0xff] ^ tt ) & 0xff - - def encrypt(self, plaintext, ciphertext, offset): - convert_to_int32(plaintext, self.working_mem[1], offset, 16) - return self._crypt(ciphertext, offset, True) - - def encrypt32(self, plaintext, ciphertext, offset): - self.working_mem[1].set(plaintext) - return self._crypt(ciphertext, offset, True) - - def decrypt(self, ciphertext, plaintext, offset): - convert_to_int32(ciphertext, self.working_mem[1], offset, 16) - return self._crypt(plaintext, offset, False) - - def decrypt32(self, ciphertext, plaintext, offset): - self.working_mem[1].set(ciphertext) - return self._crypt(plaintext, offset, False) -# }}} - -def random_bytes_insecure(sz): - ans = Uint8Array(sz) - for v'var i = 0; i < sz; i++': - ans[i] = Math.floor(Math.random() * 256) - return ans - -def random_bytes_secure(sz): - ans = Uint8Array(sz) - crypto.getRandomValues(ans) - return ans - -random_bytes = random_bytes_secure if jstype(crypto) is not 'undefined' and jstype(crypto.getRandomValues) is 'function' else random_bytes_insecure -if random_bytes is random_bytes_insecure: - try: - noderandom = require('crypto').randomBytes - random_bytes = def(sz): - return Uint8Array(noderandom(sz)) - except: - print('WARNING: Using insecure RNG for AES') - -class ModeOfOperation: # {{{ - - def __init__(self, key): - self.key = key or generate_key(32) - self.aes = AES(self.key) - - @property - def key_as_js(self): - return typed_array_as_js(self.key) - - def tag_as_bytes(self, tag): - if isinstance(tag, Uint8Array): - return tag - if not tag: - return Uint8Array(0) - if jstype(tag) is 'string': - return string_to_bytes(tag) - raise TypeError('Invalid tag, must be a string or a Uint8Array') -# }}} - -class GaloisField: # {{{ - - def __init__(self, sub_key): - k32 = Uint32Array(4) - convert_to_int32(sub_key, k32, 0) - self.m = self.generate_hash_table(k32) - self.wmem = Uint32Array(4) - - def power(self, x, out): - lsb = x[3] & 1 - for v'var i = 3; i > 0; --i': - out[i] = (x[i] >>> 1) | ((x[i - 1] & 1) << 31) - out[0] = x[0] >>> 1 - if lsb: - out[0] ^= 0xE1000000 - - def multiply(self, x, y): - z_i = Uint32Array(4) - v_i = Uint32Array(y) - for v'var i = 0; i < 128; ++i': - x_i = x[(i / 32) | 0] & (1 << (31 - i % 32)) - if x_i: - z_i[0] ^= v_i[0] - z_i[1] ^= v_i[1] - z_i[2] ^= v_i[2] - z_i[3] ^= v_i[3] - self.power(v_i, v_i) - return z_i - - def generate_sub_hash_table(self, mid): - bits = mid.length - size = 1 << bits - half = size >>> 1 - m = Array(size) - m[half] = Uint32Array(mid) - i = half >>> 1 - while i > 0: - m[i] = Uint32Array(4) - self.power(m[2 * i], m[i]) - i >>= 1 - i = 2 - while i < half: - for v'var j = 1; j < i; ++j': - m_i = m[i] - m_j = m[j] - m[i + j] = x = Uint32Array(4) - for v'var c = 0; c < 4; c++': - x[c] = m_i[c] ^ m_j[c] - i *= 2 - m[0] = Uint32Array(4) - for v'i = half + 1; i < size; ++i': - x = m[i ^ half] - m[i] = y = Uint32Array(4) - for v'var c = 0; c < 4; c++': - y[c] = mid[c] ^ x[c] - return m - - def generate_hash_table(self, key_as_int32_array): - bits = key_as_int32_array.length - multiplier = 8 / bits - per_int = 4 * multiplier - size = 16 * multiplier - ans = Array(size) - for v'var i =0; i < size; ++i': - tmp = Uint32Array(4) - idx = (i/ per_int) | 0 - shft = ((per_int - 1 - (i % per_int)) * bits) - tmp[idx] = (1 << (bits - 1)) << shft - ans[i] = self.generate_sub_hash_table(self.multiply(tmp, key_as_int32_array)) - return ans - - def table_multiply(self, x): - z = Uint32Array(4) - for v'var i = 0; i < 32; ++i': - idx = (i / 8) | 0 - x_i = (x[idx] >>> ((7 - (i % 8)) * 4)) & 0xF - ah = self.m[i][x_i] - z[0] ^= ah[0] - z[1] ^= ah[1] - z[2] ^= ah[2] - z[3] ^= ah[3] - return z - - def ghash(self, x, y): - # Corresponds to the XOR + mult_H operation from the paper - z = self.wmem - z[0] = y[0] ^ x[0] - z[1] = y[1] ^ x[1] - z[2] = y[2] ^ x[2] - z[3] = y[3] ^ x[3] - return self.table_multiply(z) - -# }}} - -# }}} - -def generate_key(sz): - if not number_of_rounds[sz]: - raise ValueError('Invalid key size, must be: 16, 24 or 32') - return random_bytes(sz) - -def generate_tag(sz): - return random_bytes(sz or 32) - -def typed_array_as_js(x): - name = x.constructor.name or 'Uint8Array' - return '(new ' + name + '(' + JSON.stringify(Array.prototype.slice.call(x)) + '))' - -class CBC(ModeOfOperation): # {{{ - - def encrypt_bytes(self, bytes, tag_bytes, iv): - iv = first_iv = iv or random_bytes(16) - mlen = bytes.length + tag_bytes.length - padsz = (16 - (mlen % 16)) % 16 - inputbytes = Uint8Array(mlen + padsz) - if tag_bytes.length: - inputbytes.set(tag_bytes) - inputbytes.set(bytes, tag_bytes.length) - - offset = 0 - outputbytes = Uint8Array(inputbytes.length) - for v'var block = 0; block < inputbytes.length; block += 16': - if block > 0: - iv, offset = outputbytes, block - 16 - for v'var i = 0; i < 16; i++': - inputbytes[block + i] ^= iv[offset + i] - self.aes.encrypt(inputbytes, outputbytes, block) - return {'iv':first_iv, 'cipherbytes':outputbytes} - - def encrypt(self, plaintext, tag): - return self.encrypt_bytes(string_to_bytes(plaintext), self.tag_as_bytes(tag)) - - def decrypt_bytes(self, inputbytes, tag_bytes, iv): - offset = 0 - outputbytes = Uint8Array(inputbytes.length) - for v'var block = 0; block < inputbytes.length; block += 16': - self.aes.decrypt(inputbytes, outputbytes, block) - if block > 0: - iv, offset = inputbytes, block - 16 - for v'var i = 0; i < 16; i++': - outputbytes[block + i] ^= iv[offset + i] - for v'var i = 0; i < tag_bytes.length; i++': - if tag_bytes[i] != outputbytes[i]: - raise ValueError('Corrupt message') - outputbytes = outputbytes.subarray(tag_bytes.length) - return outputbytes - - def decrypt(self, output_from_encrypt, tag): - ans = self.decrypt_bytes(output_from_encrypt.cipherbytes, self.tag_as_bytes(tag), output_from_encrypt.iv) - return str.rstrip(bytes_to_string(ans), '\0') -# }}} - -class CTR(ModeOfOperation): # {{{ - - # Note that this mode of operation requires the pair of (counterbytes, - # secret key) to always be unique, for every block. Therefore, if you are - # using it for bi-directional messaging it is best to use a different - # secret key for each direction - - def __init__(self, key, iv): - ModeOfOperation.__init__(self, key) - self.wmem = Uint8Array(16) - self.counter_block = Uint8Array(iv or 16) - if self.counter_block.length != 16: - raise ValueError('iv must be 16 bytes long') - self.counter_index = 16 - - def _crypt(self, bytes): - for v'var i = 0; i < bytes.length; i++, self.counter_index++': - if self.counter_index is 16: - self.counter_index = 0 - self.aes.encrypt(self.counter_block, self.wmem, 0) - increment_counter(self.counter_block) - bytes[i] ^= self.wmem[self.counter_index] - self.counter_index = 16 - - def encrypt(self, plaintext, tag): - outbytes = string_to_bytes(plaintext) - counterbytes = Uint8Array(self.counter_block) - if tag: - tag_bytes = self.tag_as_bytes(tag) - t = Uint8Array(outbytes.length + tag_bytes.length) - t.set(tag_bytes) - t.set(outbytes, tag_bytes.length) - outbytes = t - self._crypt(outbytes) - return {'cipherbytes':outbytes, 'counterbytes':counterbytes} - - def __enter__(self): - self.before_index = self.counter_index - self.before_counter = Uint8Array(self.counter_block) - - def __exit__(self): - self.counter_index = self.before_index - self.counter_block = self.before_counter - - def decrypt(self, output_from_encrypt, tag): - b = Uint8Array(output_from_encrypt.cipherbytes) - with self: - self.counter_block = output_from_encrypt.counterbytes - self.counter_index = 16 - self._crypt(b) - offset = 0 - if tag: - tag_bytes = self.tag_as_bytes(tag) - for v'var i = 0; i < tag_bytes.length; i++': - if tag_bytes[i] != b[i]: - raise ValueError('Corrupted message') - offset = tag_bytes.length - return bytes_to_string(b, offset) -# }}} - -class GCM(ModeOfOperation): # {{{ - - # Note that this mode of operation requires the pair of (iv, - # secret key) to always be unique, for every message. Therefore, if you are - # using it for bi-directional messaging it is best to use a different - # secret key for each direction (you could also use random_key, - # but that has a non-zero probability of repeating keys). - # See http://web.cs.ucdavis.edu/~rogaway/ocb/gcm.pdf - - def __init__(self, key, random_iv=False): - ModeOfOperation.__init__(self, key) - self.random_iv = random_iv - if not random_iv: - self.current_iv = Uint8Array(12) - - # Generate the hash subkey - H = Uint8Array(16) - self.aes.encrypt(Uint8Array(16), H, 0) - self.galois = GaloisField(H) - - # Working memory - self.J0 = Uint32Array(4) - self.wmem = Uint32Array(4) - self.byte_block = Uint8Array(16) - - def increment_iv(self): - c = self.current_iv - for v'var i = 11; i >=0; i--': - if c[i] is 255: - if i is 0: - raise ValueError('The GCM IV space is exhausted, cannot encrypt anymore messages with this key as doing so would cause the IV to repeat') - c[i] = 0 - else: - c[i] += 1 - break - - def _create_j0(self, iv): - J0 = self.J0 - if iv.length is 12: - convert_to_int32(iv, J0) - J0[3] = 1 - else: - J0.fill(0) - tmp = convert_to_int32_pad(iv) - while tmp.length: - J0 = self.galois.ghash(J0, tmp) - tmp = tmp.subarray(4) - tmp = Uint32Array(4) - tmp.set(from_64_to_32(iv.length * 8), 2) - J0 = self.galois.ghash(J0, tmp) - return J0 - - def _start(self, iv, additional_data): - J0 = self._create_j0(iv) - # Generate initial counter block - in_block = Uint32Array(J0) - in_block[3] = (in_block[3] + 1) & 0xFFFFFFFF # increment counter - - # Process additional_data - S = Uint32Array(4) - overflow = additional_data.length % 16 - for v'var i = 0; i < additional_data.length - overflow; i += 16': - convert_to_int32(additional_data, self.wmem, i, 16) - S = self.galois.ghash(S, self.wmem) - if overflow: - self.byte_block.fill(0) - self.byte_block.set(additional_data.subarray(additional_data.length - overflow)) - convert_to_int32(self.byte_block, self.wmem) - S = self.galois.ghash(S, self.wmem) - return J0, in_block, S - - def _finish(self, iv, J0, adata_len, S, outbytes): - # Mix the lengths into S - lengths = Uint32Array(4) - lengths.set(from_64_to_32(adata_len * 8)) - lengths.set(from_64_to_32(outbytes.length * 8), 2) - S = self.galois.ghash(S, lengths) - - # Create the tag - self.aes.encrypt32(J0, self.byte_block, 0) - convert_to_int32(self.byte_block, self.wmem) - tag = Uint32Array(4) - for v'var i = 0; i < S.length; i++': - tag[i] = S[i] ^ self.wmem[i] - return {'iv':iv, 'cipherbytes':outbytes, 'tag':tag} - - def _crypt(self, iv, bytes, additional_data, decrypt): - ghash = self.galois.ghash.bind(self.galois) - outbytes = Uint8Array(bytes.length) - J0, in_block, S = self._start(iv, additional_data) - bb = self.byte_block - enc = self.aes.encrypt32.bind(self.aes) - hash_bytes = bytes if decrypt else outbytes - - # Create the ciphertext, encrypting block by block - for v'var i = 0, counter_index = 16; i < bytes.length; i++, counter_index++': - if counter_index is 16: - # Encrypt counter and increment it - enc(in_block, bb, 0) - in_block[3] = (in_block[3] + 1) & 0xFFFFFFFF # increment counter - counter_index = 0 - # Output is XOR of encrypted counter with input - outbytes[i] = bytes[i] ^ bb[counter_index] - if counter_index is 15: - # We have completed a block, update the hash - convert_to_int32(hash_bytes, self.wmem, i - 15, 16) - S = ghash(S, self.wmem) - - # Check if we have a last partial block - overflow = outbytes.length % 16 - if overflow: - # partial output block - bb.fill(0) - bb.set(hash_bytes.subarray(hash_bytes.length - overflow)) - convert_to_int32(bb, self.wmem) - S = ghash(S, self.wmem) - - return self._finish(iv, J0, additional_data.length, S, outbytes) - - def encrypt(self, plaintext, tag): - if self.random_iv: - iv = random_bytes(12) - else: - self.increment_iv() - iv = self.current_iv - return self._crypt(iv, string_to_bytes(plaintext), self.tag_as_bytes(tag), False) - - def decrypt(self, output_from_encrypt, tag): - if output_from_encrypt.tag.length != 4: - raise ValueError('Corrupted message') - ans = self._crypt(output_from_encrypt.iv, output_from_encrypt.cipherbytes, self.tag_as_bytes(tag), True) - if ans.tag != output_from_encrypt.tag: - raise ValueError('Corrupted message') - return bytes_to_string(ans.cipherbytes) -# }}} diff --git a/resources/rapydscript/lib/elementmaker.pyj b/resources/rapydscript/lib/elementmaker.pyj deleted file mode 100644 index fb29f8ff6a..0000000000 --- a/resources/rapydscript/lib/elementmaker.pyj +++ /dev/null @@ -1,83 +0,0 @@ -# vim:fileencoding=utf-8 -# License: GPL v3 Copyright: 2015, Kovid Goyal - -html_elements = { - 'a', 'abbr', 'acronym', 'address', 'area', - 'article', 'aside', 'audio', 'b', 'big', 'blockquote', 'br', 'button', - 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', - 'command', 'datagrid', 'datalist', 'dd', 'del', 'details', 'dfn', - 'dialog', 'dir', 'div', 'dl', 'dt', 'em', 'event-source', 'fieldset', - 'figcaption', 'figure', 'footer', 'font', 'form', 'header', 'h1', - 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'i', 'iframe', 'img', 'input', 'ins', - 'keygen', 'kbd', 'label', 'legend', 'li', 'm', 'map', 'menu', 'meter', - 'multicol', 'nav', 'nextid', 'ol', 'output', 'optgroup', 'option', - 'p', 'pre', 'progress', 'q', 's', 'samp', 'script', 'section', 'select', - 'small', 'sound', 'source', 'spacer', 'span', 'strike', 'strong', 'style', - 'sub', 'sup', 'table', 'tbody', 'td', 'textarea', 'time', 'tfoot', - 'th', 'thead', 'tr', 'tt', 'u', 'ul', 'var', 'video' -} - -mathml_elements = { - 'maction', 'math', 'merror', 'mfrac', 'mi', - 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', - 'mprescripts', 'mroot', 'mrow', 'mspace', 'msqrt', 'mstyle', 'msub', - 'msubsup', 'msup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', - 'munderover', 'none' -} - -svg_elements = { - 'a', 'animate', 'animateColor', 'animateMotion', - 'animateTransform', 'clipPath', 'circle', 'defs', 'desc', 'ellipse', - 'font-face', 'font-face-name', 'font-face-src', 'g', 'glyph', 'hkern', - 'linearGradient', 'line', 'marker', 'metadata', 'missing-glyph', - 'mpath', 'path', 'polygon', 'polyline', 'radialGradient', 'rect', - 'set', 'stop', 'svg', 'switch', 'text', 'title', 'tspan', 'use' -} - -html5_tags = html_elements.union(mathml_elements).union(svg_elements) - -def _makeelement(tag, *args, **kwargs): - ans = this.createElement(tag) - - for attr in kwargs: - vattr = str.replace(str.rstrip(attr, '_'), '_', '-') - val = kwargs[attr] - if callable(val): - if str.startswith(attr, 'on'): - attr = attr[2:] - ans.addEventListener(attr, val) - elif val is True: - ans.setAttribute(vattr, vattr) - elif jstype(val) is 'string': - ans.setAttribute(vattr, val) - - for arg in args: - if jstype(arg) is 'string': - arg = this.createTextNode(arg) - ans.appendChild(arg) - return ans - -def maker_for_document(document): - # Create an elementmaker to be used with the specified document - E = _makeelement.bind(document) - Object.defineProperties(E, { - tag: { - 'value':_makeelement.bind(document, tag) - } for tag in html5_tags - }) - return E - -if jstype(document) is 'undefined': - E = maker_for_document({ - 'createTextNode': def(value): return value;, - 'createElement': def(name): - return { - 'name':name, - 'children':[], - 'attributes':{}, - 'setAttribute': def(name, val): this.attributes[name] = val;, - 'appendChild': def(child): this.children.push(child);, - } - }) -else: - E = maker_for_document(document) diff --git a/resources/rapydscript/lib/encodings.pyj b/resources/rapydscript/lib/encodings.pyj deleted file mode 100644 index d72e9b54f6..0000000000 --- a/resources/rapydscript/lib/encodings.pyj +++ /dev/null @@ -1,126 +0,0 @@ -# vim:fileencoding=utf-8 -# License: BSD Copyright: 2016, Kovid Goyal - -def base64encode(bytes, altchars, pad_char): - # Convert an array of bytes into a base-64 encoded string - l = bytes.length - remainder = l % 3 - main_length = l - remainder - encodings = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' + (altchars or '+/') - pad_char = '=' if pad_char is undefined else pad_char - ans = v'[]' - for v'var i = 0; i < main_length; i += 3': - chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2] - ans.push(encodings[(chunk & 16515072) >> 18], encodings[(chunk & 258048) >> 12], encodings[(chunk & 4032) >> 6], encodings[chunk & 63]) - if remainder is 1: - chunk = bytes[main_length] - ans.push(encodings[(chunk & 252) >> 2], encodings[(chunk & 3) << 4], pad_char, pad_char) - elif remainder is 2: - chunk = (bytes[main_length] << 8) | bytes[main_length + 1] - ans.push(encodings[(chunk & 64512) >> 10], encodings[(chunk & 1008) >> 4], encodings[(chunk & 15) << 2], pad_char) - return ans.join('') - -def base64decode(string): - # convert the output of base64encode back into an array of bytes - # (Uint8Array) only works with the standard altchars and pad_char - if jstype(window) is not 'undefined': - chars = window.atob(string) - else: - chars = new Buffer(string, 'base64').toString('binary') # noqa: undef - ans = Uint8Array(chars.length) - for i in range(ans.length): - ans[i] = chars.charCodeAt(i) - return ans - -def urlsafe_b64encode(bytes, pad_char): - return base64encode(bytes, '-_', pad_char) - -def urlsafe_b64decode(string): - string = String.prototype.replace.call(string, /[_-]/g, def(m): return '+' if m is '-' else '/';) - return base64decode(string) - -def hexlify(bytes): - ans = v'[]' - for v'var i = 0; i < bytes.length; i++': - x = bytes[i].toString(16) - if x.length is 1: - x = '0' + x - ans.push(x) - return ans.join('') - -def unhexlify(string): - num = string.length // 2 - if num * 2 is not string.length: - raise ValueError('string length is not a multiple of two') - ans = Uint8Array(num) - for v'var i = 0; i < num; i++': - x = parseInt(string[i*2:i*2+2], 16) - if isNaN(x): - raise ValueError('string is not hex-encoded') - ans[i] = x - return ans - -utf8_decoder_table = v'''[ - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 00..1f - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 20..3f - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 40..5f - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 60..7f - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, // 80..9f - 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, // a0..bf - 8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // c0..df - 0xa,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x3,0x4,0x3,0x3, // e0..ef - 0xb,0x6,0x6,0x6,0x5,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8,0x8, // f0..ff - 0x0,0x1,0x2,0x3,0x5,0x8,0x7,0x1,0x1,0x1,0x4,0x6,0x1,0x1,0x1,0x1, // s0..s0 - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,0,1,1,1,1,1,1, // s1..s2 - 1,2,1,1,1,1,1,2,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1, // s3..s4 - 1,2,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,3,1,1,1,1,1,1, // s5..s6 - 1,3,1,1,1,1,1,3,1,3,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // s7..s8 -]''' - -def _from_code_point(x): - if x <= 0xFFFF: - return String.fromCharCode(x) - x -= 0x10000 - return String.fromCharCode((x >> 10) + 0xD800, (x % 0x400) + 0xDC00) - -def utf8_decode(bytes, errors, replacement): - # Convert an array of UTF-8 encoded bytes into a string - state = 0 - ans = v'[]' - - for v'var i = 0, l = bytes.length; i < l; i++': # noqa - byte = bytes[i] - typ = utf8_decoder_table[byte] - codep = (byte & 0x3f) | (codep << 6) if state is not 0 else (0xff >> typ) & (byte) - state = utf8_decoder_table[256 + state*16 + typ] - if state is 0: - ans.push(_from_code_point(codep)) - elif state is 1: - if not errors or errors is 'strict': - raise UnicodeDecodeError(str.format('The byte 0x{:02x} at position {} is not valid UTF-8', byte, i)) - elif errors is 'replace': - ans.push(replacement or '?') - return ans.join('') - -def utf8_encode_js(string): - # Encode a string as an array of UTF-8 bytes - escstr = encodeURIComponent(string) - ans = v'[]' - for v'var i = 0; i < escstr.length; i++': - ch = escstr[i] - if ch is '%': - ans.push(parseInt(escstr[i+1:i+3], 16)) - i += 2 - else: - ans.push(ch.charCodeAt(0)) - return Uint8Array(ans) - -if jstype(TextEncoder) is 'function': - _u8enc = TextEncoder('utf-8') - utf8_encode = _u8enc.encode.bind(_u8enc) - _u8enc = undefined -else: - utf8_encode = utf8_encode_js - -def utf8_encode_native(string): - return _u8enc.encode(string) diff --git a/resources/rapydscript/lib/gettext.pyj b/resources/rapydscript/lib/gettext.pyj deleted file mode 100644 index 2a5b3c690f..0000000000 --- a/resources/rapydscript/lib/gettext.pyj +++ /dev/null @@ -1,569 +0,0 @@ -# vim:fileencoding=utf-8 -# License: BSD Copyright: 2015, Kovid Goyal - -# noqa: eol-semicolon - -# The Plural-Forms parser {{{ -# From: https://github.com/SlexAxton/Jed/blob/master/jed.js licensed under the WTFPL - -Jed = {} - -vr''' - Jed.PF = {}; - - Jed.PF.parse = function ( p ) { - var plural_str = Jed.PF.extractPluralExpr( p ); - return Jed.PF.parser.parse.call(Jed.PF.parser, plural_str); - }; - - Jed.PF.compile = function ( p ) { - // Handle trues and falses as 0 and 1 - function imply( val ) { - return (val === true ? 1 : val ? val : 0); - } - - var ast = Jed.PF.parse( p ); - return function ( n ) { - return imply( Jed.PF.interpreter( ast )( n ) ); - }; - }; - - Jed.PF.interpreter = function ( ast ) { - return function ( n ) { - var res; - switch ( ast.type ) { - case 'GROUP': - return Jed.PF.interpreter( ast.expr )( n ); - case 'TERNARY': - if ( Jed.PF.interpreter( ast.expr )( n ) ) { - return Jed.PF.interpreter( ast.truthy )( n ); - } - return Jed.PF.interpreter( ast.falsey )( n ); - case 'OR': - return Jed.PF.interpreter( ast.left )( n ) || Jed.PF.interpreter( ast.right )( n ); - case 'AND': - return Jed.PF.interpreter( ast.left )( n ) && Jed.PF.interpreter( ast.right )( n ); - case 'LT': - return Jed.PF.interpreter( ast.left )( n ) < Jed.PF.interpreter( ast.right )( n ); - case 'GT': - return Jed.PF.interpreter( ast.left )( n ) > Jed.PF.interpreter( ast.right )( n ); - case 'LTE': - return Jed.PF.interpreter( ast.left )( n ) <= Jed.PF.interpreter( ast.right )( n ); - case 'GTE': - return Jed.PF.interpreter( ast.left )( n ) >= Jed.PF.interpreter( ast.right )( n ); - case 'EQ': - return Jed.PF.interpreter( ast.left )( n ) == Jed.PF.interpreter( ast.right )( n ); - case 'NEQ': - return Jed.PF.interpreter( ast.left )( n ) != Jed.PF.interpreter( ast.right )( n ); - case 'MOD': - return Jed.PF.interpreter( ast.left )( n ) % Jed.PF.interpreter( ast.right )( n ); - case 'VAR': - return n; - case 'NUM': - return ast.val; - default: - throw new Error("Invalid Token found."); - } - }; - }; - - Jed.PF.extractPluralExpr = function ( p ) { - // trim first - p = p.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); - - if (! /;\s*$/.test(p)) { - p = p.concat(';'); - } - - var nplurals_re = /nplurals\=(\d+);/, - plural_re = /plural\=(.*);/, - nplurals_matches = p.match( nplurals_re ), - res = {}, - plural_matches; - - // Find the nplurals number - if ( nplurals_matches.length > 1 ) { - res.nplurals = nplurals_matches[1]; - } - else { - throw new Error('nplurals not found in plural_forms string: ' + p ); - } - - // remove that data to get to the formula - p = p.replace( nplurals_re, "" ); - plural_matches = p.match( plural_re ); - - if (!( plural_matches && plural_matches.length > 1 ) ) { - throw new Error('`plural` expression not found: ' + p); - } - return plural_matches[ 1 ]; - }; - - /* Jison generated parser */ - Jed.PF.parser = (function(){ - -var parser = {trace: function trace() { }, -yy: {}, -symbols_: {"error":2,"expressions":3,"e":4,"EOF":5,"?":6,":":7,"||":8,"&&":9,"<":10,"<=":11,">":12,">=":13,"!=":14,"==":15,"%":16,"(":17,")":18,"n":19,"NUMBER":20,"$accept":0,"$end":1}, -terminals_: {2:"error",5:"EOF",6:"?",7:":",8:"||",9:"&&",10:"<",11:"<=",12:">",13:">=",14:"!=",15:"==",16:"%",17:"(",18:")",19:"n",20:"NUMBER"}, -productions_: [0,[3,2],[4,5],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,3],[4,1],[4,1]], -performAction: function anonymous(yytext,yyleng,yylineno,yy,yystate,$$,_$) { - -var $0 = $$.length - 1; -switch (yystate) { -case 1: return { type : 'GROUP', expr: $$[$0-1] }; -case 2:this.$ = { type: 'TERNARY', expr: $$[$0-4], truthy : $$[$0-2], falsey: $$[$0] }; -break; -case 3:this.$ = { type: "OR", left: $$[$0-2], right: $$[$0] }; -break; -case 4:this.$ = { type: "AND", left: $$[$0-2], right: $$[$0] }; -break; -case 5:this.$ = { type: 'LT', left: $$[$0-2], right: $$[$0] }; -break; -case 6:this.$ = { type: 'LTE', left: $$[$0-2], right: $$[$0] }; -break; -case 7:this.$ = { type: 'GT', left: $$[$0-2], right: $$[$0] }; -break; -case 8:this.$ = { type: 'GTE', left: $$[$0-2], right: $$[$0] }; -break; -case 9:this.$ = { type: 'NEQ', left: $$[$0-2], right: $$[$0] }; -break; -case 10:this.$ = { type: 'EQ', left: $$[$0-2], right: $$[$0] }; -break; -case 11:this.$ = { type: 'MOD', left: $$[$0-2], right: $$[$0] }; -break; -case 12:this.$ = { type: 'GROUP', expr: $$[$0-1] }; -break; -case 13:this.$ = { type: 'VAR' }; -break; -case 14:this.$ = { type: 'NUM', val: Number(yytext) }; -break; -} -}, -table: [{3:1,4:2,17:[1,3],19:[1,4],20:[1,5]},{1:[3]},{5:[1,6],6:[1,7],8:[1,8],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16]},{4:17,17:[1,3],19:[1,4],20:[1,5]},{5:[2,13],6:[2,13],7:[2,13],8:[2,13],9:[2,13],10:[2,13],11:[2,13],12:[2,13],13:[2,13],14:[2,13],15:[2,13],16:[2,13],18:[2,13]},{5:[2,14],6:[2,14],7:[2,14],8:[2,14],9:[2,14],10:[2,14],11:[2,14],12:[2,14],13:[2,14],14:[2,14],15:[2,14],16:[2,14],18:[2,14]},{1:[2,1]},{4:18,17:[1,3],19:[1,4],20:[1,5]},{4:19,17:[1,3],19:[1,4],20:[1,5]},{4:20,17:[1,3],19:[1,4],20:[1,5]},{4:21,17:[1,3],19:[1,4],20:[1,5]},{4:22,17:[1,3],19:[1,4],20:[1,5]},{4:23,17:[1,3],19:[1,4],20:[1,5]},{4:24,17:[1,3],19:[1,4],20:[1,5]},{4:25,17:[1,3],19:[1,4],20:[1,5]},{4:26,17:[1,3],19:[1,4],20:[1,5]},{4:27,17:[1,3],19:[1,4],20:[1,5]},{6:[1,7],8:[1,8],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16],18:[1,28]},{6:[1,7],7:[1,29],8:[1,8],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16]},{5:[2,3],6:[2,3],7:[2,3],8:[2,3],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16],18:[2,3]},{5:[2,4],6:[2,4],7:[2,4],8:[2,4],9:[2,4],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16],18:[2,4]},{5:[2,5],6:[2,5],7:[2,5],8:[2,5],9:[2,5],10:[2,5],11:[2,5],12:[2,5],13:[2,5],14:[2,5],15:[2,5],16:[1,16],18:[2,5]},{5:[2,6],6:[2,6],7:[2,6],8:[2,6],9:[2,6],10:[2,6],11:[2,6],12:[2,6],13:[2,6],14:[2,6],15:[2,6],16:[1,16],18:[2,6]},{5:[2,7],6:[2,7],7:[2,7],8:[2,7],9:[2,7],10:[2,7],11:[2,7],12:[2,7],13:[2,7],14:[2,7],15:[2,7],16:[1,16],18:[2,7]},{5:[2,8],6:[2,8],7:[2,8],8:[2,8],9:[2,8],10:[2,8],11:[2,8],12:[2,8],13:[2,8],14:[2,8],15:[2,8],16:[1,16],18:[2,8]},{5:[2,9],6:[2,9],7:[2,9],8:[2,9],9:[2,9],10:[2,9],11:[2,9],12:[2,9],13:[2,9],14:[2,9],15:[2,9],16:[1,16],18:[2,9]},{5:[2,10],6:[2,10],7:[2,10],8:[2,10],9:[2,10],10:[2,10],11:[2,10],12:[2,10],13:[2,10],14:[2,10],15:[2,10],16:[1,16],18:[2,10]},{5:[2,11],6:[2,11],7:[2,11],8:[2,11],9:[2,11],10:[2,11],11:[2,11],12:[2,11],13:[2,11],14:[2,11],15:[2,11],16:[2,11],18:[2,11]},{5:[2,12],6:[2,12],7:[2,12],8:[2,12],9:[2,12],10:[2,12],11:[2,12],12:[2,12],13:[2,12],14:[2,12],15:[2,12],16:[2,12],18:[2,12]},{4:30,17:[1,3],19:[1,4],20:[1,5]},{5:[2,2],6:[1,7],7:[2,2],8:[1,8],9:[1,9],10:[1,10],11:[1,11],12:[1,12],13:[1,13],14:[1,14],15:[1,15],16:[1,16],18:[2,2]}], -defaultActions: {6:[2,1]}, -parseError: function parseError(str, hash) { - throw new Error(str); -}, -parse: function parse(input) { - var self = this, - stack = [0], - vstack = [null], // semantic value stack - lstack = [], // location stack - table = this.table, - yytext = '', - yylineno = 0, - yyleng = 0, - recovering = 0, - TERROR = 2, - EOF = 1; - - //this.reductionCount = this.shiftCount = 0; - - this.lexer.setInput(input); - this.lexer.yy = this.yy; - this.yy.lexer = this.lexer; - if (typeof this.lexer.yylloc == 'undefined') - this.lexer.yylloc = {}; - var yyloc = this.lexer.yylloc; - lstack.push(yyloc); - - if (typeof this.yy.parseError === 'function') - this.parseError = this.yy.parseError; - - function popStack (n) { - stack.length = stack.length - 2*n; - vstack.length = vstack.length - n; - lstack.length = lstack.length - n; - } - - function lex() { - var token; - token = self.lexer.lex() || 1; // $end = 1 - // if token isn't its numeric value, convert - if (typeof token !== 'number') { - token = self.symbols_[token] || token; - } - return token; - } - - var symbol, preErrorSymbol, state, action, a, r, yyval={},p,len,newState, expected, errStr; - while (true) { - // retreive state number from top of stack - state = stack[stack.length-1]; - - // use default actions if available - if (this.defaultActions[state]) { - action = this.defaultActions[state]; - } else { - if (symbol === null || symbol === undefined) - symbol = lex(); - // read action for current state and first input - action = table[state] && table[state][symbol]; - } - - // handle parse error - _handle_error: - if (typeof action === 'undefined' || !action.length || !action[0]) { - - if (!recovering) { - // Report error - expected = []; - for (p in table[state]) if (this.terminals_[p] && p > 2) { - expected.push("'"+this.terminals_[p]+"'"); - } - errStr = ''; - if (this.lexer.showPosition) { - errStr = 'Parse error on line '+(yylineno+1)+":\n"+this.lexer.showPosition()+"\nExpecting "+expected.join(', ') + ", got '" + this.terminals_[symbol]+ "'"; - } else { - errStr = 'Parse error on line '+(yylineno+1)+": Unexpected " + - (symbol == 1 /*EOF*/ ? "end of input" : - ("'"+(this.terminals_[symbol] || symbol)+"'")); - } - this.parseError(errStr, - {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected}); - } - - // just recovered from another error - if (recovering == 3) { - if (symbol == EOF) { - throw new Error(errStr || 'Parsing halted.'); - } - - // discard current lookahead and grab another - yyleng = this.lexer.yyleng; - yytext = this.lexer.yytext; - yylineno = this.lexer.yylineno; - yyloc = this.lexer.yylloc; - symbol = lex(); - } - - // try to recover from error - while (1) { - // check for error recovery rule in this state - if ((TERROR.toString()) in table[state]) { - break; - } - if (state === 0) { - throw new Error(errStr || 'Parsing halted.'); - } - popStack(1); - state = stack[stack.length-1]; - } - - preErrorSymbol = symbol; // save the lookahead token - symbol = TERROR; // insert generic error symbol as new lookahead - state = stack[stack.length-1]; - action = table[state] && table[state][TERROR]; - recovering = 3; // allow 3 real symbols to be shifted before reporting a new error - } - - // this shouldn't happen, unless resolve defaults are off - if (action[0] instanceof Array && action.length > 1) { - throw new Error('Parse Error: multiple actions possible at state: '+state+', token: '+symbol); - } - - switch (action[0]) { - - case 1: // shift - //this.shiftCount++; - - stack.push(symbol); - vstack.push(this.lexer.yytext); - lstack.push(this.lexer.yylloc); - stack.push(action[1]); // push state - symbol = null; - if (!preErrorSymbol) { // normal execution/no error - yyleng = this.lexer.yyleng; - yytext = this.lexer.yytext; - yylineno = this.lexer.yylineno; - yyloc = this.lexer.yylloc; - if (recovering > 0) - recovering--; - } else { // error just occurred, resume old lookahead f/ before error - symbol = preErrorSymbol; - preErrorSymbol = null; - } - break; - - case 2: // reduce - //this.reductionCount++; - - len = this.productions_[action[1]][1]; - - // perform semantic action - yyval.$ = vstack[vstack.length-len]; // default to $$ = $1 - // default location, uses first token for firsts, last for lasts - yyval._$ = { - first_line: lstack[lstack.length-(len||1)].first_line, - last_line: lstack[lstack.length-1].last_line, - first_column: lstack[lstack.length-(len||1)].first_column, - last_column: lstack[lstack.length-1].last_column - }; - r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack); - - if (typeof r !== 'undefined') { - return r; - } - - // pop off stack - if (len) { - stack = stack.slice(0,-1*len*2); - vstack = vstack.slice(0, -1*len); - lstack = lstack.slice(0, -1*len); - } - - stack.push(this.productions_[action[1]][0]); // push nonterminal (reduce) - vstack.push(yyval.$); - lstack.push(yyval._$); - // goto new state = table[STATE][NONTERMINAL] - newState = table[stack[stack.length-2]][stack[stack.length-1]]; - stack.push(newState); - break; - - case 3: // accept - return true; - } - - } - - return true; -}};/* Jison generated lexer */ -var lexer = (function(){ - -var lexer = ({EOF:1, -parseError:function parseError(str, hash) { - if (this.yy.parseError) { - this.yy.parseError(str, hash); - } else { - throw new Error(str); - } - }, -setInput:function (input) { - this._input = input; - this._more = this._less = this.done = false; - this.yylineno = this.yyleng = 0; - this.yytext = this.matched = this.match = ''; - this.conditionStack = ['INITIAL']; - this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0}; - return this; - }, -input:function () { - var ch = this._input[0]; - this.yytext+=ch; - this.yyleng++; - this.match+=ch; - this.matched+=ch; - var lines = ch.match(/\n/); - if (lines) this.yylineno++; - this._input = this._input.slice(1); - return ch; - }, -unput:function (ch) { - this._input = ch + this._input; - return this; - }, -more:function () { - this._more = true; - return this; - }, -pastInput:function () { - var past = this.matched.substr(0, this.matched.length - this.match.length); - return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, ""); - }, -upcomingInput:function () { - var next = this.match; - if (next.length < 20) { - next += this._input.substr(0, 20-next.length); - } - return (next.substr(0,20)+(next.length > 20 ? '...':'')).replace(/\n/g, ""); - }, -showPosition:function () { - var pre = this.pastInput(); - var c = new Array(pre.length + 1).join("-"); - return pre + this.upcomingInput() + "\n" + c+"^"; - }, -next:function () { - if (this.done) { - return this.EOF; - } - if (!this._input) this.done = true; - - var token, - match, - col, - lines; - if (!this._more) { - this.yytext = ''; - this.match = ''; - } - var rules = this._currentRules(); - for (var i=0;i < rules.length; i++) { - match = this._input.match(this.rules[rules[i]]); - if (match) { - lines = match[0].match(/\n.*/g); - if (lines) this.yylineno += lines.length; - this.yylloc = {first_line: this.yylloc.last_line, - last_line: this.yylineno+1, - first_column: this.yylloc.last_column, - last_column: lines ? lines[lines.length-1].length-1 : this.yylloc.last_column + match[0].length}; - this.yytext += match[0]; - this.match += match[0]; - this.matches = match; - this.yyleng = this.yytext.length; - this._more = false; - this._input = this._input.slice(match[0].length); - this.matched += match[0]; - token = this.performAction.call(this, this.yy, this, rules[i],this.conditionStack[this.conditionStack.length-1]); - if (token) return token; - else return; - } - } - if (this._input === "") { - return this.EOF; - } else { - this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(), - {text: "", token: null, line: this.yylineno}); - } - }, -lex:function lex() { - var r = this.next(); - if (typeof r !== 'undefined') { - return r; - } else { - return this.lex(); - } - }, -begin:function begin(condition) { - this.conditionStack.push(condition); - }, -popState:function popState() { - return this.conditionStack.pop(); - }, -_currentRules:function _currentRules() { - return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules; - }, -topState:function () { - return this.conditionStack[this.conditionStack.length-2]; - }, -pushState:function begin(condition) { - this.begin(condition); - }}); -lexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) { - -var YYSTATE=YY_START; -switch($avoiding_name_collisions) { -case 0:/* skip whitespace */ -break; -case 1:return 20 -break; -case 2:return 19 -break; -case 3:return 8 -break; -case 4:return 9 -break; -case 5:return 6 -break; -case 6:return 7 -break; -case 7:return 11 -break; -case 8:return 13 -break; -case 9:return 10 -break; -case 10:return 12 -break; -case 11:return 14 -break; -case 12:return 15 -break; -case 13:return 16 -break; -case 14:return 17 -break; -case 15:return 18 -break; -case 16:return 5 -break; -case 17:return 'INVALID' -break; -} -}; -lexer.rules = [/^\s+/,/^[0-9]+(\.[0-9]+)?\b/,/^n\b/,/^\|\|/,/^&&/,/^\?/,/^:/,/^<=/,/^>=/,/^/,/^!=/,/^==/,/^%/,/^\(/,/^\)/,/^$/,/^./]; -lexer.conditions = {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17],"inclusive":true}};return lexer;})() -parser.lexer = lexer; -return parser; -})(); -''' -plural_forms_parser = Jed.PF -# }}} - -def _get_plural_forms_function(plural_forms_string): - return plural_forms_parser.compile(plural_forms_string or "nplurals=2; plural=(n != 1);") - -_gettext = def(text): return text - -_ngettext = def(text, plural, n): return text if n is 1 else plural - -def gettext(text): - return _gettext(text) - -def ngettext(text, plural, n): - return _ngettext(text, plural, n) - -def install(translation_data): - t = new Translations(translation_data) - t.install() - for func in register_callback.install_callbacks: - try: - func(t) - except: - pass - return t - -has_prop = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty) - -def register_callback(func): - # Register callbacks that will be called when new translation data is - # installed - register_callback.install_callbacks.push(func) -register_callback.install_callbacks = v'[]' - -empty_translation_data = {'entries': {}} - -class Translations: - - def __init__(self, translation_data): - translation_data = translation_data or empty_translation_data - func = _get_plural_forms_function(translation_data.plural_forms) - self.translations = [[translation_data, func]] - self.language = translation_data['language'] - - def add_fallback(self, fallback): - fallback = fallback or empty_translation_data - func = _get_plural_forms_function(fallback.plural_forms) - self.translations.push([fallback, func]) - - def gettext(self, text): - for t in self.translations: - m = t[0].entries - if has_prop(m, text): - return m[text][0] - return text - - def ngettext(self, text, plural, n): - for t in self.translations: - m = t[0].entries - if has_prop(m, text): - idx = t[1](n) - return m[text][idx] or (text if n is 1 else plural) - return text if n is 1 else plural - - def install(self): - nonlocal _gettext, _ngettext - _gettext = def (): - return self.gettext.apply(self, arguments) - _ngettext = def (): - return self.ngettext.apply(self, arguments) diff --git a/resources/rapydscript/lib/math.pyj b/resources/rapydscript/lib/math.pyj deleted file mode 100644 index 0cd65ae590..0000000000 --- a/resources/rapydscript/lib/math.pyj +++ /dev/null @@ -1,192 +0,0 @@ -########################################################### -# RapydScript Standard Library -# Author: Alexander Tsepkov -# Copyright 2013 Pyjeon Software LLC -# License: Apache License 2.0 -# This library is covered under Apache license, so that -# you can distribute it with your RapydScript applications. -########################################################### - - -# basic implementation of Python's 'math' library - -# NOTE: this is only meant to aid those porting lots of Python code into RapydScript, -# if you're writing a new RapydScript application, in most cases you probably want to -# use JavaScript's Math module directly instead - - -pi = Math.PI -e = Math.E - -######################################## -# Number-theoretic and representation functions -######################################## -def ceil(x): - return Math.ceil(x) -def copysign(x, y): - x = Math.abs(x) - if y < 0: - return -x - else: - return x -def fabs(x): - return Math.abs(x) -def factorial(x): - if Math.abs(int(x)) is not x: - raise ValueError("factorial() only accepts integral values") - factorial.cache = [] - r = def(n): - if n is 0 or n is 1: - return 1 - if not factorial.cache[n]: - factorial.cache[n] = r(n-1) * n - return factorial.cache[n] - return r(x) -def floor(x): - return Math.floor(x) -def fmod(x, y): - # javascript's % operator isn't consistent with C fmod implementation, this function is - while y <= x: - x -= y - return x -def fsum(iterable): - # like Python's fsum, this method is much more resilient to rounding errors than regular sum - partials = [] # sorted, non-overlapping partial sums - for x in iterable: - i = 0 - for y in partials: - if Math.abs(x) < Math.abs(y): - x, y = y, x - hi = x + y - lo = y - (hi - x) - if lo: - partials[i] = lo - i += 1 - x = hi - #partials[i:] = [x] - partials.splice(i, partials.length-i, x) - return sum(partials) -def isinf(x): - return not isFinite(x) -def isnan(x): - return isNaN(x) -def modf(x): - m = fmod(x, 1) - return m, x-m -def trunc(x): - return x | 0 - -######################################## -# Power and logarithmic functions -######################################## -def exp(x): - return Math.exp(x) -def expm1(x): - # NOTE: Math.expm1() is currently only implemented in Firefox, this provides alternative implementation - # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/expm1 - #return Math.expm1(x) - if Math.abs(x) < 1e-5: - return x + 0.5*x*x - else: - return Math.exp(x) - 1 -def log(x, base=e): - return Math.log(x)/Math.log(base) -def log1p(x): - # NOTE: Math.log1p() is currently only implemented in Firefox, this provides alternative implementation - # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log1p - # this version has been taken from http://phpjs.org/functions/log1p/ - # admittedly it's not as accurate as MDN version, as you can see from math.log1p(1) result - ret = 0 - n = 50 - if x <= -1: - return Number.NEGATIVE_INFINITY - if x < 0 or x > 1: - return Math.log(1 + x) - for i in range(1, n): - if i % 2 is 0: - ret -= Math.pow(x, i) / i - else: - ret += Math.pow(x, i) / i - return ret -def log10(x): - # NOTE: Math.log10() is currently only implemented in Firefox, this provides alternative implementation - # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/log10 - # I didn't find a more accurate algorithm so I'm using the basic implementation - return Math.log(x)/Math.LN10 -def pow(x, y): - if x < 0 and int(y) is not y: - raise ValueError('math domain error') - if isnan(y) and x is 1: - return 1 - return Math.pow(x, y) -def sqrt(x): - return Math.sqrt(x) - -######################################## -# Trigonometric functions -######################################## -def acos(x): return Math.acos(x) -def asin(x): return Math.asin(x) -def atan(x): return Math.atan(x) -def atan2(y, x): return Math.atan2(y, x) -def cos(x): return Math.cos(x) -def sin(x): return Math.sin(x) -def hypot(x, y): return Math.sqrt(x*x + y*y) -def tan(x): return Math.tan(x) - -######################################## -# Angular conversion -######################################## -def degrees(x): return x*180/pi -def radians(x): return x*pi/180 - -######################################## -# Hyperbolic functions -######################################## -def acosh(x): - # NOTE: will be replaced with official, when it becomes mainstream - # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/acosh - return Math.log(x + Math.sqrt(x*x - 1)) -def asinh(x): - # NOTE: will be replaced with official, when it becomes mainstream - # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/asinh - return Math.log(x + Math.sqrt(x*x + 1)) -def atanh(x): - # NOTE: will be replaced with official, when it becomes mainstream - # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atanh - return 0.5 * Math.log((1 + x) / (1 - x)) -def cosh(x): - # NOTE: will be replaced with official, when it becomes mainstream - # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cosh - return (Math.exp(x) + Math.exp(-x)) / 2 -def sinh(x): - # NOTE: will be replaced with official, when it becomes mainstream - # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sinh - return (Math.exp(x) - Math.exp(-x)) / 2 -def tanh(x): - # NOTE: will be replaced with official, when it becomes mainstream - # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tanh - return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x)) - - - -#import stdlib -#print(math.ceil(4.2)) -#print(math.floor(4.2)) -#print(math.fabs(-6)) -#print(math.copysign(-5, 7)) -#print(math.factorial(4)) -#print(math.fmod(-1e100, 1e100)) -# -#d = [0.9999999, 1, 2, 3] -#print(sum(d), math.fsum(d)) -#print(math.isinf(5), math.isinf(Infinity)) -#print(math.modf(5.5)) -#print(math.trunc(2.6), math.trunc(-2.6)) -#print(math.exp(1e-5), math.expm1(1e-5)) -#print(math.log(10), math.log(10, 1000)) -#print(math.log1p(1e-15), math.log1p(1)) -#print(math.log10(1000), math.log(1000, 10)) -#print(math.pow(1, 0), math.pow(1, NaN), math.pow(0, 0), math.pow(NaN, 0), math.pow(4,3), math.pow(100, -2)) -#print(math.hypot(3,4)) -#print(math.acosh(2), math.asinh(1), math.atanh(0.5), math.cosh(1), math.cosh(-1), math.sinh(1), math.tanh(1)) diff --git a/resources/rapydscript/lib/operator.pyj b/resources/rapydscript/lib/operator.pyj deleted file mode 100644 index fc9fb7a9dd..0000000000 --- a/resources/rapydscript/lib/operator.pyj +++ /dev/null @@ -1,11 +0,0 @@ -add = __add__ = def(x, y): return x + y -sub = __sub__ = def(x, y): return x - y -mul = __mul__ = def(x, y): return x * y -div = __div__ = def(x, y): return x / y - -lt = __lt__ = def(x, y): return x < y -le = __le__ = def(x, y): return x <= y -eq = __eq__ = def(x, y): return x is y -ne = __ne__ = def(x, y): return x is not y -ge = __ge__ = def(x, y): return x >= y -gt = __gt__ = def(x, y): return x > y diff --git a/resources/rapydscript/lib/pythonize.pyj b/resources/rapydscript/lib/pythonize.pyj deleted file mode 100644 index e3da389361..0000000000 --- a/resources/rapydscript/lib/pythonize.pyj +++ /dev/null @@ -1,20 +0,0 @@ -# vim:fileencoding=utf-8 -# License: BSD Copyright: 2016, Kovid Goyal -# globals: ρσ_str - -def strings(): - string_funcs = set(( - 'capitalize strip lstrip rstrip islower isupper isspace lower upper swapcase' - ' center count endswith startswith find rfind index rindex format join ljust rjust' - ' partition rpartition replace split rsplit splitlines zfill').split(' ')) - - if not arguments.length: - exclude = {'split', 'replace'} - elif arguments[0]: - exclude = Array.prototype.slice.call(arguments) - else: - exclude = None - if exclude: - string_funcs = string_funcs.difference(set(exclude)) - for name in string_funcs: - String.prototype[name] = ρσ_str.prototype[name] diff --git a/resources/rapydscript/lib/random.pyj b/resources/rapydscript/lib/random.pyj deleted file mode 100644 index bacd5791b2..0000000000 --- a/resources/rapydscript/lib/random.pyj +++ /dev/null @@ -1,94 +0,0 @@ -########################################################### -# RapydScript Standard Library -# Author: Alexander Tsepkov -# Copyright 2013 Pyjeon Software LLC -# License: Apache License 2.0 -# This library is covered under Apache license, so that -# you can distribute it with your RapydScript applications. -########################################################### - - -# basic implementation of Python's 'random' library - -# JavaScript's Math.random() does not allow seeding its random generator, to bypass that, this module implements its own -# version that can be seeded. I decided on RC4 algorithm for this. - -# please don't mess with this from the outside - -ρσ_seed_state = { - 'key': [], - 'key_i': 0, - 'key_j': 0 -} - -ρσ_get_random_byte = def(): - ρσ_seed_state.key_i = (ρσ_seed_state.key_i + 1) % 256 - ρσ_seed_state.key_j = (ρσ_seed_state.key_j + ρσ_seed_state.key[ρσ_seed_state.key_i]) % 256 - ρσ_seed_state.key[ρσ_seed_state.key_i], ρσ_seed_state.key[ρσ_seed_state.key_j] = \ - ρσ_seed_state.key[ρσ_seed_state.key_j], ρσ_seed_state.key[ρσ_seed_state.key_i] - return ρσ_seed_state.key[(ρσ_seed_state.key[ρσ_seed_state.key_i] + \ - ρσ_seed_state.key[ρσ_seed_state.key_j]) % 256] - -def seed(x=Date().getTime()): - ρσ_seed_state.key_i = ρσ_seed_state.key_j = 0 - if jstype(x) is 'number': - x = x.toString() - elif jstype(x) is not 'string': - raise TypeError("unhashable type: '" + jstype(x) + "'") - for i in range(256): - ρσ_seed_state.key[i] = i - j = 0 - for i in range(256): - j = (j + ρσ_seed_state.key[i] + x.charCodeAt(i % x.length)) % 256 - ρσ_seed_state.key[i], ρσ_seed_state.key[j] = ρσ_seed_state.key[j], ρσ_seed_state.key[i] -seed() - -def random(): - n = 0 - m = 1 - for i in range(8): - n += ρσ_get_random_byte() * m - m *= 256 - return v'n / 0x10000000000000000' - -# unlike the python version, this DOES build a range object, feel free to reimplement -def randrange(): - return choice(range.apply(this, arguments)) - -def randint(a, b): - return int(random()*(b-a+1) + a) - -def uniform(a, b): - return random()*(b-a) + a - -def choice(seq): - if seq.length > 0: - return seq[Math.floor(random()*seq.length)] - else: - raise IndexError() - -# uses Fisher-Yates algorithm to shuffle an array -def shuffle(x, random_f=random): - for i in range(x.length): - j = Math.floor(random_f() * (i+1)) - x[i], x[j] = x[j], x[i] - return x - -# similar to shuffle, but only shuffles a subset and creates a copy -def sample(population, k): - x = population.slice() - for i in range(population.length-1, population.length-k-1, -1): - j = Math.floor(random() * (i+1)) - x[i], x[j] = x[j], x[i] - return x.slice(population.length-k) - - -#import stdlib -#a = range(50) -#random.seed(5) -#print(random.choice(a)) -#print(random.shuffle(a)) -#print(random.randrange(10)) -#print(random.randint(1,5)) -#print(random.uniform(1,5)) -#print(random.sample(range(20),5)) diff --git a/resources/rapydscript/lib/re.pyj b/resources/rapydscript/lib/re.pyj deleted file mode 100644 index 1ad1142e72..0000000000 --- a/resources/rapydscript/lib/re.pyj +++ /dev/null @@ -1,472 +0,0 @@ -# vim:fileencoding=utf-8 -# License: BSD -# Copyright: 2015, Kovid Goyal -# Copyright: 2013, Alexander Tsepkov - -# globals: ρσ_iterator_symbol, ρσ_list_decorate - -# basic implementation of Python's 're' library - -from __python__ import bound_methods - -# Alias DB from http://www.unicode.org/Public/8.0.0/ucd/NameAliases.txt {{{ -_ALIAS_MAP = {"null":0,"nul":0,"start of heading":1,"soh":1,"start of text":2,"stx":2,"end of text":3,"etx":3,"end of transmission":4,"eot":4,"enquiry":5,"enq":5,"acknowledge":6,"ack":6,"alert":7,"bel":7,"backspace":8,"bs":8,"character tabulation":9,"horizontal tabulation":9,"ht":9,"tab":9,"line feed":10,"new line":10,"end of line":10,"lf":10,"nl":10,"eol":10,"line tabulation":11,"vertical tabulation":11,"vt":11,"form feed":12,"ff":12,"carriage return":13,"cr":13,"shift out":14,"locking-shift one":14,"so":14,"shift in":15,"locking-shift zero":15,"si":15,"data link escape":16,"dle":16,"device control one":17,"dc1":17,"device control two":18,"dc2":18,"device control three":19,"dc3":19,"device control four":20,"dc4":20,"negative acknowledge":21,"nak":21,"synchronous idle":22,"syn":22,"end of transmission block":23,"etb":23,"cancel":24,"can":24,"end of medium":25,"eom":25,"substitute":26,"sub":26,"escape":27,"esc":27,"information separator four":28,"file separator":28,"fs":28,"information separator three":29,"group separator":29,"gs":29,"information separator two":30,"record separator":30,"rs":30,"information separator one":31,"unit separator":31,"us":31,"sp":32,"delete":127,"del":127,"padding character":128,"pad":128,"high octet preset":129,"hop":129,"break permitted here":130,"bph":130,"no break here":131,"nbh":131,"index":132,"ind":132,"next line":133,"nel":133,"start of selected area":134,"ssa":134,"end of selected area":135,"esa":135,"character tabulation set":136,"horizontal tabulation set":136,"hts":136,"character tabulation with justification":137,"horizontal tabulation with justification":137,"htj":137,"line tabulation set":138,"vertical tabulation set":138,"vts":138,"partial line forward":139,"partial line down":139,"pld":139,"partial line backward":140,"partial line up":140,"plu":140,"reverse line feed":141,"reverse index":141,"ri":141,"single shift two":142,"single-shift-2":142,"ss2":142,"single shift three":143,"single-shift-3":143,"ss3":143,"device control string":144,"dcs":144,"private use one":145,"private use-1":145,"pu1":145,"private use two":146,"private use-2":146,"pu2":146,"set transmit state":147,"sts":147,"cancel character":148,"cch":148,"message waiting":149,"mw":149,"start of guarded area":150,"start of protected area":150,"spa":150,"end of guarded area":151,"end of protected area":151,"epa":151,"start of string":152,"sos":152,"single graphic character introducer":153,"sgc":153,"single character introducer":154,"sci":154,"control sequence introducer":155,"csi":155,"string terminator":156,"st":156,"operating system command":157,"osc":157,"privacy message":158,"pm":158,"application program command":159,"apc":159,"nbsp":160,"shy":173,"latin capital letter gha":418,"latin small letter gha":419,"cgj":847,"alm":1564,"syriac sublinear colon skewed left":1801,"kannada letter llla":3294,"lao letter fo fon":3741,"lao letter fo fay":3743,"lao letter ro":3747,"lao letter lo":3749,"tibetan mark bka- shog gi mgo rgyan":4048,"fvs1":6155,"fvs2":6156,"fvs3":6157,"mvs":6158,"zwsp":8203,"zwnj":8204,"zwj":8205,"lrm":8206,"rlm":8207,"lre":8234,"rle":8235,"pdf":8236,"lro":8237,"rlo":8238,"nnbsp":8239,"mmsp":8287,"wj":8288,"lri":8294,"rli":8295,"fsi":8296,"pdi":8297,"weierstrass elliptic function":8472,"micr on us symbol":9288,"micr dash symbol":9289,"leftwards triangle-headed arrow with double vertical stroke":11130,"rightwards triangle-headed arrow with double vertical stroke":11132,"yi syllable iteration mark":40981,"presentation form for vertical right white lenticular bracket":65048,"vs1":65024,"vs2":65025,"vs3":65026,"vs4":65027,"vs5":65028,"vs6":65029,"vs7":65030,"vs8":65031,"vs9":65032,"vs10":65033,"vs11":65034,"vs12":65035,"vs13":65036,"vs14":65037,"vs15":65038,"vs16":65039,"byte order mark":65279,"bom":65279,"zwnbsp":65279,"cuneiform sign nu11 tenu":74452,"cuneiform sign nu11 over nu11 bur over bur":74453,"byzantine musical symbol fthora skliron chroma vasis":118981,"vs17":917760,"vs18":917761,"vs19":917762,"vs20":917763,"vs21":917764,"vs22":917765,"vs23":917766,"vs24":917767,"vs25":917768,"vs26":917769,"vs27":917770,"vs28":917771,"vs29":917772,"vs30":917773,"vs31":917774,"vs32":917775,"vs33":917776,"vs34":917777,"vs35":917778,"vs36":917779,"vs37":917780,"vs38":917781,"vs39":917782,"vs40":917783,"vs41":917784,"vs42":917785,"vs43":917786,"vs44":917787,"vs45":917788,"vs46":917789,"vs47":917790,"vs48":917791,"vs49":917792,"vs50":917793,"vs51":917794,"vs52":917795,"vs53":917796,"vs54":917797,"vs55":917798,"vs56":917799,"vs57":917800,"vs58":917801,"vs59":917802,"vs60":917803,"vs61":917804,"vs62":917805,"vs63":917806,"vs64":917807,"vs65":917808,"vs66":917809,"vs67":917810,"vs68":917811,"vs69":917812,"vs70":917813,"vs71":917814,"vs72":917815,"vs73":917816,"vs74":917817,"vs75":917818,"vs76":917819,"vs77":917820,"vs78":917821,"vs79":917822,"vs80":917823,"vs81":917824,"vs82":917825,"vs83":917826,"vs84":917827,"vs85":917828,"vs86":917829,"vs87":917830,"vs88":917831,"vs89":917832,"vs90":917833,"vs91":917834,"vs92":917835,"vs93":917836,"vs94":917837,"vs95":917838,"vs96":917839,"vs97":917840,"vs98":917841,"vs99":917842,"vs100":917843,"vs101":917844,"vs102":917845,"vs103":917846,"vs104":917847,"vs105":917848,"vs106":917849,"vs107":917850,"vs108":917851,"vs109":917852,"vs110":917853,"vs111":917854,"vs112":917855,"vs113":917856,"vs114":917857,"vs115":917858,"vs116":917859,"vs117":917860,"vs118":917861,"vs119":917862,"vs120":917863,"vs121":917864,"vs122":917865,"vs123":917866,"vs124":917867,"vs125":917868,"vs126":917869,"vs127":917870,"vs128":917871,"vs129":917872,"vs130":917873,"vs131":917874,"vs132":917875,"vs133":917876,"vs134":917877,"vs135":917878,"vs136":917879,"vs137":917880,"vs138":917881,"vs139":917882,"vs140":917883,"vs141":917884,"vs142":917885,"vs143":917886,"vs144":917887,"vs145":917888,"vs146":917889,"vs147":917890,"vs148":917891,"vs149":917892,"vs150":917893,"vs151":917894,"vs152":917895,"vs153":917896,"vs154":917897,"vs155":917898,"vs156":917899,"vs157":917900,"vs158":917901,"vs159":917902,"vs160":917903,"vs161":917904,"vs162":917905,"vs163":917906,"vs164":917907,"vs165":917908,"vs166":917909,"vs167":917910,"vs168":917911,"vs169":917912,"vs170":917913,"vs171":917914,"vs172":917915,"vs173":917916,"vs174":917917,"vs175":917918,"vs176":917919,"vs177":917920,"vs178":917921,"vs179":917922,"vs180":917923,"vs181":917924,"vs182":917925,"vs183":917926,"vs184":917927,"vs185":917928,"vs186":917929,"vs187":917930,"vs188":917931,"vs189":917932,"vs190":917933,"vs191":917934,"vs192":917935,"vs193":917936,"vs194":917937,"vs195":917938,"vs196":917939,"vs197":917940,"vs198":917941,"vs199":917942,"vs200":917943,"vs201":917944,"vs202":917945,"vs203":917946,"vs204":917947,"vs205":917948,"vs206":917949,"vs207":917950,"vs208":917951,"vs209":917952,"vs210":917953,"vs211":917954,"vs212":917955,"vs213":917956,"vs214":917957,"vs215":917958,"vs216":917959,"vs217":917960,"vs218":917961,"vs219":917962,"vs220":917963,"vs221":917964,"vs222":917965,"vs223":917966,"vs224":917967,"vs225":917968,"vs226":917969,"vs227":917970,"vs228":917971,"vs229":917972,"vs230":917973,"vs231":917974,"vs232":917975,"vs233":917976,"vs234":917977,"vs235":917978,"vs236":917979,"vs237":917980,"vs238":917981,"vs239":917982,"vs240":917983,"vs241":917984,"vs242":917985,"vs243":917986,"vs244":917987,"vs245":917988,"vs246":917989,"vs247":917990,"vs248":917991,"vs249":917992,"vs250":917993,"vs251":917994,"vs252":917995,"vs253":917996,"vs254":917997,"vs255":917998,"vs256":917999} -# }}} - -_ASCII_CONTROL_CHARS = {'a':7, 'b':8, 'f': 12, 'n': 10, 'r': 13, 't': 9, 'v': 11} -_HEX_PAT = /^[a-fA-F0-9]/ -_NUM_PAT = /^[0-9]/ -_GROUP_PAT = /<([^>]+)>/ -_NAME_PAT = /^[a-zA-Z ]/ - -I = IGNORECASE = 2 -L = LOCALE = 4 -M = MULTILINE = 8 -D = DOTALL = 16 -U = UNICODE = 32 -X = VERBOSE = 64 -DEBUG = 128 -A = ASCII = 256 - -supports_unicode = RegExp.prototype.unicode is not undefined - -_RE_ESCAPE = /[-\/\\^$*+?.()|[\]{}]/g - -_re_cache_map = {} -_re_cache_items = v'[]' - -error = SyntaxError # This is the error JS throws for invalid regexps -has_prop = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty) - -def _expand(groups, repl, group_name_map): - i = 0 - - def next(): - nonlocal i - return v'repl[i++]' - - def peek(): - return repl[i] - - def read_digits(count, pat, base, maxval, prefix): - ans = prefix or '' - greedy = count is Number.MAX_VALUE - while count > 0: - count -= 1 - if not pat.test(peek()): - if greedy: - break - return ans - ans += next() - nval = parseInt(ans, base) - if nval > maxval: - return ans - return nval - - def read_escape_sequence(): - nonlocal i - q = next() - if not q or q is '\\': - return '\\' - if '"\''.indexOf(q) is not -1: - return q - if _ASCII_CONTROL_CHARS[q]: - return String.fromCharCode(_ASCII_CONTROL_CHARS[q]) - if '0' <= q <= '9': - ans = read_digits(Number.MAX_VALUE, _NUM_PAT, 10, Number.MAX_VALUE, q) - if jstype(ans) is 'number': - return groups[ans] or '' - return '\\' + ans - if q is 'g': - m = _GROUP_PAT.exec(repl[i:]) - if m is not None: - i += m[0].length - gn = m[1] - if isNaN(parseInt(gn, 10)): - if not has_prop(group_name_map, gn): - return '' - gn = group_name_map[gn][-1] - return groups[gn] or '' - if q is 'x': - code = read_digits(2, _HEX_PAT, 16, 0x10FFFF) - if jstype(code) is 'number': - return String.fromCharCode(code) - return '\\x' + code - if q is 'u': - code = read_digits(4, _HEX_PAT, 16, 0x10FFFF) - if jstype(code) is 'number': - return String.fromCharCode(code) - return '\\u' + code - if q is 'U': - code = read_digits(8, _HEX_PAT, 16, 0x10FFFF) - if jstype(code) is 'number': - if code <= 0xFFFF: - return String.fromCharCode(code) - code -= 0x10000 - return String.fromCharCode(0xD800+(code>>10), 0xDC00+(code&0x3FF)) - return '\\U' + code - if q is 'N' and peek() is '{': - next() - name = '' - while _NAME_PAT.test(peek()): - name += next() - if peek() is not '}': - return '\\N{' + name - next() - key = (name or '').toLowerCase() - if not name or not has_prop(_ALIAS_MAP, key): - return '\\N{' + name + '}' - code = _ALIAS_MAP[key] - if code <= 0xFFFF: - return String.fromCharCode(code) - code -= 0x10000 - return String.fromCharCode(0xD800+(code>>10), 0xDC00+(code&0x3FF)) - - return '\\' + q - - ans = ch = '' - while True: - ch = next() - if ch is '\\': - ans += read_escape_sequence() - elif not ch: - break - else: - ans += ch - return ans - -def transform_regex(source, flags): - pos = 0 - previous_backslash = in_class = False - ans = '' - group_map = {} - flags = flags or 0 - group_count = 0 - - while pos < source.length: - ch = v'source[pos++]' - if previous_backslash: - ans += '\\' + ch - previous_backslash = False - continue - - if in_class: - if ch is ']': - in_class = False - ans += ch - continue - - if ch is '\\': - previous_backslash = True - continue - - if ch is '[': - in_class = True - if source[pos] is ']': # in python the empty set is not allowed, instead []] is the same as [\]] - pos += 1 - ch = r'[\]' - elif ch is '(': - if source[pos] is '?': - extension = source[pos + 1] - if extension is '#': - close = source.indexOf(')', pos + 1) - if close is -1: - raise ValueError('Expecting a closing )') - pos = close + 1 - continue - if 'aiLmsux'.indexOf(extension) is not -1: - flag_map = {'a':ASCII, 'i':IGNORECASE, 'L':LOCALE, 'm':MULTILINE, 's':DOTALL, 'u':UNICODE, 'x':VERBOSE} - close = source.indexOf(')', pos + 1) - if close is -1: - raise SyntaxError('Expecting a closing )') - flgs = source[pos+1:close] - for v'var i = 0; i < flgs.length; i++': - q = flgs[i] # noqa:undef - if not has_prop(flag_map, q): - raise SyntaxError('Invalid flag: ' + q) - flags |= flag_map[q] - pos = close + 1 - continue - if extension is '<': - raise SyntaxError('Look behind assertions are not supported in JavaScript') - if extension is '(': - raise SyntaxError('Group existence assertions are not supported in JavaScript') - if extension is 'P': - pos += 2 - q = source[pos] - if q is '<': - close = source.indexOf('>', pos) - if close is -1: - raise SyntaxError('Named group not closed, expecting >') - name = source[pos+1:close] - if not has_prop(group_map, name): - group_map[name] = v'[]' - group_map[name].push(v'++group_count') - pos = close + 1 - elif q is '=': - close = source.indexOf(')', pos) - if close is -1: - raise SyntaxError('Named group back-reference not closed, expecting a )') - name = source[pos+1:close] - if not isNaN(parseInt(name, 10)): - ans += '\\' + name - else: - if not has_prop(group_map, name): - raise SyntaxError('Invalid back-reference. The named group: ' + name + ' has not yet been defined.') - ans += '\\' + group_map[name][-1] - pos = close + 1 - continue - else: - raise SyntaxError('Expecting < or = after (?P') - else: - group_count += 1 - elif ch is '.' and (flags & DOTALL): - ans += r'[\s\S]' # JavaScript has no DOTALL - continue - - ans += ch - - return ans, flags, group_map - -class MatchObject: - - def __init__(self, regex, match, pos, endpos): - self.re = regex - self.string = match.input - self._start_pos = match.index - self._groups = match - self.pos, self.endpos = pos, endpos - - def _compute_extents(self): - # compute start/end for each group - match = self._groups - self._start = v'Array(match.length)' - self._end = v'Array(match.length)' - self._start[0] = self._start_pos - self._end[0] = self._start_pos + match[0].length - offset = self._start_pos - extent = match[0] - loc = 0 - for v'var i = 1; i < match.length; i++': - g = match[i] - loc = extent.indexOf(g, loc) - if loc is -1: - self._start[i] = self._start[i-1] - self._end[i] = self._end[i-1] - else: - self._start[i] = offset + loc - loc += g.length - self._end[i] = offset + loc # noqa:undef - - def groups(self, defval=None): - ans = v'[]' - for v'var i = 1; i < self._groups.length; i++': - val = self._groups[i] # noqa:undef - if val is undefined: - val = defval - ans.push(val) - return ans - - def _group_number(self, g): - if jstype(g) is 'number': - return g - if has_prop(self.re.group_name_map, g): - return self.re.group_name_map[g][-1] - return g - - def _group_val(self, q, defval): - val = undefined - if jstype(q) is 'number' and -1 < q < self._groups.length: - val = self._groups[q] - else: - if has_prop(self.re.group_name_map, q): - val = self._groups[self.re.group_name_map[q][-1]] - if val is undefined: - val = defval - return val - - def group(self): - if arguments.length is 0: - return self._groups[0] - ans = v'[]' - for v'var i = 0; i < arguments.length; i++': - q = arguments[i] # noqa:undef - ans.push(self._group_val(q, None)) - return ans[0] if ans.length is 1 else ans - - def start(self, g): - if self._start is undefined: - self._compute_extents() - val = self._start[self._group_number(g or 0)] - if val is undefined: - val = -1 - return val - - def end(self, g): - if self._end is undefined: - self._compute_extents() - val = self._end[self._group_number(g or 0)] - if val is undefined: - val = -1 - return val - - def span(self, g): - return [self.start(g), self.end(g)] - - def expand(self, repl): - return _expand(repl, this._groups, this.re.group_name_map) - - def groupdict(self, defval=None): - gnm = self.re.group_name_map - names = Object.keys(gnm) - ans = {} - for v"var i = 0; i < names.length; i++": - name = names[i] # noqa:undef - if has_prop(gnm, name): - val = self._groups[gnm[name][-1]] - if val is undefined: - val = defval - ans[name] = val - return ans - - def captures(self, group_name): - ans = [] - if not has_prop(self.re.group_name_map, group_name): - return ans - groups = self.re.group_name_map[group_name] - for v'var i = 0; i < groups.length; i++': - val = self._groups[groups[i]] # noqa:undef - if val is not undefined: - ans.push(val) - return ans - - def capturesdict(self): - gnm = self.re.group_name_map - names = Object.keys(gnm) - ans = {} - for v'var i = 0; i < names.length; i++': - name = names[i] # noqa:undef - ans[name] = self.captures(name) - return ans - -class RegexObject: - - def __init__(self, pattern, flags): - self.pattern = pattern.source if isinstance(pattern, RegExp) else pattern - self.js_pattern, self.flags, self.group_name_map = transform_regex(self.pattern, flags) - - modifiers = '' - if self.flags & IGNORECASE: modifiers += 'i' - if self.flags & MULTILINE: modifiers += 'm' - if not (self.flags & ASCII) and supports_unicode: - modifiers += 'u' - self._modifiers = modifiers + 'g' - self._pattern = RegExp(self.js_pattern, self._modifiers) - - def _do_search(self, pat, string, pos, endpos): - pat.lastIndex = 0 - if endpos is not None: - string = string[:endpos] - while True: - n = pat.exec(string) - if n is None: - return None - if n.index >= pos: - return MatchObject(self, n, pos, endpos) - - def search(self, string, pos=0, endpos=None): - return self._do_search(self._pattern, string, pos, endpos) - - def match(self, string, pos=0, endpos=None): - return self._do_search(RegExp('^' + self.js_pattern, self._modifiers), string, pos, endpos) - - def split(self, string, maxsplit=0): - self._pattern.lastIndex = 0 - return string.split(self._pattern, maxsplit or undefined) - - def findall(self, string): - self._pattern.lastIndex = 0 - return ρσ_list_decorate(string.match(self._pattern) or v'[]') - - def finditer(self, string): - # We have to copy pat since lastIndex is mutable - pat = RegExp(this._pattern.source, this._modifiers) # noqa: unused-local - ans = v"{'_string':string, '_r':pat, '_self':self}" - ans[ρσ_iterator_symbol] = def(): - return this - ans['next'] = def(): - m = this._r.exec(this._string) - if m is None: - return v"{'done':true}" - return v"{'done':false, 'value':new MatchObject(this._self, m, 0, null)}" - return ans - - def subn(self, repl, string, count=0): - expand = _expand - if jstype(repl) is 'function': - expand = def(m, repl, gnm): return '' + repl(MatchObject(self, m, 0, None)) - this._pattern.lastIndex = 0 - num = 0 - matches = v'[]' - - while count < 1 or num < count: - m = this._pattern.exec(string) - if m is None: - break - matches.push(m) - num += 1 - - for v'var i = matches.length - 1; i > -1; i--': - m = matches[i] # noqa:undef - start = m.index - end = start + m[0].length - string = string[:start] + expand(m, repl, self.group_name_map) + string[end:] - return string, matches.length - - def sub(self, repl, string, count=0): - return self.subn(repl, string, count)[0] - -def _get_from_cache(pattern, flags): - if isinstance(pattern, RegExp): - pattern = pattern.source - key = JSON.stringify(v'[pattern, flags]') - if has_prop(_re_cache_map, key): - return _re_cache_map[key] - if _re_cache_items.length >= 100: - v'delete _re_cache_map[_re_cache_items.shift()]' - ans = RegexObject(pattern, flags) - _re_cache_map[key] = ans - _re_cache_items.push(key) - return ans - -def compile(pattern, flags=0): - return _get_from_cache(pattern, flags) - -def search(pattern, string, flags=0): - return _get_from_cache(pattern, flags).search(string) - -def match(pattern, string, flags=0): - return _get_from_cache(pattern, flags).match(string) - -def split(pattern, string, maxsplit=0, flags=0): - return _get_from_cache(pattern, flags).split(string) - -def findall(pattern, string, flags=0): - return _get_from_cache(pattern, flags).findall(string) - -def finditer(pattern, string, flags=0): - return _get_from_cache(pattern, flags).finditer(string) - -def sub(pattern, repl, string, count=0, flags=0): - return _get_from_cache(pattern, flags).sub(repl, string, count) - -def subn(pattern, repl, string, count=0, flags=0): - return _get_from_cache(pattern, flags).subn(repl, string, count) - -def escape(string): - return string.replace(_RE_ESCAPE, '\\$&') - -def purge(): - nonlocal _re_cache_map, _re_cache_items - _re_cache_map = {} - _re_cache_items = v'[]' diff --git a/resources/rapydscript/lib/traceback.pyj b/resources/rapydscript/lib/traceback.pyj deleted file mode 100644 index a25bb32cff..0000000000 --- a/resources/rapydscript/lib/traceback.pyj +++ /dev/null @@ -1,51 +0,0 @@ -# vim:fileencoding=utf-8 -# License: BSD Copyright: 2016, Kovid Goyal -# globals: ρσ_str, ρσ_last_exception - -def _get_internal_traceback(err): - if isinstance(err, Exception) and err.stack: - lines = ρσ_str.splitlines(err.stack) - for i, line in enumerate(lines): - line = ρσ_str.strip(line) - # These two conditions work on desktop Chrome and Firefox to identify the correct - # line in the traceback. - if line.startsWith('at new ' + err.name) or line.startsWith(err.name + '@'): - return err.__repr__() + '\n' + lines.slice(i+1).join('\n') - return err and err.stack - -def format_exception(exc, limit): - if not isinstance(exc, Error): - if exc and exc.toString: - return [exc.toString()] - return [] - tb = _get_internal_traceback(exc) - if tb: - lines = ρσ_str.splitlines(tb) - e = lines[0] - lines = [l for l in lines[1:]] - if limit: - lines = lines[:limit+1] if limit > 0 else lines[limit:] - lines.reverse() - lines.push(e) - lines.insert(0, 'Traceback (most recent call last):') - return [l+'\n' for l in lines] - return [exc.toString()] - -def format_exc(limit): - return format_exception(ρσ_last_exception, limit).join('') - -def print_exc(limit): - print(format_exc(limit)) - -def format_stack(limit): - stack = Error().stack - if not stack: - return [] - lines = str.splitlines(stack)[2:] - lines.reverse() - if limit: - lines = lines[:limit+1] if limit > 0 else lines[limit:] - return [l + '\n' for l in lines] - -def print_stack(limit): - print(format_stack(limit).join('')) diff --git a/resources/rapydscript/lib/uuid.pyj b/resources/rapydscript/lib/uuid.pyj deleted file mode 100644 index ad69d1e085..0000000000 --- a/resources/rapydscript/lib/uuid.pyj +++ /dev/null @@ -1,77 +0,0 @@ -# vim:fileencoding=utf-8 -# License: BSD Copyright: 2017, Kovid Goyal -# globals: crypto -from __python__ import hash_literals - -from encodings import hexlify, urlsafe_b64decode, urlsafe_b64encode - -RFC_4122 = 1 - -if jstype(crypto) is 'object' and crypto.getRandomValues: - random_bytes = def (num): - ans = Uint8Array(num or 16) - crypto.getRandomValues(ans) - return ans -else: - random_bytes = def (num): - ans = Uint8Array(num or 16) - for i in range(ans.length): - ans[i] = Math.floor(Math.random() * 256) - return ans - - -def uuid4_bytes(): - data = random_bytes() - data[6] = 0b01000000 | (data[6] & 0b1111) - data[8] = (((data[8] >> 4) & 0b11 | 0b1000) << 4) | (data[8] & 0b1111) - return data - - -def as_str(): - h = this.hex - return h[:8] + '-' + h[8:12] + '-' + h[12:16] + '-' + h[16:20] + '-' + h[20:] - - -def uuid4(): - b = uuid4_bytes() - return { - 'hex': hexlify(b), - 'bytes': b, - 'variant': RFC_4122, - 'version': 4, - '__str__': as_str, - 'toString': as_str, - } - - -def num_to_string(numbers, alphabet, pad_to_length): - ans = v'[]' - alphabet_len = alphabet.length - numbers = Array.prototype.slice.call(numbers) - for v'var i = 0; i < numbers.length - 1; i++': - x = divmod(numbers[i], alphabet_len) - numbers[i] = x[0] - numbers[i+1] += x[1] - for v'var i = 0; i < numbers.length; i++': - number = numbers[i] - while number: - x = divmod(number, alphabet_len) - number = x[0] - ans.push(alphabet[x[1]]) - if pad_to_length and pad_to_length > ans.length: - ans.push(alphabet[0].repeat(pad_to_length - ans.length)) - return ans.join('') - - -def short_uuid(): - # A totally random uuid encoded using only URL and filename safe characters - return urlsafe_b64encode(random_bytes(), '') - - -def short_uuid4(): - # A uuid4 encoded using only URL and filename safe characters - return urlsafe_b64encode(uuid4_bytes(), '') - - -def decode_short_uuid(val): - return urlsafe_b64decode(val + '==')