{
  "version": 3,
  "sources": ["../../lib/ac.js", "../../lib/crypto.js", "../../lib/enum.js", "../../lib/base_convert.js", "../../lib/base_func.js", "../../lib/base_hex64.js", "../../lib/everything.js", "../../lib/tree.js"],
  "sourcesContent": ["\"use strict\";\n\nimport * as Coze from '../pkg/coze_all~fv=-7uCIHNa.min.js'\nimport * as Crypto from './crypto.js'\n// import {\n// \tIsCyphrmeDigest\n// } from '../app/cyphrme.js';\n\nexport {\n\tAnticounterfeitCanon,\n\n\tNewAnticounterfeit,\n\tAppendToObject,\n};\n\n/**\n@typedef {import('../../../pkg/cozejs/typedef.js').B64}     B64\n@typedef {import('../../../pkg/cozejs/typedef.js').Coze}    Coze\n@typedef {import('../../../pkg/cozejs/typedef.js').Dig}     Dig\n@typedef {import('../../../pkg/cozejs/typedef.js').Pay}     Pay\n@typedef {import('../../../pkg/cozejs/typedef.js').Alg}     Alg\n@typedef {import('../app/ac_gen.js').ACOptions}             ACOptions\n@typedef {import('../page/ac_gen_pj.js').PJ}                PJ\n*/\n\n// Required fields\nconst AnticounterfeitCanon = [\"alg\", \"iat\", \"tmb\", \"typ\", \"id\"]\n\n/**\nNewAntiCounterfeit generates a new basic anti-counterfeit.  Accepts an\noptional existing AC, and fields are added/existing fields are used where\napplicable.  \nSince seed is not currently preserved, so on random generated ID's there is\nno seed, and if Seed is needed, id needs to be the digest of seed.  \nThrows error when given an ID in pay, but is not a valid cyphr.me digest.\n\nReturns in this form:\n{\n \"pay\": {\n  \"alg\": \"ES256\",\n  \"iat\": 1686263707,\n  \"tmb\": \"dfzR4DYK8o36trYoMGbOEdvdLrjFjcdku0tdZ6h4cok\",\n  \"typ\": \"cyphr.me/ac/create\",\n  \"id\": \"K5RyJ04c2gb5JBMQ-9Icr5tTJGlgBV8XaYAAEUMxdMA\",\n },\n \"sig\": \"O2Ovsbc5dFHq6e9OI42KACl-1x757o0r0130NGlMbTRHumtI_azeNIQ_pDpsJOnm2UCMm7-yWQeSJ4695tid1w\"\n}\n\n@param   {CozeKey} cozeKey     CozeKey\n@param   {AC}      [ac]        Optional existing AC.  (coze.pay)\n@returns {AC}\n@throws  {error}\n*/\nasync function NewAnticounterfeit(cozeKey, ac) {\n\t// console.debug(pay, isEmpty(pay))\n\tif (isEmpty(ac)) {\n\t\tac = {}\n\t}\n\n\t// To avoid overwriting/modifying the original reference copy.\n\tlet pay = {\n\t\t...ac\n\t}\n\tpay.alg = cozeKey.alg\n\tpay.iat = Now()\n\tpay.tmb = cozeKey.tmb\n\tpay.typ = \"cyphr.me/ac/create\"\n\tif (!(\"id\" in pay)) {\n\t\tpay.id = await Crypto.RandomIDB64(cozeKey.alg)\n\t}\n\n\t// console.log(pay)\n\treturn await Coze.Sign({\n\t\t\"pay\": pay\n\t}, cozeKey, AnticounterfeitCanon)\n}\n\n\n\n/**\nAppendToObject appends `objToAppend` to `obj` without loosing reference to the\noriginal object.  Making a copy of the original `obj` requires assignment (\"=\",\ne.g. o = {...o}), and assignment causes reference loss. // TODO write test to\nmake sure this is the case. For global stateful objects, keeping the reference\nmay be critical, as other modules lose reference when assignment is made.\n\nThe spread operator necessitates assignment, which is what loses reference.\nDon't use the copy syntax if needing the same reference, for example:\n```\nACs = {\n\t...ACs,\n\t...moreACs\n}\n```\n\nTODO if tests confirm our suspicion that assignment is the problem, add test to\ndoc and move this function to helpers.\n\nTODO consider renaming to AppendObjectToObject\n@param   {object}  obj\n@param   {object}  objToAppend\n@returns {void}\n*/\nfunction AppendToObject(obj, objToAppend) {\n\tfor (let key in objToAppend) {\n\t\tobj[key] = objToAppend[key]\n\t}\n}", "\"use strict\";\n\nimport * as Coze from '../pkg/coze_all~fv=-7uCIHNa.min.js'\n\n// Use Coze's CanonicalHash for Hashing JS things.  \nexport {\n\tHashAB,\n\tHashFile,\n\tHashFileCallback,\n\tRandomB64,\n\tRandomIDB64,\n}\n\n\n/**\n@typedef {import('../../../pkg/cozejs/typedef.js').Hsh}    Hsh\n@typedef {import('../../../pkg/cozejs/typedef.js').Dig}    Dig\n */\n\n/**\nHashAB hashes an ArrayBuffer.\nNon hash algs (ES256) are converted to hash algs (SHA-256).\n@param  {ArrayBuffer} ab             Javascript ArrayBuffer\n@param  {Hsh}         [alg=SHA-256]  Coze hash alg.\n@return {Dig}\n */\nasync function HashAB(ab, alg) {\n\tif (isEmpty(alg)) {\n\t\talg = \"SHA-256\"\n\t}\n\treturn Coze.ArrayBufferTo64ut(await crypto.subtle.digest(Coze.HashAlg(alg), ab))\n}\n\n/**\nHashFile hashes a blob synchronously.\nNon hash algs (ES256) are converted to hash algs (SHA-256).\n@param  {Blob} file            Blob\n@param  {Hsh}  [alg=SHA-256]   Coze hash alg.\n@return {Dig}\n */\nasync function HashFile(file, alg) {\n\tif (isEmpty(alg)) {\n\t\talg = \"SHA-256\";\n\t}\n\talg = Coze.HashAlg(alg);\n\tlet buffer = await file.arrayBuffer();\n\tlet ab = await crypto.subtle.digest(alg, buffer);\n\treturn await Coze.ArrayBufferTo64ut(ab);\n};\n\n/** \nHashFileCallback hashes a blob asynchronously.\nNon hash algs (ES256) are converted to hash algs (SHA-256).\n@param  {Blob}     file           blob\n@param  {Hsh}      [alg=SHA-256]  Coze hash alg.\n@param  {function} [callback]     Optional callback\n@return {Dig}\n */\nasync function HashFileCallback(file, callback) {\n\tif (isEmpty(alg)) {\n\t\talg = \"SHA-256\";\n\t}\n\talg = Coze.HashAlg(alg);\n\n\tlet reader = new FileReader();\n\treader.readAsArrayBuffer(file);\n\treader.onloadend = async function () {\n\t\tlet ab = await crypto.subtle.digest(\"SHA-256\", reader.result);\n\t\tlet digest = await Coze.ArrayBufferTo64ut(ab);\n\t\tif (!isEmpty(callback)) {\n\t\t\treturn callback(digest);\n\t\t}\n\t\treturn digest;\n\t}\n};\n\n/** \nRandomB64 returns a random B64 encoded string.\n@param  {number} [num] Number of random bytes. Defaults to 32 (32 for 256 bits of entropy).\n@return {B64}\n */\nasync function RandomB64(num) {\n\tif (isEmpty(num)) {\n\t\tnum = 32\n\t}\n\tlet randomArray = new Uint8Array(num)\n\twindow.crypto.getRandomValues(randomArray)\n\treturn Coze.ArrayBufferTo64ut(randomArray)\n}\n\n/** \nRandomIDB64 returns a random B64 encoded double digest.\n@param  {Alg} [alg] Alg used for hashing algo. Defaults to SHA-256.\n@return {B64}\n */\nasync function RandomIDB64(alg) {\n\tif (isEmpty(alg)) {\n\t\talg = \"SHA-256\"\n\t}\n\tlet randomArray = new Uint8Array(Coze.HashSize(alg))\n\twindow.crypto.getRandomValues(randomArray)\n\treturn Coze.ArrayBufferTo64ut(await crypto.subtle.digest(Coze.HashAlg(alg), await crypto.subtle.digest(Coze.HashAlg(alg), randomArray)))\n}", "\"use strict\";\n\n/*\nWe recommend using hex when dealing with the arraybuffer (Uint8Array).  Why\nHex? Because \"RFC 4648 base64 (maybe URI safe and maybe padded or truncated)\ncannot represent all numbers without accounting for _right_ padding. For\nexample Javascript's base64 encoding cannot represent 2^256  in a _left\npadding paradigm_ (like decimal, hex, dozenal, etc...) because Javascript's\nbase64 is in 43 6 bit buckets, or 258 bits. \n\nHex avoids this because it's 4 bit buckets fit into bytes and is left padded.  \n*/\n\nconst Base10 = \"0123456789\";\nconst Base16 = \"0123456789ABCDEF\";\nconst Base16Lower = \"0123456789abcdef\";\n\n///////////////////////\n// RFC 4648 base64s\n///////////////////////\n// RFCBase64Unsafe is a URI unsafe base 64 alphabet, the \"default\" for RFC 4648. \nconst RFCBase64Unsafe = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n// RFCBase64Uri is RFC 4648 URI safe base 64 alphabet.  \nconst RFCBase64Uri = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\";\n\n// ASCII Extended control and non printable characters.\nconst ASCIIExtCTRLNPChars = String.fromCharCode(\n\t// First two rows and space\n\t0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,\n\t22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,\n\t// Row 9, 10, NBSP, and soft hyphen\n\t127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,\n\t142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156,\n\t157, 158, 159, 160, 173\n);\n\n\n// Start: Remove when merging with Zami's BaseConvert \n\n\nexport {\n\tAB,\n};\n\n// This section includes all of Cyphr.me's proprietary alphabets, as well as any\n// enums that should not ever be pushed up or down stream.\n\n///////////////////////\n// (Patent Pending) Cyphr.me, Cypherpunk LLC Alphabets\n///////////////////////\n// (Patent Pending) Cyphr.me, Cypherpunk LLC, BASE37\n// Base37 are URI friendly base 37.\nconst BASE37 = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-\";\n\n// (Patent Pending) Cyphr.me, Cypherpunk LLC, BASE38-QR-URI-UNRESERVED\nconst BASE38 = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-.\";\n\n// (Patent Pending) Cyphr.me, Cypherpunk LLC, BASE45 The full QR-URI alphabet\nconst BASE45 = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-/$%*+: .\";\n\n// (Patent Pending) Cyphr.me, Cypherpunk LLC, Base64 (**NOT THE RFC \"base64\"**) \nconst Base64 = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_\";\n\n// (Patent Pending) Cyphr.me, Cypherpunk LLC, Base64 Base66-uri-unreserved.\n// Named \"Unreserved\" since it is not a truncation of Base191.  If it were, it would simple be \"Base66Uri\".\nconst Base66UriUnreserved = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_.~\";\n\n// ((Patent Pending) Cyphr.me, Cypherpunk LLC, Full Base191 alphabet\n// Note the escaping '\\' character before the double quote char '\"'\nconst Base191 = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_.~!\\\"$'()*+,:;<=>?@[\\]^`{|}\u00A1\u00A2\u00A3\u00A4\u00A5\u00A6\u00A7\u00A8\u00A9\u00AA\u00AB\u00AC\u00AE\u00AF\u00B0\u00B1\u00B2\u00B3\u00B4\u00B5\u00B6\u00B7\u00B8\u00B9\u00BA\u00BB\u00BC\u00BD\u00BE\u00BF\u00C0\u00C1 \u00C3\u00C4\u00C5\u00C6\u00C7\u00C8\u00C9\u00CA\u00CB\u00CC\u00CD\u00CE\u00CF\u00D0\u00D1\u00D2\u00D3\u00D4\u00D5\u00D6\u00D7\u00D8\u00D9\u00DA\u00DB\u00DC\u00DD\u00DE\u00DF\u00E0\u00E1\u00E2\u00E3\u00E4\u00E5\u00E6\u00E7\u00E8\u00E9\u00EA\u00EB\u00EC\u00ED\u00EE\u00EF\u00F0\u00F1\u00F2\u00F3\u00F4\u00F5\u00F6\u00F7\u00F8\u00F9\u00FA\u00FB\u00FC\u00FD\u00FE\u00FF#%&/ \"\n\n// AB must be last, for all alphabets must be defined first.\n// Defined Alphabets.  AB = \"alphabets\"\nvar AB = {\n\tASCIIExtCTRLNPChars: ASCIIExtCTRLNPChars,\n\tBase10: Base10,\n\tBase16: Base16,\n\tBase16Lower: Base16Lower,\n\tBASE37: BASE37,\n\tBASE38: BASE38,\n\tBASE45: BASE45,\n\tBase64: Base64,\n\tBase66UriUnreserved: Base66UriUnreserved,\n\tBase191: Base191,\n\tRFCBase64Unsafe: RFCBase64Unsafe,\n\tRFCBase64Uri: RFCBase64Uri,\n};\n\n\n// End: Non merge section", "\"use strict\";\n\n// BaseConvert function was taken from https://github.com/zamicol/BaseConverter\nexport {\n\tBaseConvert,\n\tBASE37Padded,\n}\n\nimport {\n\tAB\n} from \"./enum.js\";\n\n/**\nBASE37Padded accepts input, input alphabet, and alg and returns BASE37\npadded.  Alg is used to enforce padding.  \n@param   {string} in          String. Number being converted.\n@param   {string} inputBase   String. Input alphabet for in.\n@param   {string} alg         String. Alg for specifying length.\n@returns {string}             BASE37 padded to alg's specified length.\n@throws  {error}              Returns error on unsupported algs.\n */\nfunction BASE37Padded(input, inputBase, alg) {\n\t// console.debug(input,inputBase,alg, AB);\n\tlet b37 = BaseConvert(input, inputBase, AB.BASE37);\n\tswitch (alg) {\n\t\tcase 'ES256':\n\t\tcase 'SHA-256':\n\t\t\treturn b37.padStart(50, \"0\");\n\t\tcase \"ES384\":\n\t\tcase 'SHA-384':\n\t\t\treturn b37.padStart(74, \"0\");\n\t\tcase \"ES512\":\n\t\tcase 'SHA-512':\n\t\t\treturn b37.padStart(99, \"0\");\n\t\tdefault:\n\t\t\tthrow new Error(\"base_convert.BASE37Padded: unsupported alg\");\n\t}\n};\n\n\n// baseConvert converts a given string with a given encoding alphabet\n// \n//\n// Base is assumed from alphabet sizes. \n\n// LeftPadding is for preceding padding characters.  By default padding should\n// be ignored as it carries no meaning.  For example, for the base 7 alphabet\n// of \"ABCDEFG\", the padding character is \"A\". For the base 8 alphabet of\n// \"01234567\", the padding character is \"0\".  Padding characters are preserved\n// on a 1:1 character basis.  \nlet LeftPadding = false;\n\n/**\nBaseConvert converts a given string with a given encoding alphabet into\nanother base with another given encoding alphabet.\nBase is assumed from alphabet sizes.\n@param  {string} input     Input string.  \n@param  {string} inAlph    Input alphabet (i.e. 0123456789ABCDEF)\n@param  {string} outAlph   Output alphabet (i.e. ABCDEFGHJKLMNPQRSTUVWXYZ234567)\n */\nfunction BaseConvert(input, inAlph, outAlph) {\n\t// console.log(\"baseConvert: \", input, inAlph, outAlph);\n\tif (input === null || input == \"\" || inAlph == \"\" || outAlph == \"\") {\n\t\treturn null;\n\t}\n\n\tconst fromBase = inAlph.length;\n\tconst toBase = outAlph.length;\n\tconst inAlphChars = inAlph.split('');\n\t// TODO support Base 1 decoding.  \n\tif (toBase == 1) return;\n\n\tconst add = (x, y, base) => {\n\t\tlet z = [];\n\t\tconst n = Math.max(x.length, y.length);\n\t\tlet carry = 0;\n\t\tlet i = 0;\n\t\twhile (i < n || carry) {\n\t\t\tconst xi = i < x.length ? x[i] : 0;\n\t\t\tconst yi = i < y.length ? y[i] : 0;\n\t\t\tconst zi = carry + xi + yi;\n\t\t\tz.push(zi % base);\n\t\t\tcarry = Math.floor(zi / base);\n\t\t\ti++;\n\t\t}\n\t\treturn z;\n\t}\n\n\tconst multiplyByNumber = (num, power, base) => {\n\t\tif (num < 0) return null;\n\t\tif (num === 0) return [0]; // Zero is legit. \n\n\t\tlet result = [];\n\t\twhile (true) {\n\t\t\tnum & 1 && (result = add(result, power, base));\n\t\t\tnum = num >> 1;\n\t\t\tif (num === 0) break;\n\t\t\tpower = add(power, power, base);\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t// decodeInput finds the position of each character in alphabet, thus decoding\n\t// input into a useful array.  \n\tconst decodeInput = (input) => {\n\t\t// console.log(\"decodeInput: \", string);\n\t\tconst digits = input.split('');\n\t\tlet arr = [];\n\t\tfor (let i = digits.length - 1; i >= 0; i--) {\n\t\t\t// Check for character in alphabet\n\t\t\tif (!(inAlphChars.includes(digits[i]))) {\n\t\t\t\tthrow new Error('character not in alphabet: ' + digits[i]);\n\t\t\t}\n\t\t\tconst n = inAlph.indexOf(digits[i])\n\t\t\t// Continue even if character is not found (possibly a padding character.)\n\t\t\tif (n == -1) continue;\n\t\t\t// Alternatively, fail on bad character\n\t\t\t// if (n == -1) return null;\n\t\t\tarr.push(n);\n\t\t}\n\t\treturn arr;\n\t}\n\n\tconst digits = decodeInput(input);\n\tif (digits === null) return null; // zero case is legit.  \n\t// Get an array of what each position of character should be. \n\tlet outArray = [];\n\tlet power = [1];\n\tfor (let i = 0; i < digits.length; i++) {\n\t\toutArray = add(outArray, multiplyByNumber(digits[i], power, toBase), toBase);\n\t\tpower = multiplyByNumber(fromBase, power, toBase);\n\t}\n\n\t// Finally, decode array into characters.  \n\tlet out = '';\n\t// Preceding padding characters - Add back in preceding padding characters.\n\tif (LeftPadding) {\n\t\tlet inPad = inAlph.charAt(0);\n\t\tlet outPad = outAlph.charAt(0);\n\t\tlet i = 0;\n\t\twhile (i < input.length) {\n\t\t\tif (input.charAt(i) !== inPad) break;\n\t\t\tout += outPad;\n\t\t\ti++;\n\t\t}\n\t}\n\n\tfor (let i = outArray.length - 1; i >= 0; i--) {\n\t\tout += outAlph[outArray[i]];\n\t}\n\n\treturn out;\n}", "\"use strict\";\n\nexport {\n\tConcatBuffers,\n\tSToArrayBuffer,\n\tArrayBufferToS,\n\tASCIIExtToChiclets,\n\tBitPerBase,\n\tExplodeBytes,\n\tGoBytesToHex,\n\tGoBytesToString,\n\tHexToGoBytesString,\n\tRemovePad,\n\tSysCnvToHex,\n\tToUTF8Array,\n\tArrayBufferToBigInt,\n\tBigIntToArrayBuffer,\n\n\t// General base64 and Hex functions are in base_hex64.js\n}\n\n/**\n@typedef {import('./typedef.js').Hex}                   Hex\n */\n\nimport {\n\tAB\n} from \"./enum.js\";\n\nvar ASCIIExtCTRLNPChars = AB.ASCIIExtCTRLNPChars;\n\n/**\nConcatenates the two given array buffers.\n@param  {ArrayBuffer} b1 The first buffer.\n@param  {ArrayBuffer} b2 The second buffer.\n@return {ArrayBuffer} The new ArrayBuffer created out of the two.\n */\nfunction ConcatBuffers(b1, b2) {\n\tvar tmp = new Uint8Array(b1.byteLength + b2.byteLength)\n\ttmp.set(new Uint8Array(b1), 0)\n\ttmp.set(new Uint8Array(b2), b1.byteLength)\n\treturn tmp.buffer\n}\n\n/**\nConverts a string to an ArrayBuffer.   \n@param  {string}        string\n@return {ArrayBuffer}\n */\nasync function SToArrayBuffer(string) {\n\tvar enc = new TextEncoder(); // Suppose to be always in UTF-8\n\tlet uint8array = enc.encode(string);\n\treturn uint8array.buffer;\n}\n\n/**\nConverts an ArrayBuffer to a UTF-8 string.   \n@param  {string}        string\n@return {string}\n */\nasync function ArrayBufferToS(ab) {\n\tvar enc = new TextDecoder(\"UTF-8\");\n\tlet s = await enc.decode(ab);\n\treturn s;\n}\n\n/**\nReturns the exploded byte array from \",\".\nExample: input = \"[255,64,32]\" : return = [\"255\", \"64\", \"32\"]\n@param   {string}    input     Go Bytes representation as a string.\n@returns {string[]}            Array of numbers, as string type.\n@throws  {error}               Syntax error.\n */\nfunction ExplodeBytes(input) {\n\tif (input.charAt(0) != \"[\" && input.charAt(0) != \"{\") {\n\t\tthrow new SyntaxError(\"not in correct byte format: [255, ...]\");\n\t}\n\t// Supports trailing comma (but returns it removed).\n\tif (input.charAt(input.length - 2) == \",\") {\n\t\treturn input.substring(1, input.length - 2).split(\",\");\n\t}\n\treturn input.substring(1, input.length - 1).split(\",\");\n}\n\n/**\nConvert from a Go Bytes representation, to string.\n@param   {string}  input      Go Bytes representation as a string.\n@returns {string} \n@throws  {error}              Syntax error.\n */\nfunction GoBytesToString(input) {\n\tlet unicode = \"\";\n\tfor (let c of ExplodeBytes(input)) {\n\t\tunicode += String.fromCodePoint(c);\n\t}\n\treturn unicode;\n}\n\n/**\nConvert from a Go Bytes representation, to Hex.\nEmpty bytes returns \"\".\n@param   {string}  input         Go Bytes representation as a string.\n@returns {Hex}\n@throws  {error}                 Syntax error.\n */\nfunction GoBytesToHex(input) {\n\tlet hex = \"\";\n\tlet chunks = ExplodeBytes(input);\n\t// Empty bytes check\n\tif (chunks.length == 1 && isEmpty(chunks[0])) {\n\t\treturn hex;\n\t}\n\tfor (let c of chunks) {\n\t\thex += parseInt(c).toString(16).toUpperCase().padStart(2, \"0\");\n\t}\n\treturn hex;\n}\n\n// Returns the Hex string in the Hex line from a correctly formatted SysCnv conversion.\nfunction SysCnvToHex(inputText) {\n\tlet hexLine = inputText.split(\"\\n\", 1)[0];\n\tif (hexLine.substring(0, 4) != \"Hex:\") {\n\t\tthrow new SyntaxError('Not in the correct SysCnv format.');\n\t}\n\treturn hexLine.split(' ', 2)[1];\n}\n\n/**\nConvert a hex string to a byte array\n@param   {Hex}  hex\n@returns {string}  Go Bytes representation.\n */\nfunction HexToGoBytesString(hex) {\n\tfor (var bytes = [], i = 0; i < hex.length; i += 2)\n\t\tbytes.push(parseInt(hex.substr(i, 2), 16)); // .substring does not return same results\n\treturn \"[\" + bytes + \"]\";\n}\n\n/**\nGet how many bits are needed to represent a particular number base\n@param  {number} base The length of the characters of the alphabet (the base,\ne.g. for base 64 would be the number 64 and the output would be 6)\n@returns {number} The number of bits required to represent the base.  \n */\nfunction BitPerBase(base) {\n\tvar bits = 0;\n\tvar space = 1;\n\n\twhile (base > space) {\n\t\tspace = space * 2;\n\t\tbits++;\n\t}\n\treturn bits;\n}\n\n// TODO deprecate for something more general. \n// Returns string from the input string, where any control/non-printable characters\n// are represented as a chiclet (including space).\n// See also Mojibake (https://en.wikipedia.org/wiki/Mojibake)\nfunction ASCIIExtToChiclets(string) {\n\tlet outString = \"\";\n\tfor (let char of string) {\n\t\tif (ASCIIExtCTRLNPChars.includes(char)) {\n\t\t\toutString += '\u0005';\n\t\t\tcontinue;\n\t\t}\n\t\toutString += char;\n\t}\n\treturn outString;\n}\n\n// TODO Not in use and not working\n// RemovePad is a helper function removes pad but not the single zero case.\nfunction RemovePad(input, inAlph) {\n\t// console.debug(\"RemovePad\", input, inAlph);\n\tif (input.length == 1) {\n\t\treturn input;\n\t}\n\t// Remove padding characters\n\tlet inPad = inAlph.charAt(0);\n\tfor (var i = 0; i < input.length; i++) {\n\t\tif (input.charAt(i) !== inPad) {\n\t\t\tbreak;\n\t\t}\n\t}\n\treturn input.substring(i);\n}\n\n\n/**\nConverts an ArrayBuffer to a UTF-8 string.\n@param  {ArrayBuffer} ab\n@return {string}\n */\nasync function ArrayBufferToS(ab) {\n\tvar enc = new TextDecoder(\"UTF-8\")\n\treturn enc.decode(ab)\n}\n\n/**\nToUTF8Array accepts a string and returns the utf8 encoding of the string.\nhttps://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array\n@param   {string}     str     String that is being converted to UTF-8.\n@returns {number[]}           Number array returned from the input string.\n */\nfunction ToUTF8Array(str) {\n\tvar utf8 = [];\n\tfor (var i = 0; i < str.length; i++) {\n\t\tvar charcode = str.charCodeAt(i);\n\t\tif (charcode < 0x80) utf8.push(charcode);\n\t\telse if (charcode < 0x800) {\n\t\t\tutf8.push(0xc0 | (charcode >> 6),\n\t\t\t\t0x80 | (charcode & 0x3f));\n\t\t} else if (charcode < 0xd800 || charcode >= 0xe000) {\n\t\t\tutf8.push(0xe0 | (charcode >> 12),\n\t\t\t\t0x80 | ((charcode >> 6) & 0x3f),\n\t\t\t\t0x80 | (charcode & 0x3f));\n\t\t}\n\t\t// surrogate pair\n\t\telse {\n\t\t\ti++;\n\t\t\t// UTF-16 encodes 0x10000-0x10FFFF by\n\t\t\t// subtracting 0x10000 and splitting the\n\t\t\t// 20 bits of 0x0-0xFFFFF into two halves\n\t\t\tcharcode = 0x10000 + (((charcode & 0x3ff) << 10) |\n\t\t\t\t(str.charCodeAt(i) & 0x3ff));\n\t\t\tutf8.push(0xf0 | (charcode >> 18),\n\t\t\t\t0x80 | ((charcode >> 12) & 0x3f),\n\t\t\t\t0x80 | ((charcode >> 6) & 0x3f),\n\t\t\t\t0x80 | (charcode & 0x3f));\n\t\t}\n\t}\n\treturn utf8;\n};\n\n//https://stackoverflow.com/questions/13356493/decode-utf-8-with-javascript\n//https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent\nfunction encode_utf8(s) {\n\treturn unescape(encodeURIComponent(s));\n};\n\nfunction decode_utf8(s) {\n\treturn decodeURIComponent(escape(s));\n};\n\n\n/** Converts a Big Endian ArrayBuffer to BigInt.  \n@param   {ArrayBuffer}         buffer\n@returns {BigInt}         \n */\nfunction ArrayBufferToBigInt(buffer) {\n\tlet result = 0n;\n\tlet a = new Uint8Array(buffer)\n\tfor (let i = 0; i < a.length; i++) {\n\t\tresult = (result << 8n) + BigInt(a[i]);\n\t}\n\treturn result;\n}\n\n/**\nConverts a BigInt to a Big Endian ArrayBuffer.\n@param   {size}         int     Number of bytes to pad the ArrayBuffer\n@param   {Bigint}       bigInt \n@returns {ArrayBuffer}\n */\nfunction BigIntToArrayBuffer(size, bigInt) {\n\tconst buffer = new ArrayBuffer(size);\n\tconst view = new DataView(buffer);\n\n\tdo {\n\t\tsize--;\n\t\tview.setUint8(size, Number(bigInt & 0xffn)) // NOTE: Linter puts a space between oxff and n\n\t\tbigInt >>= 8n;\n\t} while (size > 0);\n\treturn buffer;\n}", "\"use strict\"\nimport * as BASECNV from './base_convert.js'\nimport {\n\tAB\n} from \"./enum.js\"\n\nexport {\n\t// Hex\n\tBaseToHex,\n\tHexPadded,\n\tHexToS,\n\tSToHex,\n\tHexToUb64p,\n\tHexTob64ut,\n\tArrayBufferToHex,\n\tHexToArrayBuffer,\n\n\t// RFC 4648 base64\n\tB64ToHex,\n\tUB64pToS,\n\tB64tToP,\n\tB64utToS,\n\tB64utToArrayBuffer,\n\tArrayBufferTo64ut,\n\tB64ToUint8Array,\n\tURISafeToUnsafe,\n\tURIUnsafeToSafe,\n\tSToB64ut,\n\tSToUB64p,\n}\n\n\n/**\n@typedef {import('./typedef.js').Hex}                   Hex\n@typedef {import('./typedef.js').ub64}                  ub64\n@typedef {import('./typedef.js').b64ut}                 b64ut\n@typedef {import('./typedef.js').ub64}                  ub64\n */\n\n/** BaseToHex converts base to Hex.\n@param  {string} input         Input string.\n@param  {string} inAlph        Input alphabet (i.e. 0123456789ABCDEF)\n@param  {Hex}\n */\nfunction BaseToHex(input, inAlph) {\n\tif (input === null || input === \"\" || input.length === 0) {\n\t\treturn \"\"\n\t}\n\tif (inAlph !== Base16) {\n\t\tinput = BASECNV.BaseConvert(input, inAlph, Base16)\n\t}\n\tif (input.length % 2 === 1) {\n\t\tinput = input.padStart(input.length + 1, \"0\")\n\t}\n\treturn input // Hex is always padded.\n}\n\n\n// String to ASCII (UTF-8) binary HEX string\nfunction SToHex(input) {\n\t// console.debug(input)\n\tif (typeof input != 'string') {\n\t\tthrow new TypeError('Input is not a string. Given type: ' + typeof input)\n\t}\n\treturn input.split(\"\").reduce((hex, c) => hex += c.charCodeAt(0).toString(16).toUpperCase().padStart(2, \"0\"), \"\")\n}\n\n// ASCII (UTF-8) binary HEX string to string\nfunction HexToS(input) {\n\tif (typeof input != 'string') {\n\t\tthrow new TypeError('input is not a string')\n\t}\n\tif (isEmpty(input)) {\n\t\treturn \"\" // empty is a valid input.\n\t}\n\treturn input.match(/.{1,2}/g).reduce((acc, char) => acc + String.fromCharCode(parseInt(char, 16)), \"\")\n}\n\n/**\nHexPadded accepts input, input alphabet, and alg and returns Hex.  Alg is\nused to enforce padding. \n@param    {string} input       String. Number being converted.\n@param    {string} inputBase   String. Input alphabet for input.\n@param    {string} alg         String. Alg for specifying length of pad.\n@returns  {string}             Base16 padded to alg's specified length.\n@throws   {error}              Returns error on unsupported algs.\n */\nfunction HexPadded(input, inputBase, alg) {\n\tlet hex = BASECNV.BaseConvert(input, inputBase, AB.Base16)\n\tswitch (alg) {\n\t\tcase 'ES256':\n\t\t\treturn hex.padStart(64, \"0\")\n\t\tcase \"ES384\":\n\t\t\treturn hex.padStart(96, \"0\")\n\t\tcase \"ES512\":\n\t\t\treturn hex.padStart(128, \"0\")\n\t\tdefault:\n\t\t\tthrow new Error(\"base_convert.HexPadded: unsupported alg\")\n\t}\n}\n\n\n////////////////////////////////////////////////////\n////////////////////////////////////////////////////\n////////////////////////////////////////////////////\n////////////////////////////////////////////////////\n// RFC 4648 \"base64\"s\n////////////////////////////////////////////////////\n////////////////////////////////////////////////////\n////////////////////////////////////////////////////\n////////////////////////////////////////////////////\n\n// There are several base 64's that we use/define.  There are four permutations\n// of the RFC 4648 base64s and one Cyphr.me base 64.  \"base 64\", with a space,\n// refers to any encoding with a 64 character alphabet.  RFC base64 has a\n// different alphabet than Cyphr.me Base64 (enumerated above).\n//\n// RFC base64s use bucket encoding.  Cyphr.me Base64 uses\n// radix/arbitrary/natural encoding method.  We usually say \"arbitrary\" but \"radix\n// conversion\" or \"natural\" is appropriate.\n//\n// Also note, the RFC for URI safe characters says \"URI\" and not \"URL\"\n// (https://datatracker.ietf.org/doc/html/rfc3986#section-2.3), \"Characters that\n// are allowed in a URI (...) are called unreserved.\".  We consider \"URL\" and\n// \"URL safe\" incorrect.\n//\n// \"Truncated\" is the preferred term since implementations add padding and then\n// remove it, so the unneeded padding is \"truncated\".  (See JOSE as an example\n// explicitly removing the added padding)\n//\n//   1. ub64p - RFC 4648 URI unsafe base64 padded.\n//   2. ub64t - RFC 4648 URI unsafe base64 truncated (no padding).  \n//   3. b64up - base64 URI safe padded.\n//   4. b64ut - base64 URI safe truncated.\n//   5. Base64 - Note the upper case \"B\".  Uses the \"divide by radix\" encoding\n//      method and a different alphabet. Cyphr.me defined, not RFC 4648 defined.  \n//\n// Why do we need work with the \"Unsafe base 64 padded\" (ub64p)?\n//\n// JOSE's base64 is b64ut which is right padded, so standard base conversion\n// cannot be used \"out of the box\".  Also, Javascript's `atob` is the most\n// efficient way to work with base64 even though variant may be used by some\n// applications.\n\n\n/**\nHexToUb64p is Hex to RFC ub64p.\n@param   {Hex}   Hex\n@returns {ub64}          ub64 RFC 4648 URI unsafe base 64 padded.\n */\nfunction HexToUb64p(Hex) {\n\t// console.debug(Hex)\n\tif (Hex.length == 0) {\n\t\treturn \"\"\n\t}\n\tlet bytes = Hex.match(/\\w{2}/g).map(function (a) {\n\t\treturn String.fromCharCode(parseInt(a, 16))\n\t}).join(\"\")\n\treturn btoa(bytes)\n}\n\n\n/**\nSToB64ut encodes a string as base64 URI truncated string.\n\"String to base64 uri truncated\"\n@param   {string} string \n@returns {b64ut}\n */\nfunction SToB64ut(string) {\n\treturn btoa(string).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=/g, '')\n}\n\n/**\nB64utToS takes a b64ut string and decodes it back into a string.\n@param   {b64ut} string \n@returns {string}\n */\nfunction B64utToS(string) {\n\t// atob doesn't care about the padding character '='\n\treturn atob(string.replace(/-/g, '+').replace(/_/g, '/'))\n}\n\n\n/**\nSToUB64p takes a string and encodes it into a unsafe Base64 string.\n\"String to Unsafe Base64\"\n@param   {string}  string\n@returns {ub64}    Unsafe Base64 string\n */\nfunction SToUB64p(string) {\n\treturn btoa(string)\n}\n\n/**\nUB64pToS takes an unsafe base64 string and decodes it back into a string.\n\"Unsafe base64 padded to String\"\n@param   {ub64}   string Unsafe base64 padded string\n@returns {string}\n */\nfunction UB64pToS(string) {\n\treturn atob(string)\n}\n\n/**\nURIUnsafeToSafe converts any URI unsafe string to URI safe.\n@param   {string} ub64t \n@returns {string} b64ut \n */\nfunction URIUnsafeToSafe(ub64) {\n\treturn ub64.replace(/\\+/g, '-').replace(/\\//g, '_')\n}\n\n/**\nURISafeToUnsafe converts any URI safe string to URI unsafe.  \n@param   {string} b64ut \n@returns {string} ub64t\n */\nfunction URISafeToUnsafe(ub64) {\n\treturn ub64.replace(/-/g, '+').replace(/_/g, '/')\n}\n\n\n/**\nB64tToP (truncated to padded) takes any base64 truncated string and adds padding\nif appropriate.  \n@param   {string} b64t \n@returns {string} base64p\n */\nfunction B64tToP(b64t) {\n\tvar padding = b64t.length % 4\n\tswitch (padding) {\n\t\tcase 0:\n\t\t\treturn b64t\n\t\tcase 1:\n\t\t\t// malformed input, can only 0, 2, 3, or 4 characters, never 1.  \n\t\t\tconsole.error(\"input is invalid b64t.\")\n\t\t\treturn\n\t\tcase 2:\n\t\t\treturn b64t + \"==\"\n\t\tcase 3:\n\t\t\treturn b64t + \"=\"\n\t}\n}\n\n\n\n\n\n\n// STOLEN:\n\n////////////////////////////////////////////////////\n////////////////////////////////////////////////////\n// RFC 4648 \"base64\"s\n////////////////////////////////////////////////////\n////////////////////////////////////////////////////\n// Encodings have two features:\n// 1. An alphabet.\n// 2. A conversion method.  \n//\n// RFC 4648 \"base64\" is a bucket convert encoding method with a specific alphabet.  \n// \n// There are several base 64's that we use in two classes:\n//   1. Unsafe base64.  We call it `ub64`.\n//   2. URL Safe base64 (base64 url).  We call it `b64u` or `base64url`.\n//   3. base64 url safe truncated.  We call it `b64ut`. Padding character \"=\"\n//      removed.  \n//   4. Unsafe base64 truncated isn't a thing.  Why?  Use b64ut instead.  \n//   5. Base64, with an upper case \"B\", has a different alphabet and uses the\n//      iterative divide by radix conversion method and is not a bucket\n//      conversion method.  (Cyphr.me defined, not RFC 4648 defined.)  NOT IN\n//      THIS file. \n//\n// NOTE: RFC 4648 uses the lower case \"base64\" to refer to it's encoding method.\n// The casing and spacing is important!  The generic \"base 64\" with a space is\n// used to refer to any encoding system that has a 64 character alphabet.  \n\n\n\n/**\nB64ToHex takes any RFC 4648 base64 to Hex.\n@param    {string} b64        Any RFC 4648 base64.\n@returns  {Hex}\n */\nfunction B64ToHex(b64) {\n\tlet ub64 = URISafeToUnsafe(b64)\n\tconst raw = atob(ub64)\n\tlet result = ''\n\tfor (let i = 0; i < raw.length; i++) {\n\t\tconst hex = raw.charCodeAt(i).toString(16).toUpperCase()\n\t\tresult += (hex.length === 2 ? hex : '0' + hex)\n\t}\n\treturn result\n}\n\n\n/**\nHexTob64ut is hHx to \"RFC 4648 base64 URL Safe Truncated\".  \n@param   {Hex}    hex    Hex.\n@returns {b64ut}\n */\nasync function HexTob64ut(hex) {\n\tlet ab = await HexToArrayBuffer(hex)\n\tlet b64ut = await ArrayBufferTo64ut(ab)\n\treturn b64ut\n}\n\n\n/**\nArrayBufferTo64ut Array buffer to b64ut.\n@param   {ArrayBuffer}  buffer \n@returns {b64ut}\n */\nfunction ArrayBufferTo64ut(buffer) {\n\tvar string = String.fromCharCode.apply(null, new Uint8Array(buffer))\n\treturn base64t(URIUnsafeToSafe(btoa(string)))\n}\n\n\n/**\nB64utToArrayBuffer takes a b64 (truncated or not truncated, padded or not\npadded) UTF-8 string and decodes it to an ArrayBuffer.\n@param   {B64} string \n@returns {ArrayBuffer}\n*/\nfunction B64utToArrayBuffer(string) {\n\t// atob doesn't care about the padding character '='\n\treturn B64ToUint8Array(string).buffer\n}\n\n\n/**\nB64ToUint8Array takes a b64 string (truncated or not truncated, padded or not\npadded) and decodes it back into a string.\n@param   {B64}          string \n@returns {Uint8Array}\n*/\nfunction B64ToUint8Array(string) {\n\t// Make sure that the encoding is canonical.  See issue \"Enforce Canonical\n\t// Base64 encoding\" https://github.com/Cyphrme/Coze/issues/18. Alternatively\n\t// to this method, we could write our own encoder as Mozilla suggests.\n\t// https://developer.mozilla.org/en-US/docs/Glossary/Base64#solution_1_%E2%80%93_escaping_the_string_before_encoding_it\n\tstring = string.replace(/-/g, '+').replace(/_/g, '/')\n\n\tlet reencode = btoa(atob(string)).replace(/=/g, '')\n\tif (reencode !== string) {\n\t\tthrow new Error('Non-canonical base64 string')\n\t}\n\n\t// atob doesn't care about the padding character '=', but does not like URI\n\t// encoding.  \n\treturn Uint8Array.from(atob(string), c => c.charCodeAt(0))\n}\n\n\n/**\nHexToArrayBuffer converts string Hex to ArrayBuffer.\n@param   {Hex}           Hex\n@returns {ArrayBuffer}\n */\nasync function HexToArrayBuffer(hex) {\n\tif (hex === undefined) { // undefined is different from 0 since 0 == \"AA\"\n\t\treturn new Uint8Array().buffer\n\t}\n\n\tif ((hex.length % 2) !== 0) {\n\t\tthrow new RangeError('HexToArrayBuffer: Hex is not even.')\n\t}\n\n\tvar a = new Uint8Array(hex.length / 2)\n\tfor (var i = 0; i < hex.length; i += 2) {\n\t\ta[i / 2] = parseInt(hex.substring(i, i + 2), 16)\n\t}\n\n\treturn a.buffer\n}\n\n\n\n/**\nArrayBufferToHex accepts an ArrayBuffer and returns  Hex. Taken from\nhttps://stackoverflow.com/a/50767210/1923095\n@param   {ArrayBuffer} buffer       ArrayBuffer.\n@returns {Hex}\n */\nasync function ArrayBufferToHex(buffer) {\n\treturn [...new Uint8Array(buffer)].map(x => x.toString(16).padStart(2, \"0\")).join('').toUpperCase()\n\n\t// Alternatively:\n\t// let hashArray = Array.from(new Uint8Array(digest)) // convert buffer to byte array\n\t// let hexHash = hashArray.map(b => b.toString(16).padStart(2, '0')).join('')\n}\n\n\n// TODO test this.\n// TODO not in use.\nasync function ArrayBufferToBigInt(buffer) {\n\t// let hex = ArrayBufferToHex()\n\n\tlet result = 0n\n\tfor (let i = 0; i < bytes.length; i++) {\n\t\tresult = (result << 8n) + BigInt(bytes[i])\n\t}\n\treturn result\n}\n\n///////////////////\n// Helpers\n///////////////////\n\n/**\nuriUnsafeToSafe converts any URI unsafe string to URI safe.  \n\nTODO not in use\n@param   {string} ub64t \n@returns {string} b64ut \n */\nfunction uriUnsafeToSafe(ub64) {\n\treturn ub64.replace(/\\+/g, '-').replace(/\\//g, '_')\n}\n\n/**\nbase64t removes base64 padding if applicable.   \n@param   {string} base64 \n@returns {string} base64t\n */\nfunction base64t(base64) {\n\treturn base64.replace(/=/g, '')\n}", "\"use strict\"\n\nexport {\n\tAuthority,\n\tRoot,\n\tNoun,\n\tVerb,\n\tAction,\n\tChild,\n\tEveryPathParse,\n\tEveryPathToString,\n\tStripHTTPS,\n}\n\n\n/**\nEveryPathParse parses an Everything typ or a URI into it's various \nEveryPath components. A typ is considered to be a 'full path', and should\ncontain all components of an EveryPath.\nAn EveryPath does not require every component to be fulfilled, in order to be\nuseful, but rather to be considred a 'full path'.\n\nTODO EveryPathParse should only be used for full path.\n@param   {string}     typ   Everything typ or uri.\n@returns {EveryPath}  ep    Object with various components parsed out.\n */\nfunction EveryPathParse(typ) {\n\tlet ep = {}\n\tep.auth = Authority(typ)\n\tep.root = Root(typ)\n\tep.Noun = Noun(typ)\n\tep.verb = Verb(typ)\n\tep.action = Action(typ)\n\tep.child = Child(typ)\n\treturn ep\n}\n\n\n/**\nStripHTTPS accepts a uri string, and returns an array of path parts, separated\nby `/` with the uri stripped of http:// and https:// (if applicable).\n@param   {string}    uri\n@returns {string[]}\n */\nfunction StripHTTPS(uri) {\n\tlet re = new RegExp('^http:\\/\\/|^https:\\/\\/')\n\treturn uri.replace(re, \"\").split(\"/\")\n}\n\n\n/**\nEveryPathToString takes an EveryPath object, and return a reconstructed\nuri/typ. (e.g. auth/noun/verb)\n@param   {EveryPath}  ep    Parsed EveryPath object. Auth, Noun, and Verb must be present before calling.\n@returns {string}           Reconstructed typ/uri.\n */\nfunction EveryPathToString(ep) {\n\treturn ep.auth + \"/\" + ep.noun + \"/\" + ep.verb\n}\n\n\n/**\nAuthority returns the authority.\n@param   {string}     typ   Everything typ or uri.\n@returns {string}     auth  First component of the typ/uri (aka host).\n */\nfunction Authority(typ) {\n\treturn StripHTTPS(typ)[0]\n}\n\n\n/**\nRoot returns the root.\n@param   {string}     typ   Everything typ or uri.\n@returns {string}     root  Component directly after the authority.\n */\nfunction Root(typ) {\n\treturn StripHTTPS(typ)[1]\n}\n\n\n/**\nNoun returns the noun.\n@param   {string}  typ  Everything typ or uri.\n@returns {string}       Components after the authority and before the verb.\n */\nfunction Noun(typ) {\n\tlet parts = StripHTTPS(typ)\n\tif (parts.length == 2) {\n\t\treturn parts[1]\n\t}\n\tlet noun = \"\"\n\tfor (let i = 1; i < (parts.length - 1); i++) {\n\t\tif (i > 1) {\n\t\t\tnoun += \"/\"\n\t\t}\n\t\tnoun += parts[i]\n\t}\n\treturn noun\n}\n\n\n/**\nVerb returns the verb.\n@param   {string}  typ   Everything typ or uri.\n@returns {string}        Last component.\n */\nfunction Verb(typ) {\n\tlet parts = StripHTTPS(typ)\n\treturn parts[parts.length - 1]\n}\n\n\n/**\nAction returns the action.\n@param   {string}   typ  Everything typ or uri.\n@returns {string}        Component directly after the authority.\n */\nfunction Action(typ) {\n\tlet parts = StripHTTPS(typ)\n\tlet action = \"\"\n\tfor (let i = 1; i < parts.length; i++) {\n\t\tif (i > 1) {\n\t\t\taction += \"/\"\n\t\t}\n\t\taction += parts[i]\n\t}\n\treturn action\n}\n\n\n/**\nChild returns the child.\n@param   {string}  typ   Everything typ or uri.\n@returns {string}        Component that is last unit of the noun.\n */\nfunction Child(typ) {\n\tlet parts = StripHTTPS(typ)\n\treturn parts[parts.length - 2]\n}", "\"use strict\";\n\n// TODO make Tree js its own package.\n\nimport * as Coze from '../pkg/coze_all~fv=-7uCIHNa.min.js'\nimport * as BaseHex64 from './base_hex64.js'\n\nexport {\n\tBundleTypes,\n\n\tIdentity,\n\tPopulateTree,\n\tPopulateBundleIDs,\n\tGenTreeBranch,\n\tIntToBytesBE,\n};\n\n/**\n@typedef {import('../../../pkg/cozejs/typedef.js').Alg} Alg\n@typedef {import('../../../pkg/cozejs/typedef.js').Hsh} Hsh\n@typedef {import('../../../pkg/cozejs/typedef.js').B64} B64\n\n@typedef {number[]}     BLS // brach_level_sizes\n*/\n\n\n/**\n Tree represents a lightning/staircase tree.  The tree has a (secret) trunk\n chain and (public) branches.  The hashing chain is the \"trunk\", the seed plus\n the trunk digest is a branch.  This datastructure may be used recursively, and\n a branch of tree size 0 is a leaf.\n\nalg: The coze.Hsh (Hash alg) for digests. e.g. \"SHA-256\"\n\nseed: \"Private\" seed. Seed is the starting digest for tree. Seed length must be\nsame length as HashSize as digest. Should be same length. e.g.\nRpMM4_lU6jCj3asZEtIFyYqPjC2L6mlucl7VGMvAuno\n\nid: The B64 \"Public\" seed identifier.\n\nskip: Optional starting position.  Populates tree starting at this position.\n\nBranches: The digest values of the branches off the main trunk chain. Branch\nvalue become the seed for the children level. digest(seed||digest(Seed||byte 0))\n= BD1 where \"0\" is the integer value in bytes of the current branch level.\n\npathCalc: If true, Paths, Leaves, and IDPaths are calculated.\n\npaths: (\"Private\") Seed paths. The tree path (all branches above) for all nodes.\nAll leaves in a branch share the same Path. Both keys and values are seeds.\nObject of keys as string, values as B64[] of path, e.g.  \"paths\": {\"77Jo...\":\n[\"0RJw...\"],\n\npathsID: (\"Public\") Paths except with ID's for both keys and values.\n\nleaves: (\"Private\") A slice of leaves in the tree down.  Only calculated if\nLeafPathCalc. Leaves are \"private\" like seed and branch.  Use Identity for\n\"public\" ID.\n\nleavesID: (\"Public\") Like Leaves except uses ID's as the keys and values.\n\nTotalLeaves: Number of leaves currently populated in the whole tree, including\n\"skip\". (Children trees `TreeTotalLeaves` is parent tree's\n`TreeTotalLeaves` as well.) Leaves are the last branch with no children.- \n\nChildren: Recursive tree.  Each digest in \"Branch\" is the key for the tree in\n\"BranchTree\" on a one to one basis.  Note that the \"public\" value for the branch\nis used for the generation of a child tree and not the \"secret\" value from the\ntrunk chain.\n@typedef  {object}    Tree\n@property {Hsh}       alg\n@property {B64}       seed\n@property {B64}       id\n@property {BLS}       branch_level_sizes\n@property {B64[]}     [branches]\n\n@property {number}    [skip]\n\n@property {boolean}   [pathCalc]\n@property {B64MapP}   [paths]\n@property {B64MapP}   [pathsID]\n@property {B64[]}     [leaves]\n@property {B64[]}     [leavesID]\n\n// Stats and internal variables.  Should not be printed.  \n@property {number}    [total_leaves]   // For whole tree, up and down.\n@property {number}    [max_total_leaves] // For whole tree, up and down. // TODO\nnot implemented\n\n@property {Tree[]}    [children]  // Children appear last for readability.\n*/\n\n/**\nB64Map is for mimicking the map `B64MapP` in the GO tree package. B64 IDs are\nused as keys and values are an array of B64 IDs.\n@typedef  {object}  B64MapP\n@property {B64}\n@property {B64[]}\n*/\n\n/**\nIdentity produces the ID from seed.\n@param   {CozeAlg}   alg     Hashing Alg e.g. SHA-256\n@param   {B64}       seed    Starting seed.  Should be same length as  e.g. RpMM4_lU6jCj3asZEtIFyYqPjC2L6mlucl7VGMvAuno\n@returns {B64}       ID\n**/\nasync function Identity(alg, seed) {\n\t// console.log(\"Identity\", alg, seed);\n\tif (typeof seed !== \"string\") {\n\t\tthrow new Error(`Tree.Identity: input seed must be of type string (b64ut); given type: ${typeof seed}`) // TODO consider consistent error formatting.  \n\t}\n\tlet seedB = await BaseHex64.B64utToArrayBuffer(seed)\n\tif (seedB.byteLength !== Coze.HashSize(alg)) {\n\t\tthrow new Error(\"Tree.Identity: seed size does not match alg's hash size; \")\n\t}\n\t//console.debug(\"Alg: \", Coze.HashSize(tree.alg), \"; Seed: \", tree.seedB.byteLength)\n\treturn BaseHex64.ArrayBufferTo64ut(await crypto.subtle.digest(alg, seedB))\n}\n\n/**\nCalcPathsID converts Tree.Paths from \"seed\"/\"private\" form to \"id\"/\"public\" form\nand sets Tree.IDPaths.\n@param   {Tree} tree\n@returns {void}\n@throws  {error}\n */\nasync function CalcPathsID(tree) {\n\tif (!tree.pathCalc) {\n\t\treturn\n\t}\n\ttree.pathsID = {}\n\tfor (let key in tree.paths) {\n\t\tvar pathsID = []\n\t\tfor (let id in tree.paths[key]) {\n\t\t\tpathsID.push(await Identity(tree.alg, tree.paths[key][id])) // throws\n\t\t}\n\t\ttree.pathsID[await Identity(tree.alg, key)] = pathsID // throws\n\t}\n}\n\n\n/**\nPopulateTree recursively populates tree using givens alg, seed, and\nbranch_level_sizes. \nPopulateTree Does not populate current branch so to populate current branch,\nexample a branch_level_sizes of [2], put an implicit 1 in front, [1, 2].\n@param   {Tree} tree\n@returns {void}\n */\nasync function PopulateTree(tree) {\n\ttree.id = await Identity(tree.alg, tree.seed)\n\tif (isEmpty(tree.total_leaves)) {\n\t\ttree.total_leaves = 0\n\t}\n\tif (tree.pathCalc) {\n\t\ttree.leaves = []\n\t\ttree.leavesID = []\n\t}\n\n\tawait GenTreeBranch(tree)\n\tif (!isEmpty(tree.branches) && tree.branch_level_sizes.length > 1) { // Children\n\t\ttree.children = []\n\t\tfor (let i = 0; i < tree.branches.length; i++) {\n\t\t\tlet t = {\n\t\t\t\talg: tree.alg,\n\t\t\t\tseed: tree.branches[i],\n\t\t\t\tbranch_level_sizes: tree.branch_level_sizes.slice(1, tree.branch_level_sizes.length),\n\t\t\t\tmax_total_leaves: tree.max_total_leaves,\n\t\t\t\ttotal_leaves: tree.total_leaves,\n\t\t\t\tpathCalc: tree.pathCalc\n\t\t\t}\n\t\t\tawait PopulateTree(t)\n\t\t\ttree.children[i] = t\n\n\t\t\tif (tree.pathCalc) {\n\t\t\t\ttree.leaves = tree.leaves.concat(t.leaves) // Add leaves from branch to parent's leaves.\n\t\t\t\tfor (let key in t.paths) {\n\t\t\t\t\ttree.paths[key] = [tree.seed].concat(t.paths[key]) // Add parent to each child's path.\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tif (tree.pathCalc) {\n\t\ttree.leavesID = []\n\t\tfor (let leaf of tree.leaves) {\n\t\t\ttree.leavesID.push(await Identity(tree.alg, leaf))\n\t\t}\n\t}\n\n\t// Since Javascript does not have the Go equivalent to json ignore, we simply\n\t// delete \"internal statistic vars\" before returning the tree.  Otherwise, a\n\t// string printing method should be defined on tree. \n\tdelete tree.total_leaves\n\n\tawait CalcPathsID(tree)\n}\n\n\n/**\nGenTreeBranch generates a slice of digests from a seed digest.\nResulting digests are not cryptographically related.\n\nSkip is the starting position for the main trunk (should typically be 0).\n// TODO skip needs to be tested/match Go implementation.\n\nS\u2500(S)\u2500\u25BA ID\n\u2502\n\u251C\u2500(S+0)\u2500\u2500\u25BA D1\n\u2502\n\u251C\u2500(S+1)\u2500\u2500\u25BA D2\n\u2502\n\u251C\u2500(S+2)\u2500\u2500\u25BA D3\n...\n\n@param   {Tree}  tree\n@returns {void}\n */\nasync function GenTreeBranch(tree) {\n\tlet seedB = await BaseHex64.B64utToArrayBuffer(tree.seed)\n\tif (seedB.byteLength !== Coze.HashSize(tree.alg)) {\n\t\tthrow new Error(`Tree.GenTreeBranch: seed length does not match hash alg length; seed length ${seedB.byteLength}; hash length ${Coze.HashSize(tree.alg)}`)\n\t}\n\n\tlet skip = isEmpty(tree.skip) ? 0 : tree.skip\n\n\tif (tree.pathCalc) {\n\t\ttree.paths = {}\n\t}\n\n\tfor (let i = 0; i < tree.branch_level_sizes[0] - skip; i++) {\n\t\tif (isEmpty(tree.branches)) {\n\t\t\ttree.branches = []\n\t\t}\n\t\tif (tree.total_leaves == tree.max_total_leaves) {\n\t\t\treturn\n\t\t}\n\n\t\t// Calculate nonce bytes and merge seed and nonce array buffers.\n\t\tlet nonce = IntToBytesBE(i + skip)\n\t\tlet s = new Uint8Array(seedB.byteLength + nonce.byteLength)\n\t\ts.set(new Uint8Array(seedB), 0)\n\t\ts.set(new Uint8Array(nonce), seedB.byteLength)\n\t\ttree.branches[i] = await BaseHex64.ArrayBufferTo64ut(await crypto.subtle.digest(tree.alg, s.buffer))\n\n\t\tif (tree.branch_level_sizes.length == 1) { // Leaves\n\t\t\t// console.log(\"Edge of tree\");\n\t\t\ttree.total_leaves++\n\t\t\tif (tree.pathCalc) {\n\t\t\t\ttree.leaves = tree.leaves.concat(tree.branches[i])\n\t\t\t}\n\t\t}\n\t\tif (tree.pathCalc) {\n\t\t\ttree.paths[tree.branches[i]] = [tree.seed]\n\t\t}\n\t}\n\treturn\n}\n\n\n/**\nIntToBytesBE converts an integer to bytes does not include empty padding bytes\nand always returns at least one byte. (Empty padding bytes on left, e.g. decimal\n65,536 is bytes [1 0 0].) As currently written, it only supports numbers up to\n2^32 (4294967295) which is the max value for uint32. We did not investigate why\nJavascript has a 4 byte limit on integers. See the Go cyphrme/tree\nimplementation.\n@param   {number}  int\n@returns {void}\n */\nfunction IntToBytesBE(int) {\n\tif (int > 4294967295) {\n\t\tthrow new Error(`Tree.IntToBytesBE: cannot convert number larger than 4294967295`)\n\t}\n\tlet byteLength = Math.ceil(Math.log2(int + 1) / 8);\n\tbyteLength = Math.max(byteLength, 1); // Ensure minimum byte length of 1\n\n\tconst byteArray = new Uint8Array(byteLength);\n\tfor (let i = byteLength - 1; i >= 0; i--) {\n\t\tbyteArray[i] = int & 0xFF;\n\t\tint >>= 8;\n\t}\n\n\treturn byteArray;\n\n\n\t// Two alternative, non-working implementation (still appears to have the 2^32\n\t// limitation, and they return padding bytes which would need to be removed. \n\t// //function IntToBytesBE(number) {\n\t// // \tconst byteArray = new Uint8Array(8); // Assuming a 64-bit integer\n\t// // \t\t//0,8,16,24,32,40,48,56  \n\t// // \tbyteArray[0] = (number >> 56) & 0xFF;\n\t// // \tbyteArray[1] = (number >> 48) & 0xFF;\n\t// // \tbyteArray[2] = (number >> 40) & 0xFF;\n\t// // \tbyteArray[3] = (number >> 32) & 0xFF;\n\t// // \tbyteArray[4] = (number >> 24) & 0xFF;\n\t// // \tbyteArray[5] = (number >> 16) & 0xFF;\n\t// // \tbyteArray[6] = (number >> 8) & 0xFF;\n\t// // \tbyteArray[7] = number & 0xFF;\n\t// // \treturn byteArray;\n\t// // }\n\n\t// \t// function IntToBytesBE2(number) {\n\t// //   const byteArray = new Uint8Array(4); // Assuming a 64-bit integer\n\t// //   byteArray[0] = (number >> 24) & 0xFF;\n\t// //   byteArray[1] = (number >> 16) & 0xFF;\n\t// //   byteArray[2] = (number >> 8) & 0xFF;\n\t// //   byteArray[3] = number & 0xFF;\n\t// //   return byteArray;\n\t// // }\n\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Internal to Cyphrme and outside of Tree package\n////////////////////////////////////////////////////////////////////////////////\n\nconst BundleTypes = [\"item\", \"page\", \"batch\", \"box\", \"pallet\", \"rack\", \"warehouse\"]\n\n/**\nPopulateBundleIDs populates BundlePaths on the given ACs from IDPaths on Tree.\n@param   {Tree}  tree\n@returns {void}\n */\nfunction PopulateBundleIDs(tree, acs) {\n\tfor (let i in acs) {\n\t\tif (!(acs[i].pay.id in tree.pathsID)) {\n\t\t\tthrow new Error(\"id not in map\")\n\t\t}\n\t\tlet paths = tree.pathsID[acs[i].pay.id]\n\t\tlet bp = {}\n\t\tfor (let i in paths) {\n\t\t\tif (i == 0) {\n\t\t\t\tbp.tree = paths[i]\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tswitch (BundleTypes[paths.length - i]) {\n\t\t\t\tdefault:\n\t\t\t\t\tthrow new Error(\"bundle type not defined\")\n\t\t\t\tcase \"page\":\n\t\t\t\t\tbp.page = paths[i]\n\t\t\t\t\tbreak\n\t\t\t\tcase \"batch\":\n\t\t\t\t\tbp.batch = paths[i]\n\t\t\t\t\tbreak\n\t\t\t\tcase \"box\":\n\t\t\t\t\tbp.box = paths[i]\n\t\t\t\t\tbreak\n\t\t\t\tcase \"pallet\":\n\t\t\t\t\tbp.pallet = paths[i]\n\t\t\t\t\tbreak\n\t\t\t\tcase \"rack\":\n\t\t\t\t\tbp.rack = paths[i]\n\t\t\t\t\tbreak\n\t\t\t\tcase \"warehouse\":\n\t\t\t\t\tbp.warehouse = paths[i]\n\t\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\tacs[i].bundle_paths = bp\n\t}\n}"],
  "mappings": "AAEA,UAAYA,MAAU,qCCAtB,UAAYC,MAAU,qCAwBtB,eAAeC,GAAOC,EAAIC,EAAK,CAC9B,OAAI,QAAQA,CAAG,IACdA,EAAM,WAEK,oBAAkB,MAAM,OAAO,OAAO,OAAY,UAAQA,CAAG,EAAGD,CAAE,CAAC,CAChF,CASA,eAAeE,GAASC,EAAMF,EAAK,CAC9B,QAAQA,CAAG,IACdA,EAAM,WAEPA,EAAW,UAAQA,CAAG,EACtB,IAAIG,EAAS,MAAMD,EAAK,YAAY,EAChCH,EAAK,MAAM,OAAO,OAAO,OAAOC,EAAKG,CAAM,EAC/C,OAAO,MAAW,oBAAkBJ,CAAE,CACvC,CAUA,eAAeK,GAAiBF,EAAMG,EAAU,CAC3C,QAAQ,GAAG,IACd,IAAM,WAEP,IAAW,UAAQ,GAAG,EAEtB,IAAIC,EAAS,IAAI,WACjBA,EAAO,kBAAkBJ,CAAI,EAC7BI,EAAO,UAAY,gBAAkB,CACpC,IAAIP,EAAK,MAAM,OAAO,OAAO,OAAO,UAAWO,EAAO,MAAM,EACxDC,EAAS,MAAW,oBAAkBR,CAAE,EAC5C,OAAK,QAAQM,CAAQ,EAGdE,EAFCF,EAASE,CAAM,CAGxB,CACD,CAOA,eAAeC,GAAUC,EAAK,CACzB,QAAQA,CAAG,IACdA,EAAM,IAEP,IAAIC,EAAc,IAAI,WAAWD,CAAG,EACpC,cAAO,OAAO,gBAAgBC,CAAW,EAC7B,oBAAkBA,CAAW,CAC1C,CAOA,eAAeC,EAAYX,EAAK,CAC3B,QAAQA,CAAG,IACdA,EAAM,WAEP,IAAIU,EAAc,IAAI,WAAgB,WAASV,CAAG,CAAC,EACnD,cAAO,OAAO,gBAAgBU,CAAW,EAC7B,oBAAkB,MAAM,OAAO,OAAO,OAAY,UAAQV,CAAG,EAAG,MAAM,OAAO,OAAO,OAAY,UAAQA,CAAG,EAAGU,CAAW,CAAC,CAAC,CACxI,CD5EA,IAAME,EAAuB,CAAC,MAAO,MAAO,MAAO,MAAO,IAAI,EA2B9D,eAAeC,GAAmBC,EAASC,EAAI,CAE1C,QAAQA,CAAE,IACbA,EAAK,CAAC,GAIP,IAAIC,EAAM,CACT,GAAGD,CACJ,EACA,OAAAC,EAAI,IAAMF,EAAQ,IAClBE,EAAI,IAAM,IAAI,EACdA,EAAI,IAAMF,EAAQ,IAClBE,EAAI,IAAM,qBACJ,OAAQA,IACbA,EAAI,GAAK,MAAaC,EAAYH,EAAQ,GAAG,GAIvC,MAAW,OAAK,CACtB,IAAOE,CACR,EAAGF,EAASF,CAAoB,CACjC,CA4BA,SAASM,GAAeC,EAAKC,EAAa,CACzC,QAASC,KAAOD,EACfD,EAAIE,GAAOD,EAAYC,EAEzB,CE9FA,IAAMC,EAAS,aACTC,EAAS,mBACTC,EAAc,mBAMdC,EAAkB,mEAElBC,EAAe,mEAGfC,EAAsB,OAAO,aAElC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAC1E,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAExC,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IACtE,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IACtE,IAAK,IAAK,IAAK,IAAK,GACrB,EAkBA,IAAMC,EAAS,wCAGTC,EAAS,yCAGTC,EAAS,gDAGTC,EAAS,mEAITC,EAAsB,qEAItBC,EAAU,udAIZC,EAAK,CACR,oBAAqBC,EACrB,OAAQC,EACR,OAAQC,EACR,YAAaC,EACb,OAAQV,EACR,OAAQC,EACR,OAAQC,EACR,OAAQC,EACR,oBAAqBC,EACrB,QAASC,EACT,gBAAiBM,EACjB,aAAcC,CACf,ECjEA,SAASC,GAAaC,EAAOC,EAAWC,EAAK,CAE5C,IAAIC,EAAMC,EAAYJ,EAAOC,EAAWI,EAAG,MAAM,EACjD,OAAQH,EAAK,CACZ,IAAK,QACL,IAAK,UACJ,OAAOC,EAAI,SAAS,GAAI,GAAG,EAC5B,IAAK,QACL,IAAK,UACJ,OAAOA,EAAI,SAAS,GAAI,GAAG,EAC5B,IAAK,QACL,IAAK,UACJ,OAAOA,EAAI,SAAS,GAAI,GAAG,EAC5B,QACC,MAAM,IAAI,MAAM,4CAA4C,CAC9D,CACD,CAaA,IAAIG,EAAc,GAUlB,SAASF,EAAYJ,EAAOO,EAAQC,EAAS,CAE5C,GAAIR,IAAU,MAAQA,GAAS,IAAMO,GAAU,IAAMC,GAAW,GAC/D,OAAO,KAGR,IAAMC,EAAWF,EAAO,OAClBG,EAASF,EAAQ,OACjBG,EAAcJ,EAAO,MAAM,EAAE,EAEnC,GAAIG,GAAU,EAAG,OAEjB,IAAME,EAAM,CAACC,EAAGC,EAAGC,IAAS,CAC3B,IAAIC,EAAI,CAAC,EACHC,EAAI,KAAK,IAAIJ,EAAE,OAAQC,EAAE,MAAM,EACjCI,EAAQ,EACRC,EAAI,EACR,KAAOA,EAAIF,GAAKC,GAAO,CACtB,IAAME,EAAKD,EAAIN,EAAE,OAASA,EAAEM,GAAK,EAC3BE,EAAKF,EAAIL,EAAE,OAASA,EAAEK,GAAK,EAC3BG,EAAKJ,EAAQE,EAAKC,EACxBL,EAAE,KAAKM,EAAKP,CAAI,EAChBG,EAAQ,KAAK,MAAMI,EAAKP,CAAI,EAC5BI,GACD,CACA,OAAOH,CACR,EAEMO,EAAmB,CAACC,EAAKC,EAAOV,IAAS,CAC9C,GAAIS,EAAM,EAAG,OAAO,KACpB,GAAIA,IAAQ,EAAG,MAAO,CAAC,CAAC,EAExB,IAAIE,EAAS,CAAC,EACd,KACCF,EAAM,IAAME,EAASd,EAAIc,EAAQD,EAAOV,CAAI,GAC5CS,EAAMA,GAAO,EACTA,IAAQ,GACZC,EAAQb,EAAIa,EAAOA,EAAOV,CAAI,EAG/B,OAAOW,CACR,EAuBMC,GAnBe3B,GAAU,CAE9B,IAAM2B,EAAS3B,EAAM,MAAM,EAAE,EACzB4B,EAAM,CAAC,EACX,QAAST,EAAIQ,EAAO,OAAS,EAAGR,GAAK,EAAGA,IAAK,CAE5C,GAAI,CAAER,EAAY,SAASgB,EAAOR,EAAE,EACnC,MAAM,IAAI,MAAM,8BAAgCQ,EAAOR,EAAE,EAE1D,IAAMF,EAAIV,EAAO,QAAQoB,EAAOR,EAAE,EAE9BF,GAAK,IAGTW,EAAI,KAAKX,CAAC,CACX,CACA,OAAOW,CACR,GAE2B5B,CAAK,EAChC,GAAI2B,IAAW,KAAM,OAAO,KAE5B,IAAIE,EAAW,CAAC,EACZJ,EAAQ,CAAC,CAAC,EACd,QAASN,EAAI,EAAGA,EAAIQ,EAAO,OAAQR,IAClCU,EAAWjB,EAAIiB,EAAUN,EAAiBI,EAAOR,GAAIM,EAAOf,CAAM,EAAGA,CAAM,EAC3Ee,EAAQF,EAAiBd,EAAUgB,EAAOf,CAAM,EAIjD,IAAIoB,EAAM,GAEV,GAAIxB,EAAa,CAChB,IAAIyB,EAAQxB,EAAO,OAAO,CAAC,EACvByB,EAASxB,EAAQ,OAAO,CAAC,EACzBW,EAAI,EACR,KAAOA,EAAInB,EAAM,QACZA,EAAM,OAAOmB,CAAC,IAAMY,GACxBD,GAAOE,EACPb,GAEF,CAEA,QAASA,EAAIU,EAAS,OAAS,EAAGV,GAAK,EAAGA,IACzCW,GAAOtB,EAAQqB,EAASV,IAGzB,OAAOW,CACR,CC5HA,IAAIG,EAAsBC,EAAG,oBAQ7B,SAASC,GAAcC,EAAIC,EAAI,CAC9B,IAAIC,EAAM,IAAI,WAAWF,EAAG,WAAaC,EAAG,UAAU,EACtD,OAAAC,EAAI,IAAI,IAAI,WAAWF,CAAE,EAAG,CAAC,EAC7BE,EAAI,IAAI,IAAI,WAAWD,CAAE,EAAGD,EAAG,UAAU,EAClCE,EAAI,MACZ,CAOA,eAAeC,GAAeC,EAAQ,CACrC,IAAIC,EAAM,IAAI,YAEd,OADiBA,EAAI,OAAOD,CAAM,EAChB,MACnB,CAoBA,SAASE,EAAaC,EAAO,CAC5B,GAAIA,EAAM,OAAO,CAAC,GAAK,KAAOA,EAAM,OAAO,CAAC,GAAK,IAChD,MAAM,IAAI,YAAY,wCAAwC,EAG/D,OAAIA,EAAM,OAAOA,EAAM,OAAS,CAAC,GAAK,IAC9BA,EAAM,UAAU,EAAGA,EAAM,OAAS,CAAC,EAAE,MAAM,GAAG,EAE/CA,EAAM,UAAU,EAAGA,EAAM,OAAS,CAAC,EAAE,MAAM,GAAG,CACtD,CAQA,SAASC,GAAgBD,EAAO,CAC/B,IAAIE,EAAU,GACd,QAASC,KAAKJ,EAAaC,CAAK,EAC/BE,GAAW,OAAO,cAAcC,CAAC,EAElC,OAAOD,CACR,CASA,SAASE,GAAaJ,EAAO,CAC5B,IAAIK,EAAM,GACNC,EAASP,EAAaC,CAAK,EAE/B,GAAIM,EAAO,QAAU,GAAK,QAAQA,EAAO,EAAE,EAC1C,OAAOD,EAER,QAASF,KAAKG,EACbD,GAAO,SAASF,CAAC,EAAE,SAAS,EAAE,EAAE,YAAY,EAAE,SAAS,EAAG,GAAG,EAE9D,OAAOE,CACR,CAGA,SAASE,GAAYC,EAAW,CAC/B,IAAIC,EAAUD,EAAU,MAAM;AAAA,EAAM,CAAC,EAAE,GACvC,GAAIC,EAAQ,UAAU,EAAG,CAAC,GAAK,OAC9B,MAAM,IAAI,YAAY,mCAAmC,EAE1D,OAAOA,EAAQ,MAAM,IAAK,CAAC,EAAE,EAC9B,CAOA,SAASC,GAAmBL,EAAK,CAChC,QAASM,EAAQ,CAAC,EAAGC,EAAI,EAAGA,EAAIP,EAAI,OAAQO,GAAK,EAChDD,EAAM,KAAK,SAASN,EAAI,OAAOO,EAAG,CAAC,EAAG,EAAE,CAAC,EAC1C,MAAO,IAAMD,EAAQ,GACtB,CAQA,SAASE,GAAWC,EAAM,CAIzB,QAHIC,EAAO,EACPC,EAAQ,EAELF,EAAOE,GACbA,EAAQA,EAAQ,EAChBD,IAED,OAAOA,CACR,CAMA,SAASE,GAAmBpB,EAAQ,CACnC,IAAIqB,EAAY,GAChB,QAASC,KAAQtB,EAAQ,CACxB,GAAIP,EAAoB,SAAS6B,CAAI,EAAG,CACvCD,GAAa,IACb,QACD,CACAA,GAAaC,CACd,CACA,OAAOD,CACR,CAIA,SAASE,GAAUpB,EAAOqB,EAAQ,CAEjC,GAAIrB,EAAM,QAAU,EACnB,OAAOA,EAGR,IAAIsB,EAAQD,EAAO,OAAO,CAAC,EAC3B,QAAST,EAAI,EAAGA,EAAIZ,EAAM,QACrBA,EAAM,OAAOY,CAAC,IAAMU,EADSV,IACjC,CAID,OAAOZ,EAAM,UAAUY,CAAC,CACzB,CAQA,eAAeW,GAAeC,EAAI,CACjC,IAAI1B,EAAM,IAAI,YAAY,OAAO,EACjC,OAAOA,EAAI,OAAO0B,CAAE,CACrB,CAQA,SAASC,GAAYC,EAAK,CAEzB,QADIC,EAAO,CAAC,EACHf,EAAI,EAAGA,EAAIc,EAAI,OAAQd,IAAK,CACpC,IAAIgB,EAAWF,EAAI,WAAWd,CAAC,EAC3BgB,EAAW,IAAMD,EAAK,KAAKC,CAAQ,EAC9BA,EAAW,KACnBD,EAAK,KAAK,IAAQC,GAAY,EAC7B,IAAQA,EAAW,EAAK,EACfA,EAAW,OAAUA,GAAY,MAC3CD,EAAK,KAAK,IAAQC,GAAY,GAC7B,IAASA,GAAY,EAAK,GAC1B,IAAQA,EAAW,EAAK,GAIzBhB,IAIAgB,EAAW,QAAaA,EAAW,OAAU,GAC3CF,EAAI,WAAWd,CAAC,EAAI,MACtBe,EAAK,KAAK,IAAQC,GAAY,GAC7B,IAASA,GAAY,GAAM,GAC3B,IAASA,GAAY,EAAK,GAC1B,IAAQA,EAAW,EAAK,EAE3B,CACA,OAAOD,CACR,CAiBA,SAASE,GAAoBC,EAAQ,CACpC,IAAIC,EAAS,GACTC,EAAI,IAAI,WAAWF,CAAM,EAC7B,QAASG,EAAI,EAAGA,EAAID,EAAE,OAAQC,IAC7BF,GAAUA,GAAU,IAAM,OAAOC,EAAEC,EAAE,EAEtC,OAAOF,CACR,CAQA,SAASG,GAAoBC,EAAMC,EAAQ,CAC1C,IAAMN,EAAS,IAAI,YAAYK,CAAI,EAC7BE,EAAO,IAAI,SAASP,CAAM,EAEhC,GACCK,IACAE,EAAK,SAASF,EAAM,OAAOC,EAAS,KAAK,CAAC,EAC1CA,IAAW,SACHD,EAAO,GAChB,OAAOL,CACR,CCvOA,SAASQ,GAAUC,EAAOC,EAAQ,CACjC,OAAID,IAAU,MAAQA,IAAU,IAAMA,EAAM,SAAW,EAC/C,IAEJC,IAAW,SACdD,EAAgBE,EAAYF,EAAOC,EAAQ,MAAM,GAE9CD,EAAM,OAAS,IAAM,IACxBA,EAAQA,EAAM,SAASA,EAAM,OAAS,EAAG,GAAG,GAEtCA,EACR,CAIA,SAASG,GAAOH,EAAO,CAEtB,GAAI,OAAOA,GAAS,SACnB,MAAM,IAAI,UAAU,sCAAwC,OAAOA,CAAK,EAEzE,OAAOA,EAAM,MAAM,EAAE,EAAE,OAAO,CAACI,EAAKC,IAAMD,GAAOC,EAAE,WAAW,CAAC,EAAE,SAAS,EAAE,EAAE,YAAY,EAAE,SAAS,EAAG,GAAG,EAAG,EAAE,CACjH,CAGA,SAASC,GAAON,EAAO,CACtB,GAAI,OAAOA,GAAS,SACnB,MAAM,IAAI,UAAU,uBAAuB,EAE5C,OAAI,QAAQA,CAAK,EACT,GAEDA,EAAM,MAAM,SAAS,EAAE,OAAO,CAACO,EAAKC,IAASD,EAAM,OAAO,aAAa,SAASC,EAAM,EAAE,CAAC,EAAG,EAAE,CACtG,CAWA,SAASC,GAAUT,EAAOU,EAAWC,EAAK,CACzC,IAAIP,EAAcF,EAAYF,EAAOU,EAAWE,EAAG,MAAM,EACzD,OAAQD,EAAK,CACZ,IAAK,QACJ,OAAOP,EAAI,SAAS,GAAI,GAAG,EAC5B,IAAK,QACJ,OAAOA,EAAI,SAAS,GAAI,GAAG,EAC5B,IAAK,QACJ,OAAOA,EAAI,SAAS,IAAK,GAAG,EAC7B,QACC,MAAM,IAAI,MAAM,yCAAyC,CAC3D,CACD,CAmDA,SAASS,GAAWC,EAAK,CAExB,GAAIA,EAAI,QAAU,EACjB,MAAO,GAER,IAAIC,EAAQD,EAAI,MAAM,QAAQ,EAAE,IAAI,SAAUE,EAAG,CAChD,OAAO,OAAO,aAAa,SAASA,EAAG,EAAE,CAAC,CAC3C,CAAC,EAAE,KAAK,EAAE,EACV,OAAO,KAAKD,CAAK,CAClB,CASA,SAASE,GAASC,EAAQ,CACzB,OAAO,KAAKA,CAAM,EAAE,QAAQ,MAAO,GAAG,EAAE,QAAQ,MAAO,GAAG,EAAE,QAAQ,KAAM,EAAE,CAC7E,CAOA,SAASC,GAASD,EAAQ,CAEzB,OAAO,KAAKA,EAAO,QAAQ,KAAM,GAAG,EAAE,QAAQ,KAAM,GAAG,CAAC,CACzD,CASA,SAASE,GAASF,EAAQ,CACzB,OAAO,KAAKA,CAAM,CACnB,CAQA,SAASG,GAASH,EAAQ,CACzB,OAAO,KAAKA,CAAM,CACnB,CAOA,SAASI,EAAgBC,EAAM,CAC9B,OAAOA,EAAK,QAAQ,MAAO,GAAG,EAAE,QAAQ,MAAO,GAAG,CACnD,CAOA,SAASC,EAAgBD,EAAM,CAC9B,OAAOA,EAAK,QAAQ,KAAM,GAAG,EAAE,QAAQ,KAAM,GAAG,CACjD,CASA,SAASE,GAAQC,EAAM,CACtB,IAAIC,EAAUD,EAAK,OAAS,EAC5B,OAAQC,EAAS,CAChB,IAAK,GACJ,OAAOD,EACR,IAAK,GAEJ,QAAQ,MAAM,wBAAwB,EACtC,OACD,IAAK,GACJ,OAAOA,EAAO,KACf,IAAK,GACJ,OAAOA,EAAO,GAChB,CACD,CA0CA,SAASE,GAASC,EAAK,CACtB,IAAIN,EAAOC,EAAgBK,CAAG,EACxBC,EAAM,KAAKP,CAAI,EACjBQ,EAAS,GACb,QAASC,EAAI,EAAGA,EAAIF,EAAI,OAAQE,IAAK,CACpC,IAAM5B,EAAM0B,EAAI,WAAWE,CAAC,EAAE,SAAS,EAAE,EAAE,YAAY,EACvDD,GAAW3B,EAAI,SAAW,EAAIA,EAAM,IAAMA,CAC3C,CACA,OAAO2B,CACR,CAQA,eAAeE,GAAW7B,EAAK,CAC9B,IAAI8B,EAAK,MAAMC,EAAiB/B,CAAG,EAEnC,OADY,MAAMgC,EAAkBF,CAAE,CAEvC,CAQA,SAASE,EAAkBC,EAAQ,CAClC,IAAInB,EAAS,OAAO,aAAa,MAAM,KAAM,IAAI,WAAWmB,CAAM,CAAC,EACnE,OAAOC,GAAQhB,EAAgB,KAAKJ,CAAM,CAAC,CAAC,CAC7C,CASA,SAASqB,EAAmBrB,EAAQ,CAEnC,OAAOsB,EAAgBtB,CAAM,EAAE,MAChC,CASA,SAASsB,EAAgBtB,EAAQ,CAQhC,GAHAA,EAASA,EAAO,QAAQ,KAAM,GAAG,EAAE,QAAQ,KAAM,GAAG,EAErC,KAAK,KAAKA,CAAM,CAAC,EAAE,QAAQ,KAAM,EAAE,IACjCA,EAChB,MAAM,IAAI,MAAM,6BAA6B,EAK9C,OAAO,WAAW,KAAK,KAAKA,CAAM,EAAGb,GAAKA,EAAE,WAAW,CAAC,CAAC,CAC1D,CAQA,eAAe8B,EAAiB/B,EAAK,CACpC,GAAIA,IAAQ,OACX,OAAO,IAAI,WAAW,EAAE,OAGzB,GAAKA,EAAI,OAAS,IAAO,EACxB,MAAM,IAAI,WAAW,oCAAoC,EAI1D,QADIY,EAAI,IAAI,WAAWZ,EAAI,OAAS,CAAC,EAC5B4B,EAAI,EAAGA,EAAI5B,EAAI,OAAQ4B,GAAK,EACpChB,EAAEgB,EAAI,GAAK,SAAS5B,EAAI,UAAU4B,EAAGA,EAAI,CAAC,EAAG,EAAE,EAGhD,OAAOhB,EAAE,MACV,CAUA,eAAeyB,GAAiBJ,EAAQ,CACvC,MAAO,CAAC,GAAG,IAAI,WAAWA,CAAM,CAAC,EAAE,IAAIK,GAAKA,EAAE,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,YAAY,CAKnG,CAmCA,SAASC,GAAQC,EAAQ,CACxB,OAAOA,EAAO,QAAQ,KAAM,EAAE,CAC/B,CClZA,SAASC,GAAeC,EAAK,CAC5B,IAAIC,EAAK,CAAC,EACV,OAAAA,EAAG,KAAOC,GAAUF,CAAG,EACvBC,EAAG,KAAOE,GAAKH,CAAG,EAClBC,EAAG,KAAOG,GAAKJ,CAAG,EAClBC,EAAG,KAAOI,GAAKL,CAAG,EAClBC,EAAG,OAASK,GAAON,CAAG,EACtBC,EAAG,MAAQM,GAAMP,CAAG,EACbC,CACR,CASA,SAASO,EAAWC,EAAK,CACxB,IAAIC,EAAK,IAAI,OAAO,oBAAwB,EAC5C,OAAOD,EAAI,QAAQC,EAAI,EAAE,EAAE,MAAM,GAAG,CACrC,CASA,SAASC,GAAkBV,EAAI,CAC9B,OAAOA,EAAG,KAAO,IAAMA,EAAG,KAAO,IAAMA,EAAG,IAC3C,CAQA,SAASC,GAAUF,EAAK,CACvB,OAAOQ,EAAWR,CAAG,EAAE,EACxB,CAQA,SAASG,GAAKH,EAAK,CAClB,OAAOQ,EAAWR,CAAG,EAAE,EACxB,CAQA,SAASI,GAAKJ,EAAK,CAClB,IAAIY,EAAQJ,EAAWR,CAAG,EAC1B,GAAIY,EAAM,QAAU,EACnB,OAAOA,EAAM,GAEd,IAAIC,EAAO,GACX,QAASC,EAAI,EAAGA,EAAKF,EAAM,OAAS,EAAIE,IACnCA,EAAI,IACPD,GAAQ,KAETA,GAAQD,EAAME,GAEf,OAAOD,CACR,CAQA,SAASR,GAAKL,EAAK,CAClB,IAAIY,EAAQJ,EAAWR,CAAG,EAC1B,OAAOY,EAAMA,EAAM,OAAS,EAC7B,CAQA,SAASN,GAAON,EAAK,CACpB,IAAIY,EAAQJ,EAAWR,CAAG,EACtBe,EAAS,GACb,QAASD,EAAI,EAAGA,EAAIF,EAAM,OAAQE,IAC7BA,EAAI,IACPC,GAAU,KAEXA,GAAUH,EAAME,GAEjB,OAAOC,CACR,CAQA,SAASR,GAAMP,EAAK,CACnB,IAAIY,EAAQJ,EAAWR,CAAG,EAC1B,OAAOY,EAAMA,EAAM,OAAS,EAC7B,CCvIA,UAAYI,MAAU,qCAsGtB,eAAeC,EAASC,EAAKC,EAAM,CAElC,GAAI,OAAOA,GAAS,SACnB,MAAM,IAAI,MAAM,yEAAyE,OAAOA,GAAM,EAEvG,IAAIC,EAAQ,MAAgBC,EAAmBF,CAAI,EACnD,GAAIC,EAAM,aAAoB,WAASF,CAAG,EACzC,MAAM,IAAI,MAAM,2DAA2D,EAG5E,OAAiBI,EAAkB,MAAM,OAAO,OAAO,OAAOJ,EAAKE,CAAK,CAAC,CAC1E,CASA,eAAeG,GAAYC,EAAM,CAChC,GAAI,EAACA,EAAK,SAGV,CAAAA,EAAK,QAAU,CAAC,EAChB,QAASC,KAAOD,EAAK,MAAO,CAC3B,IAAIE,EAAU,CAAC,EACf,QAASC,KAAMH,EAAK,MAAMC,GACzBC,EAAQ,KAAK,MAAMT,EAASO,EAAK,IAAKA,EAAK,MAAMC,GAAKE,EAAG,CAAC,EAE3DH,EAAK,QAAQ,MAAMP,EAASO,EAAK,IAAKC,CAAG,GAAKC,CAC/C,EACD,CAWA,eAAeE,GAAaJ,EAAM,CAWjC,GAVAA,EAAK,GAAK,MAAMP,EAASO,EAAK,IAAKA,EAAK,IAAI,EACxC,QAAQA,EAAK,YAAY,IAC5BA,EAAK,aAAe,GAEjBA,EAAK,WACRA,EAAK,OAAS,CAAC,EACfA,EAAK,SAAW,CAAC,GAGlB,MAAMK,GAAcL,CAAI,EACpB,CAAC,QAAQA,EAAK,QAAQ,GAAKA,EAAK,mBAAmB,OAAS,EAAG,CAClEA,EAAK,SAAW,CAAC,EACjB,QAASM,EAAI,EAAGA,EAAIN,EAAK,SAAS,OAAQM,IAAK,CAC9C,IAAIC,EAAI,CACP,IAAKP,EAAK,IACV,KAAMA,EAAK,SAASM,GACpB,mBAAoBN,EAAK,mBAAmB,MAAM,EAAGA,EAAK,mBAAmB,MAAM,EACnF,iBAAkBA,EAAK,iBACvB,aAAcA,EAAK,aACnB,SAAUA,EAAK,QAChB,EAIA,GAHA,MAAMI,GAAaG,CAAC,EACpBP,EAAK,SAASM,GAAKC,EAEfP,EAAK,SAAU,CAClBA,EAAK,OAASA,EAAK,OAAO,OAAOO,EAAE,MAAM,EACzC,QAASN,KAAOM,EAAE,MACjBP,EAAK,MAAMC,GAAO,CAACD,EAAK,IAAI,EAAE,OAAOO,EAAE,MAAMN,EAAI,CAEnD,CACD,CACD,CAEA,GAAID,EAAK,SAAU,CAClBA,EAAK,SAAW,CAAC,EACjB,QAASQ,KAAQR,EAAK,OACrBA,EAAK,SAAS,KAAK,MAAMP,EAASO,EAAK,IAAKQ,CAAI,CAAC,CAEnD,CAKA,OAAOR,EAAK,aAEZ,MAAMD,GAAYC,CAAI,CACvB,CAsBA,eAAeK,GAAcL,EAAM,CAClC,IAAIJ,EAAQ,MAAgBC,EAAmBG,EAAK,IAAI,EACxD,GAAIJ,EAAM,aAAoB,WAASI,EAAK,GAAG,EAC9C,MAAM,IAAI,MAAM,+EAA+EJ,EAAM,2BAAgC,WAASI,EAAK,GAAG,GAAG,EAG1J,IAAIS,EAAO,QAAQT,EAAK,IAAI,EAAI,EAAIA,EAAK,KAErCA,EAAK,WACRA,EAAK,MAAQ,CAAC,GAGf,QAASM,EAAI,EAAGA,EAAIN,EAAK,mBAAmB,GAAKS,EAAMH,IAAK,CAI3D,GAHI,QAAQN,EAAK,QAAQ,IACxBA,EAAK,SAAW,CAAC,GAEdA,EAAK,cAAgBA,EAAK,iBAC7B,OAID,IAAIU,EAAQC,GAAaL,EAAIG,CAAI,EAC7B,EAAI,IAAI,WAAWb,EAAM,WAAac,EAAM,UAAU,EAC1D,EAAE,IAAI,IAAI,WAAWd,CAAK,EAAG,CAAC,EAC9B,EAAE,IAAI,IAAI,WAAWc,CAAK,EAAGd,EAAM,UAAU,EAC7CI,EAAK,SAASM,GAAK,MAAgBR,EAAkB,MAAM,OAAO,OAAO,OAAOE,EAAK,IAAK,EAAE,MAAM,CAAC,EAE/FA,EAAK,mBAAmB,QAAU,IAErCA,EAAK,eACDA,EAAK,WACRA,EAAK,OAASA,EAAK,OAAO,OAAOA,EAAK,SAASM,EAAE,IAG/CN,EAAK,WACRA,EAAK,MAAMA,EAAK,SAASM,IAAM,CAACN,EAAK,IAAI,EAE3C,CAED,CAaA,SAASW,GAAaC,EAAK,CAC1B,GAAIA,EAAM,WACT,MAAM,IAAI,MAAM,iEAAiE,EAElF,IAAIC,EAAa,KAAK,KAAK,KAAK,KAAKD,EAAM,CAAC,EAAI,CAAC,EACjDC,EAAa,KAAK,IAAIA,EAAY,CAAC,EAEnC,IAAMC,EAAY,IAAI,WAAWD,CAAU,EAC3C,QAASP,EAAIO,EAAa,EAAGP,GAAK,EAAGA,IACpCQ,EAAUR,GAAKM,EAAM,IACrBA,IAAQ,EAGT,OAAOE,CA4BR,CAMA,IAAMC,GAAc,CAAC,OAAQ,OAAQ,QAAS,MAAO,SAAU,OAAQ,WAAW,EAOlF,SAASC,GAAkBhB,EAAMiB,EAAK,CACrC,QAASX,KAAKW,EAAK,CAClB,GAAI,EAAEA,EAAIX,GAAG,IAAI,MAAMN,EAAK,SAC3B,MAAM,IAAI,MAAM,eAAe,EAEhC,IAAIkB,EAAQlB,EAAK,QAAQiB,EAAIX,GAAG,IAAI,IAChCa,EAAK,CAAC,EACV,QAASb,KAAKY,EAAO,CACpB,GAAIZ,GAAK,EAAG,CACXa,EAAG,KAAOD,EAAMZ,GAChB,QACD,CACA,OAAQS,GAAYG,EAAM,OAASZ,GAAI,CACtC,QACC,MAAM,IAAI,MAAM,yBAAyB,EAC1C,IAAK,OACJa,EAAG,KAAOD,EAAMZ,GAChB,MACD,IAAK,QACJa,EAAG,MAAQD,EAAMZ,GACjB,MACD,IAAK,MACJa,EAAG,IAAMD,EAAMZ,GACf,MACD,IAAK,SACJa,EAAG,OAASD,EAAMZ,GAClB,MACD,IAAK,OACJa,EAAG,KAAOD,EAAMZ,GAChB,MACD,IAAK,YACJa,EAAG,UAAYD,EAAMZ,GACrB,KACF,CACD,CACAW,EAAIX,GAAG,aAAea,CACvB,CACD",
  "names": ["Coze", "Coze", "HashAB", "ab", "alg", "HashFile", "file", "buffer", "HashFileCallback", "callback", "reader", "digest", "RandomB64", "num", "randomArray", "RandomIDB64", "AnticounterfeitCanon", "NewAnticounterfeit", "cozeKey", "ac", "pay", "RandomIDB64", "AppendToObject", "obj", "objToAppend", "key", "Base10", "Base16", "Base16Lower", "RFCBase64Unsafe", "RFCBase64Uri", "ASCIIExtCTRLNPChars", "BASE37", "BASE38", "BASE45", "Base64", "Base66UriUnreserved", "Base191", "AB", "ASCIIExtCTRLNPChars", "Base10", "Base16", "Base16Lower", "RFCBase64Unsafe", "RFCBase64Uri", "BASE37Padded", "input", "inputBase", "alg", "b37", "BaseConvert", "AB", "LeftPadding", "inAlph", "outAlph", "fromBase", "toBase", "inAlphChars", "add", "x", "y", "base", "z", "n", "carry", "i", "xi", "yi", "zi", "multiplyByNumber", "num", "power", "result", "digits", "arr", "outArray", "out", "inPad", "outPad", "ASCIIExtCTRLNPChars", "AB", "ConcatBuffers", "b1", "b2", "tmp", "SToArrayBuffer", "string", "enc", "ExplodeBytes", "input", "GoBytesToString", "unicode", "c", "GoBytesToHex", "hex", "chunks", "SysCnvToHex", "inputText", "hexLine", "HexToGoBytesString", "bytes", "i", "BitPerBase", "base", "bits", "space", "ASCIIExtToChiclets", "outString", "char", "RemovePad", "inAlph", "inPad", "ArrayBufferToS", "ab", "ToUTF8Array", "str", "utf8", "charcode", "ArrayBufferToBigInt", "buffer", "result", "a", "i", "BigIntToArrayBuffer", "size", "bigInt", "view", "BaseToHex", "input", "inAlph", "BaseConvert", "SToHex", "hex", "c", "HexToS", "acc", "char", "HexPadded", "inputBase", "alg", "AB", "HexToUb64p", "Hex", "bytes", "a", "SToB64ut", "string", "B64utToS", "SToUB64p", "UB64pToS", "URIUnsafeToSafe", "ub64", "URISafeToUnsafe", "B64tToP", "b64t", "padding", "B64ToHex", "b64", "raw", "result", "i", "HexTob64ut", "ab", "HexToArrayBuffer", "ArrayBufferTo64ut", "buffer", "base64t", "B64utToArrayBuffer", "B64ToUint8Array", "ArrayBufferToHex", "x", "base64t", "base64", "EveryPathParse", "typ", "ep", "Authority", "Root", "Noun", "Verb", "Action", "Child", "StripHTTPS", "uri", "re", "EveryPathToString", "parts", "noun", "i", "action", "Coze", "Identity", "alg", "seed", "seedB", "B64utToArrayBuffer", "ArrayBufferTo64ut", "CalcPathsID", "tree", "key", "pathsID", "id", "PopulateTree", "GenTreeBranch", "i", "t", "leaf", "skip", "nonce", "IntToBytesBE", "int", "byteLength", "byteArray", "BundleTypes", "PopulateBundleIDs", "acs", "paths", "bp"]
}