chrome-devtools-frontend

/* Copyright 2016 Mozilla Foundation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ // See https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md const WASM_MAGIC_NUMBER = 0x6d736100; const WASM_SUPPORTED_EXPERIMENTAL_VERSION = 0xd; const WASM_SUPPORTED_VERSION = 0x1; export const enum SectionCode { Unknown = -1, Custom = 0, Type = 1, // Function signature declarations Import = 2, // Import declarations Function = 3, // Function declarations Table = 4, // Indirect function table and other tables Memory = 5, // Memory attributes Global = 6, // Global declarations Export = 7, //Exports Start = 8, // Start function declaration Element = 9, // Elements section Code = 10, // Function bodies (code) Data = 11, // Data segments Event = 13, // Events } export const enum OperatorCode { unreachable = 0x00, nop = 0x01, block = 0x02, loop = 0x03, if = 0x04, else = 0x05, try = 0x06, catch = 0x07, throw = 0x08, rethrow = 0x09, unwind = 0x0a, end = 0x0b, br = 0x0c, br_if = 0x0d, br_table = 0x0e, return = 0x0f, call = 0x10, call_indirect = 0x11, return_call = 0x12, return_call_indirect = 0x13, call_ref = 0x14, return_call_ref = 0x15, let = 0x17, delegate = 0x18, catch_all = 0x19, drop = 0x1a, select = 0x1b, select_with_type = 0x1c, local_get = 0x20, local_set = 0x21, local_tee = 0x22, global_get = 0x23, global_set = 0x24, i32_load = 0x28, i64_load = 0x29, f32_load = 0x2a, f64_load = 0x2b, i32_load8_s = 0x2c, i32_load8_u = 0x2d, i32_load16_s = 0x2e, i32_load16_u = 0x2f, i64_load8_s = 0x30, i64_load8_u = 0x31, i64_load16_s = 0x32, i64_load16_u = 0x33, i64_load32_s = 0x34, i64_load32_u = 0x35, i32_store = 0x36, i64_store = 0x37, f32_store = 0x38, f64_store = 0x39, i32_store8 = 0x3a, i32_store16 = 0x3b, i64_store8 = 0x3c, i64_store16 = 0x3d, i64_store32 = 0x3e, current_memory = 0x3f, grow_memory = 0x40, i32_const = 0x41, i64_const = 0x42, f32_const = 0x43, f64_const = 0x44, i32_eqz = 0x45, i32_eq = 0x46, i32_ne = 0x47, i32_lt_s = 0x48, i32_lt_u = 0x49, i32_gt_s = 0x4a, i32_gt_u = 0x4b, i32_le_s = 0x4c, i32_le_u = 0x4d, i32_ge_s = 0x4e, i32_ge_u = 0x4f, i64_eqz = 0x50, i64_eq = 0x51, i64_ne = 0x52, i64_lt_s = 0x53, i64_lt_u = 0x54, i64_gt_s = 0x55, i64_gt_u = 0x56, i64_le_s = 0x57, i64_le_u = 0x58, i64_ge_s = 0x59, i64_ge_u = 0x5a, f32_eq = 0x5b, f32_ne = 0x5c, f32_lt = 0x5d, f32_gt = 0x5e, f32_le = 0x5f, f32_ge = 0x60, f64_eq = 0x61, f64_ne = 0x62, f64_lt = 0x63, f64_gt = 0x64, f64_le = 0x65, f64_ge = 0x66, i32_clz = 0x67, i32_ctz = 0x68, i32_popcnt = 0x69, i32_add = 0x6a, i32_sub = 0x6b, i32_mul = 0x6c, i32_div_s = 0x6d, i32_div_u = 0x6e, i32_rem_s = 0x6f, i32_rem_u = 0x70, i32_and = 0x71, i32_or = 0x72, i32_xor = 0x73, i32_shl = 0x74, i32_shr_s = 0x75, i32_shr_u = 0x76, i32_rotl = 0x77, i32_rotr = 0x78, i64_clz = 0x79, i64_ctz = 0x7a, i64_popcnt = 0x7b, i64_add = 0x7c, i64_sub = 0x7d, i64_mul = 0x7e, i64_div_s = 0x7f, i64_div_u = 0x80, i64_rem_s = 0x81, i64_rem_u = 0x82, i64_and = 0x83, i64_or = 0x84, i64_xor = 0x85, i64_shl = 0x86, i64_shr_s = 0x87, i64_shr_u = 0x88, i64_rotl = 0x89, i64_rotr = 0x8a, f32_abs = 0x8b, f32_neg = 0x8c, f32_ceil = 0x8d, f32_floor = 0x8e, f32_trunc = 0x8f, f32_nearest = 0x90, f32_sqrt = 0x91, f32_add = 0x92, f32_sub = 0x93, f32_mul = 0x94, f32_div = 0x95, f32_min = 0x96, f32_max = 0x97, f32_copysign = 0x98, f64_abs = 0x99, f64_neg = 0x9a, f64_ceil = 0x9b, f64_floor = 0x9c, f64_trunc = 0x9d, f64_nearest = 0x9e, f64_sqrt = 0x9f, f64_add = 0xa0, f64_sub = 0xa1, f64_mul = 0xa2, f64_div = 0xa3, f64_min = 0xa4, f64_max = 0xa5, f64_copysign = 0xa6, i32_wrap_i64 = 0xa7, i32_trunc_f32_s = 0xa8, i32_trunc_f32_u = 0xa9, i32_trunc_f64_s = 0xaa, i32_trunc_f64_u = 0xab, i64_extend_i32_s = 0xac, i64_extend_i32_u = 0xad, i64_trunc_f32_s = 0xae, i64_trunc_f32_u = 0xaf, i64_trunc_f64_s = 0xb0, i64_trunc_f64_u = 0xb1, f32_convert_i32_s = 0xb2, f32_convert_i32_u = 0xb3, f32_convert_i64_s = 0xb4, f32_convert_i64_u = 0xb5, f32_demote_f64 = 0xb6, f64_convert_i32_s = 0xb7, f64_convert_i32_u = 0xb8, f64_convert_i64_s = 0xb9, f64_convert_i64_u = 0xba, f64_promote_f32 = 0xbb, i32_reinterpret_f32 = 0xbc, i64_reinterpret_f64 = 0xbd, f32_reinterpret_i32 = 0xbe, f64_reinterpret_i64 = 0xbf, i32_extend8_s = 0xc0, i32_extend16_s = 0xc1, i64_extend8_s = 0xc2, i64_extend16_s = 0xc3, i64_extend32_s = 0xc4, prefix_0xfb = 0xfb, prefix_0xfc = 0xfc, prefix_0xfd = 0xfd, prefix_0xfe = 0xfe, i32_trunc_sat_f32_s = 0xfc00, i32_trunc_sat_f32_u = 0xfc01, i32_trunc_sat_f64_s = 0xfc02, i32_trunc_sat_f64_u = 0xfc03, i64_trunc_sat_f32_s = 0xfc04, i64_trunc_sat_f32_u = 0xfc05, i64_trunc_sat_f64_s = 0xfc06, i64_trunc_sat_f64_u = 0xfc07, memory_init = 0xfc08, data_drop = 0xfc09, memory_copy = 0xfc0a, memory_fill = 0xfc0b, table_init = 0xfc0c, elem_drop = 0xfc0d, table_copy = 0xfc0e, table_grow = 0xfc0f, table_size = 0xfc10, table_fill = 0xfc11, table_get = 0x25, table_set = 0x26, ref_null = 0xd0, ref_is_null = 0xd1, ref_func = 0xd2, ref_as_non_null = 0xd3, br_on_null = 0xd4, ref_eq = 0xd5, br_on_non_null = 0xd6, atomic_notify = 0xfe00, i32_atomic_wait = 0xfe01, i64_atomic_wait = 0xfe02, atomic_fence = 0xfe03, i32_atomic_load = 0xfe10, i64_atomic_load = 0xfe11, i32_atomic_load8_u = 0xfe12, i32_atomic_load16_u = 0xfe13, i64_atomic_load8_u = 0xfe14, i64_atomic_load16_u = 0xfe15, i64_atomic_load32_u = 0xfe16, i32_atomic_store = 0xfe17, i64_atomic_store = 0xfe18, i32_atomic_store8 = 0xfe19, i32_atomic_store16 = 0xfe1a, i64_atomic_store8 = 0xfe1b, i64_atomic_store16 = 0xfe1c, i64_atomic_store32 = 0xfe1d, i32_atomic_rmw_add = 0xfe1e, i64_atomic_rmw_add = 0xfe1f, i32_atomic_rmw8_add_u = 0xfe20, i32_atomic_rmw16_add_u = 0xfe21, i64_atomic_rmw8_add_u = 0xfe22, i64_atomic_rmw16_add_u = 0xfe23, i64_atomic_rmw32_add_u = 0xfe24, i32_atomic_rmw_sub = 0xfe25, i64_atomic_rmw_sub = 0xfe26, i32_atomic_rmw8_sub_u = 0xfe27, i32_atomic_rmw16_sub_u = 0xfe28, i64_atomic_rmw8_sub_u = 0xfe29, i64_atomic_rmw16_sub_u = 0xfe2a, i64_atomic_rmw32_sub_u = 0xfe2b, i32_atomic_rmw_and = 0xfe2c, i64_atomic_rmw_and = 0xfe2d, i32_atomic_rmw8_and_u = 0xfe2e, i32_atomic_rmw16_and_u = 0xfe2f, i64_atomic_rmw8_and_u = 0xfe30, i64_atomic_rmw16_and_u = 0xfe31, i64_atomic_rmw32_and_u = 0xfe32, i32_atomic_rmw_or = 0xfe33, i64_atomic_rmw_or = 0xfe34, i32_atomic_rmw8_or_u = 0xfe35, i32_atomic_rmw16_or_u = 0xfe36, i64_atomic_rmw8_or_u = 0xfe37, i64_atomic_rmw16_or_u = 0xfe38, i64_atomic_rmw32_or_u = 0xfe39, i32_atomic_rmw_xor = 0xfe3a, i64_atomic_rmw_xor = 0xfe3b, i32_atomic_rmw8_xor_u = 0xfe3c, i32_atomic_rmw16_xor_u = 0xfe3d, i64_atomic_rmw8_xor_u = 0xfe3e, i64_atomic_rmw16_xor_u = 0xfe3f, i64_atomic_rmw32_xor_u = 0xfe40, i32_atomic_rmw_xchg = 0xfe41, i64_atomic_rmw_xchg = 0xfe42, i32_atomic_rmw8_xchg_u = 0xfe43, i32_atomic_rmw16_xchg_u = 0xfe44, i64_atomic_rmw8_xchg_u = 0xfe45, i64_atomic_rmw16_xchg_u = 0xfe46, i64_atomic_rmw32_xchg_u = 0xfe47, i32_atomic_rmw_cmpxchg = 0xfe48, i64_atomic_rmw_cmpxchg = 0xfe49, i32_atomic_rmw8_cmpxchg_u = 0xfe4a, i32_atomic_rmw16_cmpxchg_u = 0xfe4b, i64_atomic_rmw8_cmpxchg_u = 0xfe4c, i64_atomic_rmw16_cmpxchg_u = 0xfe4d, i64_atomic_rmw32_cmpxchg_u = 0xfe4e, v128_load = 0xfd00, i16x8_load8x8_s = 0xfd01, i16x8_load8x8_u = 0xfd02, i32x4_load16x4_s = 0xfd03, i32x4_load16x4_u = 0xfd04, i64x2_load32x2_s = 0xfd05, i64x2_load32x2_u = 0xfd06, v8x16_load_splat = 0xfd07, v16x8_load_splat = 0xfd08, v32x4_load_splat = 0xfd09, v64x2_load_splat = 0xfd0a, v128_store = 0xfd0b, v128_const = 0xfd0c, i8x16_shuffle = 0xfd0d, i8x16_swizzle = 0xfd0e, i8x16_splat = 0xfd0f, i16x8_splat = 0xfd10, i32x4_splat = 0xfd11, i64x2_splat = 0xfd12, f32x4_splat = 0xfd13, f64x2_splat = 0xfd14, i8x16_extract_lane_s = 0xfd15, i8x16_extract_lane_u = 0xfd16, i8x16_replace_lane = 0xfd17, i16x8_extract_lane_s = 0xfd18, i16x8_extract_lane_u = 0xfd19, i16x8_replace_lane = 0xfd1a, i32x4_extract_lane = 0xfd1b, i32x4_replace_lane = 0xfd1c, i64x2_extract_lane = 0xfd1d, i64x2_replace_lane = 0xfd1e, f32x4_extract_lane = 0xfd1f, f32x4_replace_lane = 0xfd20, f64x2_extract_lane = 0xfd21, f64x2_replace_lane = 0xfd22, i8x16_eq = 0xfd23, i8x16_ne = 0xfd24, i8x16_lt_s = 0xfd25, i8x16_lt_u = 0xfd26, i8x16_gt_s = 0xfd27, i8x16_gt_u = 0xfd28, i8x16_le_s = 0xfd29, i8x16_le_u = 0xfd2a, i8x16_ge_s = 0xfd2b, i8x16_ge_u = 0xfd2c, i16x8_eq = 0xfd2d, i16x8_ne = 0xfd2e, i16x8_lt_s = 0xfd2f, i16x8_lt_u = 0xfd30, i16x8_gt_s = 0xfd31, i16x8_gt_u = 0xfd32, i16x8_le_s = 0xfd33, i16x8_le_u = 0xfd34, i16x8_ge_s = 0xfd35, i16x8_ge_u = 0xfd36, i32x4_eq = 0xfd37, i32x4_ne = 0xfd38, i32x4_lt_s = 0xfd39, i32x4_lt_u = 0xfd3a, i32x4_gt_s = 0xfd3b, i32x4_gt_u = 0xfd3c, i32x4_le_s = 0xfd3d, i32x4_le_u = 0xfd3e, i32x4_ge_s = 0xfd3f, i32x4_ge_u = 0xfd40, f32x4_eq = 0xfd41, f32x4_ne = 0xfd42, f32x4_lt = 0xfd43, f32x4_gt = 0xfd44, f32x4_le = 0xfd45, f32x4_ge = 0xfd46, f64x2_eq = 0xfd47, f64x2_ne = 0xfd48, f64x2_lt = 0xfd49, f64x2_gt = 0xfd4a, f64x2_le = 0xfd4b, f64x2_ge = 0xfd4c, v128_not = 0xfd4d, v128_and = 0xfd4e, v128_andnot = 0xfd4f, v128_or = 0xfd50, v128_xor = 0xfd51, v128_bitselect = 0xfd52, v128_any_true = 0xfd53, v128_load8_lane = 0xfd54, v128_load16_lane = 0xfd55, v128_load32_lane = 0xfd56, v128_load64_lane = 0xfd57, v128_store8_lane = 0xfd58, v128_store16_lane = 0xfd59, v128_store32_lane = 0xfd5a, v128_store64_lane = 0xfd5b, v128_load32_zero = 0xfd5c, v128_load64_zero = 0xfd5d, f32x4_demote_f64x2_zero = 0xfd5e, f64x2_promote_low_f32x4 = 0xfd5f, i8x16_abs = 0xfd60, i8x16_neg = 0xfd61, i8x16_popcnt = 0xfd62, i8x16_all_true = 0xfd63, i8x16_bitmask = 0xfd64, i8x16_narrow_i16x8_s = 0xfd65, i8x16_narrow_i16x8_u = 0xfd66, f32x4_ceil = 0xfd67, f32x4_floor = 0xfd68, f32x4_trunc = 0xfd69, f32x4_nearest = 0xfd6a, i8x16_shl = 0xfd6b, i8x16_shr_s = 0xfd6c, i8x16_shr_u = 0xfd6d, i8x16_add = 0xfd6e, i8x16_add_sat_s = 0xfd6f, i8x16_add_sat_u = 0xfd70, i8x16_sub = 0xfd71, i8x16_sub_sat_s = 0xfd72, i8x16_sub_sat_u = 0xfd73, f64x2_ceil = 0xfd74, f64x2_floor = 0xfd75, i8x16_min_s = 0xfd76, i8x16_min_u = 0xfd77, i8x16_max_s = 0xfd78, i8x16_max_u = 0xfd79, f64x2_trunc = 0xfd7a, i8x16_avgr_u = 0xfd7b, i16x8_extadd_pairwise_i8x16_s = 0xfd7c, i16x8_extadd_pairwise_i8x16_u = 0xfd7d, i32x4_extadd_pairwise_i16x8_s = 0xfd7e, i32x4_extadd_pairwise_i16x8_u = 0xfd7f, i16x8_abs = 0xfd80, i16x8_neg = 0xfd81, i16x8_q15mulr_sat_s = 0xfd82, i16x8_all_true = 0xfd83, i16x8_bitmask = 0xfd84, i16x8_narrow_i32x4_s = 0xfd85, i16x8_narrow_i32x4_u = 0xfd86, i16x8_extend_low_i8x16_s = 0xfd87, i16x8_extend_high_i8x16_s = 0xfd88, i16x8_extend_low_i8x16_u = 0xfd89, i16x8_extend_high_i8x16_u = 0xfd8a, i16x8_shl = 0xfd8b, i16x8_shr_s = 0xfd8c, i16x8_shr_u = 0xfd8d, i16x8_add = 0xfd8e, i16x8_add_sat_s = 0xfd8f, i16x8_add_sat_u = 0xfd90, i16x8_sub = 0xfd91, i16x8_sub_sat_s = 0xfd92, i16x8_sub_sat_u = 0xfd93, f64x2_nearest = 0xfd94, i16x8_mul = 0xfd95, i16x8_min_s = 0xfd96, i16x8_min_u = 0xfd97, i16x8_max_s = 0xfd98, i16x8_max_u = 0xfd99, i16x8_avgr_u = 0xfd9b, i16x8_extmul_low_i8x16_s = 0xfd9c, i16x8_extmul_high_i8x16_s = 0xfd9d, i16x8_extmul_low_i8x16_u = 0xfd9e, i16x8_extmul_high_i8x16_u = 0xfd9f, i32x4_abs = 0xfda0, i32x4_neg = 0xfda1, i32x4_all_true = 0xfda3, i32x4_bitmask = 0xfda4, i32x4_extend_low_i16x8_s = 0xfda7, i32x4_extend_high_i16x8_s = 0xfda8, i32x4_extend_low_i16x8_u = 0xfda9, i32x4_extend_high_i16x8_u = 0xfdaa, i32x4_shl = 0xfdab, i32x4_shr_s = 0xfdac, i32x4_shr_u = 0xfdad, i32x4_add = 0xfdae, i32x4_sub = 0xfdb1, i32x4_mul = 0xfdb5, i32x4_min_s = 0xfdb6, i32x4_min_u = 0xfdb7, i32x4_max_s = 0xfdb8, i32x4_max_u = 0xfdb9, i32x4_dot_i16x8_s = 0xfdba, i32x4_extmul_low_i16x8_s = 0xfdbc, i32x4_extmul_high_i16x8_s = 0xfdbd, i32x4_extmul_low_i16x8_u = 0xfdbe, i32x4_extmul_high_i16x8_u = 0xfdbf, i64x2_abs = 0xfdc0, i64x2_neg = 0xfdc1, i64x2_all_true = 0xfdc3, i64x2_bitmask = 0xfdc4, i64x2_extend_low_i32x4_s = 0xfdc7, i64x2_extend_high_i32x4_s = 0xfdc8, i64x2_extend_low_i32x4_u = 0xfdc9, i64x2_extend_high_i32x4_u = 0xfdca, i64x2_shl = 0xfdcb, i64x2_shr_s = 0xfdcc, i64x2_shr_u = 0xfdcd, i64x2_add = 0xfdce, i64x2_sub = 0xfdd1, i64x2_mul = 0xfdd5, i64x2_eq = 0xfdd6, i64x2_ne = 0xfdd7, i64x2_lt_s = 0xfdd8, i64x2_gt_s = 0xfdd9, i64x2_le_s = 0xfdda, i64x2_ge_s = 0xfddb, i64x2_extmul_low_i32x4_s = 0xfddc, i64x2_extmul_high_i32x4_s = 0xfddd, i64x2_extmul_low_i32x4_u = 0xfdde, i64x2_extmul_high_i32x4_u = 0xfddf, f32x4_abs = 0xfde0, f32x4_neg = 0xfde1, f32x4_sqrt = 0xfde3, f32x4_add = 0xfde4, f32x4_sub = 0xfde5, f32x4_mul = 0xfde6, f32x4_div = 0xfde7, f32x4_min = 0xfde8, f32x4_max = 0xfde9, f32x4_pmin = 0xfdea, f32x4_pmax = 0xfdeb, f64x2_abs = 0xfdec, f64x2_neg = 0xfded, f64x2_sqrt = 0xfdef, f64x2_add = 0xfdf0, f64x2_sub = 0xfdf1, f64x2_mul = 0xfdf2, f64x2_div = 0xfdf3, f64x2_min = 0xfdf4, f64x2_max = 0xfdf5, f64x2_pmin = 0xfdf6, f64x2_pmax = 0xfdf7, i32x4_trunc_sat_f32x4_s = 0xfdf8, i32x4_trunc_sat_f32x4_u = 0xfdf9, f32x4_convert_i32x4_s = 0xfdfa, f32x4_convert_i32x4_u = 0xfdfb, i32x4_trunc_sat_f64x2_s_zero = 0xfdfc, i32x4_trunc_sat_f64x2_u_zero = 0xfdfd, f64x2_convert_low_i32x4_s = 0xfdfe, f64x2_convert_low_i32x4_u = 0xfdff, // GC proposal. struct_new_with_rtt = 0xfb01, struct_new_default_with_rtt = 0xfb02, struct_get = 0xfb03, struct_get_s = 0xfb04, struct_get_u = 0xfb05, struct_set = 0xfb06, struct_new = 0xfb07, struct_new_default = 0xfb08, array_new_with_rtt = 0xfb11, array_new_default_with_rtt = 0xfb12, array_get = 0xfb13, array_get_s = 0xfb14, array_get_u = 0xfb15, array_set = 0xfb16, array_len = 0xfb17, array_copy = 0xfb18, // Non-standard experiment in V8. array_init = 0xfb19, array_init_static = 0xfb1a, array_new = 0xfb1b, array_new_default = 0xfb1c, i31_new = 0xfb20, i31_get_s = 0xfb21, i31_get_u = 0xfb22, rtt_canon = 0xfb30, rtt_sub = 0xfb31, rtt_fresh_sub = 0xfb32, // Non-standard experiment in V8. ref_test = 0xfb40, ref_test_static = 0xfb44, ref_cast = 0xfb41, ref_cast_static = 0xfb45, br_on_cast = 0xfb42, br_on_cast_static = 0xfb46, br_on_cast_fail = 0xfb43, br_on_cast_static_fail = 0xfb47, ref_is_func = 0xfb50, ref_is_data = 0xfb51, ref_is_i31 = 0xfb52, ref_as_func = 0xfb58, ref_as_data = 0xfb59, ref_as_i31 = 0xfb5a, br_on_func = 0xfb60, br_on_data = 0xfb61, br_on_i31 = 0xfb62, br_on_non_func = 0xfb63, br_on_non_data = 0xfb64, br_on_non_i31 = 0xfb65, } export const OperatorCodeNames = [ "unreachable", "nop", "block", "loop", "if", "else", "try", "catch", "throw", "rethrow", "unwind", "end", "br", "br_if", "br_table", "return", "call", "call_indirect", "return_call", "return_call_indirect", "call_ref", "return_call_ref", undefined, "let", "delegate", "catch_all", "drop", "select", "select", // with types. undefined, undefined, undefined, "local.get", "local.set", "local.tee", "global.get", "global.set", "table.get", "table.set", undefined, "i32.load", "i64.load", "f32.load", "f64.load", "i32.load8_s", "i32.load8_u", "i32.load16_s", "i32.load16_u", "i64.load8_s", "i64.load8_u", "i64.load16_s", "i64.load16_u", "i64.load32_s", "i64.load32_u", "i32.store", "i64.store", "f32.store", "f64.store", "i32.store8", "i32.store16", "i64.store8", "i64.store16", "i64.store32", "current_memory", "memory.grow", "i32.const", "i64.const", "f32.const", "f64.const", "i32.eqz", "i32.eq", "i32.ne", "i32.lt_s", "i32.lt_u", "i32.gt_s", "i32.gt_u", "i32.le_s", "i32.le_u", "i32.ge_s", "i32.ge_u", "i64.eqz", "i64.eq", "i64.ne", "i64.lt_s", "i64.lt_u", "i64.gt_s", "i64.gt_u", "i64.le_s", "i64.le_u", "i64.ge_s", "i64.ge_u", "f32.eq", "f32.ne", "f32.lt", "f32.gt", "f32.le", "f32.ge", "f64.eq", "f64.ne", "f64.lt", "f64.gt", "f64.le", "f64.ge", "i32.clz", "i32.ctz", "i32.popcnt", "i32.add", "i32.sub", "i32.mul", "i32.div_s", "i32.div_u", "i32.rem_s", "i32.rem_u", "i32.and", "i32.or", "i32.xor", "i32.shl", "i32.shr_s", "i32.shr_u", "i32.rotl", "i32.rotr", "i64.clz", "i64.ctz", "i64.popcnt", "i64.add", "i64.sub", "i64.mul", "i64.div_s", "i64.div_u", "i64.rem_s", "i64.rem_u", "i64.and", "i64.or", "i64.xor", "i64.shl", "i64.shr_s", "i64.shr_u", "i64.rotl", "i64.rotr", "f32.abs", "f32.neg", "f32.ceil", "f32.floor", "f32.trunc", "f32.nearest", "f32.sqrt", "f32.add", "f32.sub", "f32.mul", "f32.div", "f32.min", "f32.max", "f32.copysign", "f64.abs", "f64.neg", "f64.ceil", "f64.floor", "f64.trunc", "f64.nearest", "f64.sqrt", "f64.add", "f64.sub", "f64.mul", "f64.div", "f64.min", "f64.max", "f64.copysign", "i32.wrap_i64", "i32.trunc_f32_s", "i32.trunc_f32_u", "i32.trunc_f64_s", "i32.trunc_f64_u", "i64.extend_i32_s", "i64.extend_i32_u", "i64.trunc_f32_s", "i64.trunc_f32_u", "i64.trunc_f64_s", "i64.trunc_f64_u", "f32.convert_i32_s", "f32.convert_i32_u", "f32.convert_i64_s", "f32.convert_i64_u", "f32.demote_f64", "f64.convert_i32_s", "f64.convert_i32_u", "f64.convert_i64_s", "f64.convert_i64_u", "f64.promote_f32", "i32.reinterpret_f32", "i64.reinterpret_f64", "f32.reinterpret_i32", "f64.reinterpret_i64", "i32.extend8_s", "i32.extend16_s", "i64.extend8_s", "i64.extend16_s", "i64.extend32_s", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, "ref.null", "ref.is_null", "ref.func", "ref.as_non_null", "br_on_null", "ref.eq", "br_on_non_null", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, ]; [ "i32.trunc_sat_f32_s", "i32.trunc_sat_f32_u", "i32.trunc_sat_f64_s", "i32.trunc_sat_f64_u", "i64.trunc_sat_f32_s", "i64.trunc_sat_f32_u", "i64.trunc_sat_f64_s", "i64.trunc_sat_f64_u", "memory.init", "data.drop", "memory.copy", "memory.fill", "table.init", "elem.drop", "table.copy", "table.grow", "table.size", "table.fill", ].forEach((s, i) => { OperatorCodeNames[0xfc00 | i] = s; }); [ "v128.load", "i16x8.load8x8_s", "i16x8.load8x8_u", "i32x4.load16x4_s", "i32x4.load16x4_u", "i64x2.load32x2_s", "i64x2.load32x2_u", "v8x16.load_splat", "v16x8.load_splat", "v32x4.load_splat", "v64x2.load_splat", "v128.store", "v128.const", "i8x16.shuffle", "i8x16.swizzle", "i8x16.splat", "i16x8.splat", "i32x4.splat", "i64x2.splat", "f32x4.splat", "f64x2.splat", "i8x16.extract_lane_s", "i8x16.extract_lane_u", "i8x16.replace_lane", "i16x8.extract_lane_s", "i16x8.extract_lane_u", "i16x8.replace_lane", "i32x4.extract_lane", "i32x4.replace_lane", "i64x2.extract_lane", "i64x2.replace_lane", "f32x4.extract_lane", "f32x4.replace_lane", "f64x2.extract_lane", "f64x2.replace_lane", "i8x16.eq", "i8x16.ne", "i8x16.lt_s", "i8x16.lt_u", "i8x16.gt_s", "i8x16.gt_u", "i8x16.le_s", "i8x16.le_u", "i8x16.ge_s", "i8x16.ge_u", "i16x8.eq", "i16x8.ne", "i16x8.lt_s", "i16x8.lt_u", "i16x8.gt_s", "i16x8.gt_u", "i16x8.le_s", "i16x8.le_u", "i16x8.ge_s", "i16x8.ge_u", "i32x4.eq", "i32x4.ne", "i32x4.lt_s", "i32x4.lt_u", "i32x4.gt_s", "i32x4.gt_u", "i32x4.le_s", "i32x4.le_u", "i32x4.ge_s", "i32x4.ge_u", "f32x4.eq", "f32x4.ne", "f32x4.lt", "f32x4.gt", "f32x4.le", "f32x4.ge", "f64x2.eq", "f64x2.ne", "f64x2.lt", "f64x2.gt", "f64x2.le", "f64x2.ge", "v128.not", "v128.and", "v128.andnot", "v128.or", "v128.xor", "v128.bitselect", "v128.any_true", "v128.load8_lane", "v128.load16_lane", "v128.load32_lane", "v128.load64_lane", "v128.store8_lane", "v128.store16_lane", "v128.store32_lane", "v128.store64_lane", "v128.load32_zero", "v128.load64_zero", "f32x4.demote_f64x2_zero", "f64x2.promote_low_f32x4", "i8x16.abs", "i8x16.neg", "i8x16_popcnt", "i8x16.all_true", "i8x16.bitmask", "i8x16.narrow_i16x8_s", "i8x16.narrow_i16x8_u", "f32x4.ceil", "f32x4.floor", "f32x4.trunc", "f32x4.nearest", "i8x16.shl", "i8x16.shr_s", "i8x16.shr_u", "i8x16.add", "i8x16.add_sat_s", "i8x16.add_sat_u", "i8x16.sub", "i8x16.sub_sat_s", "i8x16.sub_sat_u", "f64x2.ceil", "f64x2.floor", "i8x16.min_s", "i8x16.min_u", "i8x16.max_s", "i8x16.max_u", "f64x2.trunc", "i8x16.avgr_u", "i16x8.extadd_pairwise_i8x16_s", "i16x8.extadd_pairwise_i8x16_u", "i32x4.extadd_pairwise_i16x8_s", "i32x4.extadd_pairwise_i16x8_u", "i16x8.abs", "i16x8.neg", "i16x8.q15mulr_sat_s", "i16x8.all_true", "i16x8.bitmask", "i16x8.narrow_i32x4_s", "i16x8.narrow_i32x4_u", "i16x8.extend_low_i8x16_s", "i16x8.extend_high_i8x16_s", "i16x8.extend_low_i8x16_u", "i16x8.extend_high_i8x16_u", "i16x8.shl", "i16x8.shr_s", "i16x8.shr_u", "i16x8.add", "i16x8.add_sat_s", "i16x8.add_sat_u", "i16x8.sub", "i16x8.sub_sat_s", "i16x8.sub_sat_u", "f64x2.nearest", "i16x8.mul", "i16x8.min_s", "i16x8.min_u", "i16x8.max_s", "i16x8.max_u", undefined, "i16x8.avgr_u", "i16x8.extmul_low_i8x16_s", "i16x8.extmul_high_i8x16_s", "i16x8.extmul_low_i8x16_u", "i16x8.extmul_high_i8x16_u", "i32x4.abs", "i32x4.neg", undefined, "i32x4.all_true", "i32x4.bitmask", undefined, undefined, "i32x4.extend_low_i16x8_s", "i32x4.extend_high_i16x8_s", "i32x4.extend_low_i16x8_u", "i32x4.extend_high_i16x8_u", "i32x4.shl", "i32x4.shr_s", "i32x4.shr_u", "i32x4.add", undefined, undefined, "i32x4.sub", undefined, undefined, undefined, "i32x4.mul", "i32x4.min_s", "i32x4.min_u", "i32x4.max_s", "i32x4.max_u", "i32x4.dot_i16x8_s", undefined, "i32x4.extmul_low_i16x8_s", "i32x4.extmul_high_i16x8_s", "i32x4.extmul_low_i16x8_u", "i32x4.extmul_high_i16x8_u", "i64x2.abs", "i64x2.neg", undefined, "i64x2.all_true", "i64x2.bitmask", undefined, undefined, "i64x2.extend_low_i32x4_s", "i64x2.extend_high_i32x4_s", "i64x2.extend_low_i32x4_u", "i64x2.extend_high_i32x4_u", "i64x2.shl", "i64x2.shr_s", "i64x2.shr_u", "i64x2.add", undefined, undefined, "i64x2.sub", undefined, undefined, undefined, "i64x2.mul", "i64x2.eq", "i64x2.ne", "i64x2.lt_s", "i64x2.gt_s", "i64x2.le_s", "i64x2.ge_s", "i64x2.extmul_low_i32x4_s", "i64x2.extmul_high_i32x4_s", "i64x2.extmul_low_i32x4_u", "i64x2.extmul_high_i32x4_u", "f32x4.abs", "f32x4.neg", undefined, "f32x4.sqrt", "f32x4.add", "f32x4.sub", "f32x4.mul", "f32x4.div", "f32x4.min", "f32x4.max", "f32x4.pmin", "f32x4.pmax", "f64x2.abs", "f64x2.neg", undefined, "f64x2.sqrt", "f64x2.add", "f64x2.sub", "f64x2.mul", "f64x2.div", "f64x2.min", "f64x2.max", "f64x2.pmin", "f64x2.pmax", "i32x4.trunc_sat_f32x4_s", "i32x4.trunc_sat_f32x4_u", "f32x4.convert_i32x4_s", "f32x4.convert_i32x4_u", "i32x4.trunc_sat_f64x2_s_zero", "i32x4.trunc_sat_f64x2_u_zero", "f64x2.convert_low_i32x4_s", "f64x2.convert_low_i32x4_u", ].forEach((s, i) => { OperatorCodeNames[0xfd00 | i] = s; }); [ "atomic.notify", "i32.atomic.wait", "i64.atomic.wait", "atomic.fence", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, "i32.atomic.load", "i64.atomic.load", "i32.atomic.load8_u", "i32.atomic.load16_u", "i64.atomic.load8_u", "i64.atomic.load16_u", "i64.atomic.load32_u", "i32.atomic.store", "i64.atomic.store", "i32.atomic.store8", "i32.atomic.store16", "i64.atomic.store8", "i64.atomic.store16", "i64.atomic.store32", "i32.atomic.rmw.add", "i64.atomic.rmw.add", "i32.atomic.rmw8.add_u", "i32.atomic.rmw16.add_u", "i64.atomic.rmw8.add_u", "i64.atomic.rmw16.add_u", "i64.atomic.rmw32.add_u", "i32.atomic.rmw.sub", "i64.atomic.rmw.sub", "i32.atomic.rmw8.sub_u", "i32.atomic.rmw16.sub_u", "i64.atomic.rmw8.sub_u", "i64.atomic.rmw16.sub_u", "i64.atomic.rmw32.sub_u", "i32.atomic.rmw.and", "i64.atomic.rmw.and", "i32.atomic.rmw8.and_u", "i32.atomic.rmw16.and_u", "i64.atomic.rmw8.and_u", "i64.atomic.rmw16.and_u", "i64.atomic.rmw32.and_u", "i32.atomic.rmw.or", "i64.atomic.rmw.or", "i32.atomic.rmw8.or_u", "i32.atomic.rmw16.or_u", "i64.atomic.rmw8.or_u", "i64.atomic.rmw16.or_u", "i64.atomic.rmw32.or_u", "i32.atomic.rmw.xor", "i64.atomic.rmw.xor", "i32.atomic.rmw8.xor_u", "i32.atomic.rmw16.xor_u", "i64.atomic.rmw8.xor_u", "i64.atomic.rmw16.xor_u", "i64.atomic.rmw32.xor_u", "i32.atomic.rmw.xchg", "i64.atomic.rmw.xchg", "i32.atomic.rmw8.xchg_u", "i32.atomic.rmw16.xchg_u", "i64.atomic.rmw8.xchg_u", "i64.atomic.rmw16.xchg_u", "i64.atomic.rmw32.xchg_u", "i32.atomic.rmw.cmpxchg", "i64.atomic.rmw.cmpxchg", "i32.atomic.rmw8.cmpxchg_u", "i32.atomic.rmw16.cmpxchg_u", "i64.atomic.rmw8.cmpxchg_u", "i64.atomic.rmw16.cmpxchg_u", "i64.atomic.rmw32.cmpxchg_u", ].forEach((s, i) => { OperatorCodeNames[0xfe00 | i] = s; }); OperatorCodeNames[0xfb01] = "struct.new_with_rtt"; OperatorCodeNames[0xfb02] = "struct.new_default_with_rtt"; OperatorCodeNames[0xfb03] = "struct.get"; OperatorCodeNames[0xfb04] = "struct.get_s"; OperatorCodeNames[0xfb05] = "struct.get_u"; OperatorCodeNames[0xfb06] = "struct.set"; OperatorCodeNames[0xfb07] = "struct.new"; OperatorCodeNames[0xfb08] = "struct.new_default"; OperatorCodeNames[0xfb11] = "array.new_with_rtt"; OperatorCodeNames[0xfb12] = "array.new_default_with_rtt"; OperatorCodeNames[0xfb13] = "array.get"; OperatorCodeNames[0xfb14] = "array.get_s"; OperatorCodeNames[0xfb15] = "array.get_u"; OperatorCodeNames[0xfb16] = "array.set"; OperatorCodeNames[0xfb17] = "array.len"; OperatorCodeNames[0xfb18] = "array.copy"; OperatorCodeNames[0xfb19] = "array.init"; OperatorCodeNames[0xfb1a] = "array.init_static"; OperatorCodeNames[0xfb1b] = "array.new"; OperatorCodeNames[0xfb1c] = "array.new_default"; OperatorCodeNames[0xfb20] = "i31.new"; OperatorCodeNames[0xfb21] = "i31.get_s"; OperatorCodeNames[0xfb22] = "i31.get_u"; OperatorCodeNames[0xfb30] = "rtt.canon"; OperatorCodeNames[0xfb31] = "rtt.sub"; OperatorCodeNames[0xfb32] = "rtt.fresh_sub"; OperatorCodeNames[0xfb40] = "ref.test"; OperatorCodeNames[0xfb41] = "ref.cast"; OperatorCodeNames[0xfb42] = "br_on_cast"; OperatorCodeNames[0xfb43] = "br_on_cast_fail"; OperatorCodeNames[0xfb44] = "ref.test_static"; OperatorCodeNames[0xfb45] = "ref.cast_static"; OperatorCodeNames[0xfb46] = "br_on_cast_static"; OperatorCodeNames[0xfb47] = "br_on_cast_static_fail"; OperatorCodeNames[0xfb50] = "ref.is_func"; OperatorCodeNames[0xfb51] = "ref.is_data"; OperatorCodeNames[0xfb52] = "ref.is_i31"; OperatorCodeNames[0xfb58] = "ref.as_func"; OperatorCodeNames[0xfb59] = "ref.as_data"; OperatorCodeNames[0xfb5a] = "ref.as_i31"; OperatorCodeNames[0xfb60] = "br_on_func"; OperatorCodeNames[0xfb61] = "br_on_data"; OperatorCodeNames[0xfb62] = "br_on_i31"; OperatorCodeNames[0xfb63] = "br_on_non_func"; OperatorCodeNames[0xfb64] = "br_on_non_data"; OperatorCodeNames[0xfb65] = "br_on_non_i31"; export const enum ExternalKind { Function = 0, Table = 1, Memory = 2, Global = 3, Event = 4, } export const enum TypeKind { unspecified = 0, i32 = -0x01, i64 = -0x02, f32 = -0x03, f64 = -0x04, v128 = -0x05, i8 = -0x06, i16 = -0x07, funcref = -0x10, externref = -0x11, anyref = -0x12, eqref = -0x13, optref = -0x14, ref = -0x15, i31ref = -0x16, rtt_d = -0x17, // RTT with depth. rtt = -0x18, dataref = -0x19, func = -0x20, struct = -0x21, array = -0x22, func_subtype = -0x23, struct_subtype = -0x24, array_subtype = -0x25, empty_block_type = -0x40, } export class Type { kind: TypeKind; // Always present. index: number; // Only for reference types: ref, optref, rtt, rtt_d. depth: number; // Only for RTTs with depth. constructor(kind: TypeKind, index = -1, depth = -1) { if (kind < 0 || (kind === 0 && index >= 0)) { // all good } else { throw new Error(`invalid type: ${kind}/${index}/${depth}`); } this.kind = kind; this.index = index; this.depth = depth; // Canonicalize (ref any) to (anyref) etc. if ( (index === TypeKind.funcref && kind === TypeKind.optref) || (index === TypeKind.externref && kind === TypeKind.optref) || (index === TypeKind.anyref && kind === TypeKind.optref) || (index === TypeKind.eqref && kind === TypeKind.optref) || (index === TypeKind.i31ref && kind === TypeKind.ref) || (index === TypeKind.dataref && kind === TypeKind.ref) ) { this.kind = index; this.index = -1; } } // Convenience singletons. static funcref: Type = new Type(TypeKind.funcref); static externref: Type = new Type(TypeKind.externref); } export const enum RelocType { FunctionIndex_LEB = 0, TableIndex_SLEB = 1, TableIndex_I32 = 2, GlobalAddr_LEB = 3, GlobalAddr_SLEB = 4, GlobalAddr_I32 = 5, TypeIndex_LEB = 6, GlobalIndex_LEB = 7, } export const enum LinkingType { StackPointer = 1, } export const enum NameType { Module = 0, Function = 1, Local = 2, Event = 3, Type = 4, Table = 5, Memory = 6, Global = 7, Field = 10, } export const enum BinaryReaderState { ERROR = -1, INITIAL = 0, BEGIN_WASM = 1, END_WASM = 2, BEGIN_SECTION = 3, END_SECTION = 4, SKIPPING_SECTION = 5, READING_SECTION_RAW_DATA = 6, SECTION_RAW_DATA = 7, TYPE_SECTION_ENTRY = 11, IMPORT_SECTION_ENTRY = 12, FUNCTION_SECTION_ENTRY = 13, TABLE_SECTION_ENTRY = 14, MEMORY_SECTION_ENTRY = 15, GLOBAL_SECTION_ENTRY = 16, EXPORT_SECTION_ENTRY = 17, DATA_SECTION_ENTRY = 18, NAME_SECTION_ENTRY = 19, ELEMENT_SECTION_ENTRY = 20, LINKING_SECTION_ENTRY = 21, START_SECTION_ENTRY = 22, EVENT_SECTION_ENTRY = 23, BEGIN_INIT_EXPRESSION_BODY = 25, INIT_EXPRESSION_OPERATOR = 26, END_INIT_EXPRESSION_BODY = 27, BEGIN_FUNCTION_BODY = 28, READING_FUNCTION_HEADER = 29, CODE_OPERATOR = 30, END_FUNCTION_BODY = 31, SKIPPING_FUNCTION_BODY = 32, BEGIN_ELEMENT_SECTION_ENTRY = 33, ELEMENT_SECTION_ENTRY_BODY = 34, END_ELEMENT_SECTION_ENTRY = 35, BEGIN_DATA_SECTION_ENTRY = 36, DATA_SECTION_ENTRY_BODY = 37, END_DATA_SECTION_ENTRY = 38, BEGIN_GLOBAL_SECTION_ENTRY = 39, END_GLOBAL_SECTION_ENTRY = 40, RELOC_SECTION_HEADER = 41, RELOC_SECTION_ENTRY = 42, SOURCE_MAPPING_URL = 43, BEGIN_OFFSET_EXPRESSION_BODY = 44, OFFSET_EXPRESSION_OPERATOR = 45, END_OFFSET_EXPRESSION_BODY = 46, } const enum DataSegmentType { Active = 0x00, Passive = 0x01, ActiveWithMemoryIndex = 0x02, } function isActiveDataSegmentType(segmentType: number): boolean { switch (segmentType) { case DataSegmentType.Active: case DataSegmentType.ActiveWithMemoryIndex: return true; default: return false; } } export const enum DataMode { Active, Passive, } const enum ElementSegmentType { LegacyActiveFuncrefExternval = 0x00, PassiveExternval = 0x01, ActiveExternval = 0x02, DeclaredExternval = 0x03, LegacyActiveFuncrefElemexpr = 0x04, PassiveElemexpr = 0x05, ActiveElemexpr = 0x06, DeclaredElemexpr = 0x07, } function isActiveElementSegmentType(segmentType: number): boolean { switch (segmentType) { case ElementSegmentType.LegacyActiveFuncrefExternval: case ElementSegmentType.ActiveExternval: case ElementSegmentType.LegacyActiveFuncrefElemexpr: case ElementSegmentType.ActiveElemexpr: return true; default: return false; } } function isExternvalElementSegmentType(segmentType: number): boolean { switch (segmentType) { case ElementSegmentType.LegacyActiveFuncrefExternval: case ElementSegmentType.PassiveExternval: case ElementSegmentType.ActiveExternval: case ElementSegmentType.DeclaredExternval: return true; default: return false; } } export const enum ElementMode { Active, Passive, Declarative, } class DataRange { start: number; end: number; constructor(start: number, end: number) { this.start = start; this.end = end; } offset(delta: number) { this.start += delta; this.end += delta; } } export interface IModuleHeader { magicNumber: number; version: number; } export interface IResizableLimits { initial: number; maximum?: number; } export interface ITableType { elementType: Type; limits: IResizableLimits; } export interface IMemoryType { limits: IResizableLimits; shared: boolean; } export interface IGlobalType { contentType: Type; mutability: number; } export interface IEventType { attribute: number; typeIndex: number; } export interface IGlobalVariable { type: IGlobalType; } export interface IElementSegment { mode: ElementMode; tableIndex?: number; } export interface IElementSegmentBody { elementType: Type; } export interface IDataSegment { mode: DataMode; memoryIndex?: number; } export interface IDataSegmentBody { data: Uint8Array; } export type ImportEntryType = | ITableType | IMemoryType | IGlobalType | IEventType; export interface IImportEntry { module: Uint8Array; field: Uint8Array; kind: ExternalKind; funcTypeIndex?: number; type?: ImportEntryType; } export interface IExportEntry { field: Uint8Array; kind: ExternalKind; index: number; } export interface INameEntry { type: NameType; } export interface INaming { index: number; name: Uint8Array; } export interface IModuleNameEntry extends INameEntry { moduleName: Uint8Array; } export interface IFunctionNameEntry extends INameEntry { names: INaming[]; } export interface ILocalName { index: number; locals: INaming[]; } export interface ILocalNameEntry extends INameEntry { funcs: ILocalName[]; } export interface IEventNameEntry extends INameEntry { names: INaming[]; } export interface ITypeNameEntry extends INameEntry { names: INaming[]; } export interface ITableNameEntry extends INameEntry { names: INaming[]; } export interface IMemoryNameEntry extends INameEntry { names: INaming[]; } export interface IGlobalNameEntry extends INameEntry { names: INaming[]; } export interface IFieldName { index: number; fields: INaming[]; } export interface IFieldNameEntry extends INameEntry { types: IFieldName[]; } export interface ILinkingEntry { type: LinkingType; index?: number; } export interface IRelocHeader { id: SectionCode; name: Uint8Array; } export interface IRelocEntry { type: RelocType; offset: number; index: number; addend?: number; } export interface ISourceMappingURL { url: Uint8Array; } export interface IStartEntry { index: number; } export interface IFunctionEntry { typeIndex: number; } export interface ITypeEntry { // func | struct | array | func_subtype | struct_subtype | array_subtype form: number; params?: Type[]; // For function types. returns?: Type[]; // For function types. fields?: Type[]; // For struct types. mutabilities?: boolean[]; // For struct types. elementType?: Type; // For array types. mutability?: boolean; // For array types. supertype?: number; // For *_subtype types. } export interface ISectionInformation { id: SectionCode; name: Uint8Array; } export interface ILocals { count: number; type: Type; } export interface IFunctionInformation { locals: Array<ILocals>; } export interface IMemoryAddress { flags: number; offset: number; } export interface IOperatorInformation { code: OperatorCode; blockType?: Type; selectType?: Type; refType?: number; // "HeapType" format, a.k.a. s33 srcType?: number; // "HeapType" format, a.k.a. s33 brDepth?: number; brTable?: Array<number>; relativeDepth?: number; funcIndex?: number; typeIndex?: number; tableIndex?: number; localIndex?: number; fieldIndex?: number; globalIndex?: number; segmentIndex?: number; eventIndex?: number; destinationIndex?: number; memoryAddress?: IMemoryAddress; literal?: number | Int64 | Uint8Array; lines: Uint8Array; lineIndex: number; } export class Int64 { private _data: Uint8Array; constructor(data: Uint8Array) { this._data = data || new Uint8Array(8); } public toInt32(): number { return ( this._data[0] | (this._data[1] << 8) | (this._data[2] << 16) | (this._data[3] << 24) ); } public toDouble(): number { var power = 1; var sum; if (this._data[7] & 0x80) { sum = -1; for (var i = 0; i < 8; i++, power *= 256) sum -= power * (0xff ^ this._data[i]); } else { sum = 0; for (var i = 0; i < 8; i++, power *= 256) sum += power * this._data[i]; } return sum; } public toString(): string { var low = (this._data[0] | (this._data[1] << 8) | (this._data[2] << 16) | (this._data[3] << 24)) >>> 0; var high = (this._data[4] | (this._data[5] << 8) | (this._data[6] << 16) | (this._data[7] << 24)) >>> 0; if (low === 0 && high === 0) { return "0"; } var sign = false; if (high >> 31) { high = 4294967296 - high; if (low > 0) { high--; low = 4294967296 - low; } sign = true; } var buf = []; while (high > 0) { var t = (high % 10) * 4294967296 + low; high = Math.floor(high / 10); buf.unshift((t % 10).toString()); low = Math.floor(t / 10); } while (low > 0) { buf.unshift((low % 10).toString()); low = Math.floor(low / 10); } if (sign) buf.unshift("-"); return buf.join(""); } public get data(): Uint8Array { return this._data; } } export type BinaryReaderResult = | IImportEntry | IExportEntry | IFunctionEntry | ITypeEntry | IModuleHeader | IOperatorInformation | IMemoryType | ITableType | IGlobalVariable | INameEntry | IElementSegment | IElementSegmentBody | IDataSegment | IDataSegmentBody | ISectionInformation | IFunctionInformation | ISectionInformation | IFunctionInformation | IRelocHeader | IRelocEntry | ILinkingEntry | ISourceMappingURL | IModuleNameEntry | IStartEntry | Uint8Array; export class BinaryReader { private _data: Uint8Array = null; private _pos = 0; private _length = 0; private _eof = false; public state: BinaryReaderState = BinaryReaderState.INITIAL; public result: BinaryReaderResult = null; public error: Error = null; private _sectionEntriesLeft = 0; private _sectionId: SectionCode = SectionCode.Unknown; private _sectionRange: DataRange = null; private _functionRange: DataRange = null; private _segmentType: DataSegmentType | ElementSegmentType = 0; private _segmentEntriesLeft = 0; public get data(): Uint8Array { return this._data; } public get position(): number { return this._pos; } public get length(): number { return this._length; } public setData( buffer: ArrayBuffer, pos: number, length: number, eof?: boolean ): void { var posDelta = pos - this._pos; this._data = new Uint8Array(buffer); this._pos = pos; this._length = length; this._eof = eof === undefined ? true : eof; if (this._sectionRange) this._sectionRange.offset(posDelta); if (this._functionRange) this._functionRange.offset(posDelta); } private hasBytes(n: number): boolean { return this._pos + n <= this._length; } public hasMoreBytes(): boolean { return this.hasBytes(1); } private readUint8(): number { return this._data[this._pos++]; } private readInt32(): number { var b1 = this._data[this._pos++]; var b2 = this._data[this._pos++]; var b3 = this._data[this._pos++]; var b4 = this._data[this._pos++]; return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24); } private readUint32(): number { return this.readInt32(); } private peekInt32(): number { var b1 = this._data[this._pos]; var b2 = this._data[this._pos + 1]; var b3 = this._data[this._pos + 2]; var b4 = this._data[this._pos + 3]; return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24); } private hasVarIntBytes(): boolean { var pos = this._pos; while (pos < this._length) { if ((this._data[pos++] & 0x80) == 0) return true; } return false; } private readVarUint1(): number { return this.readUint8(); } private readVarInt7(): number { return (this.readUint8() << 25) >> 25; } private readVarUint7(): number { return this.readUint8(); } private readVarInt32(): number { var result = 0; var shift = 0; while (true) { var byte = this.readUint8(); result |= (byte & 0x7f) << shift; shift += 7; if ((byte & 0x80) === 0) break; } if (shift >= 32) return result; var ashift = 32 - shift; return (result << ashift) >> ashift; } private readVarUint32(): number { var result = 0; var shift = 0; while (true) { var byte = this.readUint8(); result |= (byte & 0x7f) << shift; shift += 7; if ((byte & 0x80) === 0) break; } return result >>> 0; } private readVarInt64(): Int64 { var result = new Uint8Array(8); var i = 0; var c = 0; var shift = 0; while (true) { var byte = this.readUint8(); c |= (byte & 0x7f) << shift; shift += 7; if (shift > 8) { result[i++] = c & 0xff; c >>= 8; shift -= 8; } if ((byte & 0x80) === 0) break; } var ashift = 32 - shift; c = (c << ashift) >> ashift; while (i < 8) { result[i++] = c & 0xff; c >>= 8; } return new Int64(result); } // Reads any "s33" (signed 33-bit integer) value correctly; no guarantees // outside that range. private readHeapType(): number { var result = 0; var shift = 0; var byte: number; while (true) { byte = this.readUint8(); if (shift === 28) { var signed = (byte << 25) >> 25; return signed * Math.pow(2, 28) + result; } result |= (byte & 0x7f) << shift; shift += 7; if ((byte & 0x80) === 0) break; } shift = 32 - shift; return (result << shift) >> shift; } private readTypeInternal(kind: TypeKind): Type { if ( kind === TypeKind.ref || kind === TypeKind.optref || kind === TypeKind.rtt ) { var index = this.readHeapType(); return new Type(kind, index); } if (kind === TypeKind.rtt_d) { var index = this.readHeapType(); var depth = this.readVarUint32(); return new Type(kind, index, depth); } return new Type(kind); } private readType(): Type { var kind = this.readVarInt7(); return this.readTypeInternal(kind); } private readBlockType(): Type { var block_type = this.readHeapType(); if (block_type < 0) { return this.readTypeInternal(block_type); } var func_index = block_type; return new Type(TypeKind.unspecified, func_index); } private readStringBytes(): Uint8Array { var length = this.readVarUint32(); return this.readBytes(length); } private readBytes(length: number): Uint8Array { var result = this._data.subarray(this._pos, this._pos + length); this._pos += length; return new Uint8Array(result); // making a clone of the data } private skipBytes(length: number) { this._pos += length; } private hasStringBytes(): boolean { if (!this.hasVarIntBytes()) return false; var pos = this._pos; var length = this.readVarUint32(); var result = this.hasBytes(length); this._pos = pos; return result; } private hasSectionPayload(): boolean { return this.hasBytes(this._sectionRange.end - this._pos); } private readFuncType(): ITypeEntry { var paramCount = this.readVarUint32(); var paramTypes = new Array(paramCount); for (var i = 0; i < paramCount; i++) paramTypes[i] = this.readType(); var returnCount = this.readVarUint1(); var returnTypes = new Array(returnCount); for (var i = 0; i < returnCount; i++) returnTypes[i] = this.readType(); return { form: TypeKind.func, params: paramTypes, returns: returnTypes, }; } private readFuncSubtype(): ITypeEntry { var result = this.readFuncType(); result.form = TypeKind.func_subtype; result.supertype = this.readHeapType(); return result; } private readStructType(): ITypeEntry { var fieldCount = this.readVarUint32(); var fieldTypes = new Array(fieldCount); var fieldMutabilities = new Array(fieldCount); for (var i = 0; i < fieldCount; i++) { fieldTypes[i] = this.readType(); fieldMutabilities[i] = !!this.readVarUint1(); } return { form: TypeKind.struct, fields: fieldTypes, mutabilities: fieldMutabilities, }; } private readStructSubtype(): ITypeEntry { var result = this.readStructType(); result.form = TypeKind.struct_subtype; result.supertype = this.readHeapType(); return result; } private readArrayType(): ITypeEntry { var elementType = this.readType(); var mutability = !!this.readVarUint1(); return { form: TypeKind.array, elementType: elementType, mutability: mutability, }; } private readArraySubtype(): ITypeEntry { var result = this.readArrayType(); result.form = TypeKind.array_subtype; result.supertype = this.readHeapType(); return result; } private readResizableLimits(maxPresent: boolean): IResizableLimits { var initial = this.readVarUint32(); var maximum; if (maxPresent) { maximum = this.readVarUint32(); } return { initial: initial, maximum: maximum }; } private readTableType(): ITableType { var elementType = this.readType(); var flags = this.readVarUint32(); var limits = this.readResizableLimits(!!(flags & 0x01)); return { elementType: elementType, limits: limits }; } private readMemoryType(): IMemoryType { var flags = this.readVarUint32(); var shared = !!(flags & 0x02); return { limits: this.readResizableLimits(!!(flags & 0x01)), shared: shared, }; } private readGlobalType(): IGlobalType { if (!this.hasVarIntBytes()) { return null; } var pos = this._pos; var contentType = this.readType(); if (!this.hasVarIntBytes()) { this._pos = pos; return null; } var mutability = this.readVarUint1(); return { contentType: contentType, mutability: mutability }; } private readEventType(): IEventType { var attribute = this.readVarUint32(); var typeIndex = this.readVarUint32(); return { attribute: attribute, typeIndex: typeIndex, }; } private readTypeEntry() { if (this._sectionEntriesLeft === 0) { this.skipSection(); return this.read(); } this.state = BinaryReaderState.TYPE_SECTION_ENTRY; var form = this.readVarInt7(); switch (form) { case TypeKind.func: this.result = this.readFuncType(); break; case TypeKind.func_subtype: this.result = this.readFuncSubtype(); break; case TypeKind.struct: this.result = this.readStructType(); break; case TypeKind.struct_subtype: this.result = this.readStructSubtype(); break; case TypeKind.array: this.result = this.readArrayType(); break; case TypeKind.array_subtype: this.result = this.readArraySubtype(); break; default: throw new Error(`Unknown type kind: ${form}`); } this._sectionEntriesLeft--; return true; } private readImportEntry() { if (this._sectionEntriesLeft === 0) { this.skipSection(); return this.read(); } this.state = BinaryReaderState.IMPORT_SECTION_ENTRY; var module = this.readStringBytes(); var field = this.readStringBytes(); var kind = this.readUint8(); var funcTypeIndex: number; var type: ITableType | IMemoryType | IGlobalType | IEventType; switch (kind) { case ExternalKind.Function: funcTypeIndex = this.readVarUi