{"version":3,"file":"serialize.cjs","sources":["../../../../../../node_modules/borsh/lib/esm/serialize.js"],"sourcesContent":["import { integers } from './types.js';\nimport { EncodeBuffer } from './buffer.js';\nimport * as utils from './utils.js';\nvar BorshSerializer = /** @class */ (function () {\n    function BorshSerializer(checkTypes) {\n        this.encoded = new EncodeBuffer();\n        this.fieldPath = ['value'];\n        this.checkTypes = checkTypes;\n    }\n    BorshSerializer.prototype.encode = function (value, schema) {\n        this.encode_value(value, schema);\n        return this.encoded.get_used_buffer();\n    };\n    BorshSerializer.prototype.encode_value = function (value, schema) {\n        if (typeof schema === 'string') {\n            if (integers.includes(schema))\n                return this.encode_integer(value, schema);\n            if (schema === 'string')\n                return this.encode_string(value);\n            if (schema === 'bool')\n                return this.encode_boolean(value);\n        }\n        if (typeof schema === 'object') {\n            if ('option' in schema)\n                return this.encode_option(value, schema);\n            if ('enum' in schema)\n                return this.encode_enum(value, schema);\n            if ('array' in schema)\n                return this.encode_array(value, schema);\n            if ('set' in schema)\n                return this.encode_set(value, schema);\n            if ('map' in schema)\n                return this.encode_map(value, schema);\n            if ('struct' in schema)\n                return this.encode_struct(value, schema);\n        }\n    };\n    BorshSerializer.prototype.encode_integer = function (value, schema) {\n        var size = parseInt(schema.substring(1));\n        if (size <= 32 || schema == 'f64') {\n            this.checkTypes && utils.expect_type(value, 'number', this.fieldPath);\n            this.encoded.store_value(value, schema);\n        }\n        else {\n            this.checkTypes && utils.expect_bigint(value, this.fieldPath);\n            this.encode_bigint(BigInt(value), size);\n        }\n    };\n    BorshSerializer.prototype.encode_bigint = function (value, size) {\n        var buffer_len = size / 8;\n        var buffer = new Uint8Array(buffer_len);\n        for (var i = 0; i < buffer_len; i++) {\n            buffer[i] = Number(value & BigInt(0xff));\n            value = value >> BigInt(8);\n        }\n        this.encoded.store_bytes(new Uint8Array(buffer));\n    };\n    BorshSerializer.prototype.encode_string = function (value) {\n        this.checkTypes && utils.expect_type(value, 'string', this.fieldPath);\n        var _value = value;\n        // encode to utf8 bytes without using TextEncoder\n        var utf8Bytes = [];\n        for (var i = 0; i < _value.length; i++) {\n            var charCode = _value.charCodeAt(i);\n            if (charCode < 0x80) {\n                utf8Bytes.push(charCode);\n            }\n            else if (charCode < 0x800) {\n                utf8Bytes.push(0xc0 | (charCode >> 6), 0x80 | (charCode & 0x3f));\n            }\n            else if (charCode < 0xd800 || charCode >= 0xe000) {\n                utf8Bytes.push(0xe0 | (charCode >> 12), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));\n            }\n            else {\n                i++;\n                charCode = 0x10000 + (((charCode & 0x3ff) << 10) | (_value.charCodeAt(i) & 0x3ff));\n                utf8Bytes.push(0xf0 | (charCode >> 18), 0x80 | ((charCode >> 12) & 0x3f), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));\n            }\n        }\n        // 4 bytes for length + string bytes\n        this.encoded.store_value(utf8Bytes.length, 'u32');\n        this.encoded.store_bytes(new Uint8Array(utf8Bytes));\n    };\n    BorshSerializer.prototype.encode_boolean = function (value) {\n        this.checkTypes && utils.expect_type(value, 'boolean', this.fieldPath);\n        this.encoded.store_value(value ? 1 : 0, 'u8');\n    };\n    BorshSerializer.prototype.encode_option = function (value, schema) {\n        if (value === null || value === undefined) {\n            this.encoded.store_value(0, 'u8');\n        }\n        else {\n            this.encoded.store_value(1, 'u8');\n            this.encode_value(value, schema.option);\n        }\n    };\n    BorshSerializer.prototype.encode_enum = function (value, schema) {\n        this.checkTypes && utils.expect_enum(value, this.fieldPath);\n        var valueKey = Object.keys(value)[0];\n        for (var i = 0; i < schema[\"enum\"].length; i++) {\n            var valueSchema = schema[\"enum\"][i];\n            if (valueKey === Object.keys(valueSchema.struct)[0]) {\n                this.encoded.store_value(i, 'u8');\n                return this.encode_struct(value, valueSchema);\n            }\n        }\n        throw new Error(\"Enum key (\".concat(valueKey, \") not found in enum schema: \").concat(JSON.stringify(schema), \" at \").concat(this.fieldPath.join('.')));\n    };\n    BorshSerializer.prototype.encode_array = function (value, schema) {\n        if (utils.isArrayLike(value))\n            return this.encode_arraylike(value, schema);\n        if (value instanceof ArrayBuffer)\n            return this.encode_buffer(value, schema);\n        throw new Error(\"Expected Array-like not \".concat(typeof (value), \"(\").concat(value, \") at \").concat(this.fieldPath.join('.')));\n    };\n    BorshSerializer.prototype.encode_arraylike = function (value, schema) {\n        if (schema.array.len) {\n            utils.expect_same_size(value.length, schema.array.len, this.fieldPath);\n        }\n        else {\n            // 4 bytes for length\n            this.encoded.store_value(value.length, 'u32');\n        }\n        // array values\n        for (var i = 0; i < value.length; i++) {\n            this.encode_value(value[i], schema.array.type);\n        }\n    };\n    BorshSerializer.prototype.encode_buffer = function (value, schema) {\n        if (schema.array.len) {\n            utils.expect_same_size(value.byteLength, schema.array.len, this.fieldPath);\n        }\n        else {\n            // 4 bytes for length\n            this.encoded.store_value(value.byteLength, 'u32');\n        }\n        // array values\n        this.encoded.store_bytes(new Uint8Array(value));\n    };\n    BorshSerializer.prototype.encode_set = function (value, schema) {\n        this.checkTypes && utils.expect_type(value, 'object', this.fieldPath);\n        var isSet = value instanceof Set;\n        var values = isSet ? Array.from(value.values()) : Object.values(value);\n        // 4 bytes for length\n        this.encoded.store_value(values.length, 'u32');\n        // set values\n        for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {\n            var value_1 = values_1[_i];\n            this.encode_value(value_1, schema.set);\n        }\n    };\n    BorshSerializer.prototype.encode_map = function (value, schema) {\n        this.checkTypes && utils.expect_type(value, 'object', this.fieldPath);\n        var isMap = value instanceof Map;\n        var keys = isMap ? Array.from(value.keys()) : Object.keys(value);\n        // 4 bytes for length\n        this.encoded.store_value(keys.length, 'u32');\n        // store key/values\n        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {\n            var key = keys_1[_i];\n            this.encode_value(key, schema.map.key);\n            this.encode_value(isMap ? value.get(key) : value[key], schema.map.value);\n        }\n    };\n    BorshSerializer.prototype.encode_struct = function (value, schema) {\n        this.checkTypes && utils.expect_type(value, 'object', this.fieldPath);\n        for (var _i = 0, _a = Object.keys(schema.struct); _i < _a.length; _i++) {\n            var key = _a[_i];\n            this.fieldPath.push(key);\n            this.encode_value(value[key], schema.struct[key]);\n            this.fieldPath.pop();\n        }\n    };\n    return BorshSerializer;\n}());\nexport { BorshSerializer };\n"],"names":["BorshSerializer","checkTypes","this","encoded","EncodeBuffer","fieldPath","prototype","encode","value","schema","encode_value","get_used_buffer","integers","includes","encode_integer","encode_string","encode_boolean","encode_option","encode_enum","encode_array","encode_set","encode_map","encode_struct","size","parseInt","substring","utils","expect_type","store_value","encode_bigint","BigInt","buffer_len","buffer","Uint8Array","i","Number","store_bytes","_value","utf8Bytes","length","charCode","charCodeAt","push","option","valueKey","Object","keys","valueSchema","struct","Error","concat","JSON","stringify","join","encode_arraylike","ArrayBuffer","encode_buffer","array","len","expect_same_size","type","byteLength","values","Set","Array","from","_i","values_1","value_1","set","isMap","Map","keys_1","key","map","get","_a","pop"],"mappings":"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","x_google_ignoreList":[0]}