watr 3.3.0 → 4.0.0

package/src/const.js

@@ -1,77 +1,163 @@
 // https://webassembly.github.io/spec/core/appendix/index-instructions.html
+// Format: 'name' or 'name handler'
+// Immediate types: blocktype, labelidx, funcidx, typeidx, tableidx, memoryidx, globalidx, localidx, dataidx, elemidx, multi
+// Value types: i32, i64, f32, f64, v128
 export const INSTR = [
-  'unreachable', 'nop', 'block', 'loop', 'if', 'else', 'then', , , , ,
-  'end', 'br', 'br_if', 'br_table', 'return', 'call', 'call_indirect', 'return_call', 'return_call_indirect', 'call_ref', 'return_call_ref', , , , ,
-  'drop', 'select', '', , , ,
-  'local.get', 'local.set', 'local.tee', 'global.get', 'global.set', 'table.get', 'table.set', ,
-  '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',
-  'memory.size', 'memory.grow',
-  'i32.const', 'i64.const', 'f32.const', 'f64.const',
+  // 0x00-0x0a: control
+  'unreachable', 'nop', 'block block', 'loop block', 'if block', 'else null', 'then null', , 'throw tagidx', , 'throw_ref',
+  // 0x0b-0x19: control
+  'end end', 'br labelidx', 'br_if labelidx', 'br_table br_table', 'return', 'call funcidx', 'call_indirect call_indirect', 'return_call funcidx', 'return_call_indirect call_indirect', 'call_ref typeidx', 'return_call_ref typeidx', , , , ,
+  // 0x1a-0x1f: parametric
+  'drop', 'select select', '', , , 'try_table try_table',
+  // 0x20-0x27: variable
+  'local.get localidx', 'local.set localidx', 'local.tee localidx', 'global.get globalidx', 'global.set globalidx', 'table.get tableidx', 'table.set tableidx', ,
+  // 0x28-0x3e: memory
+  'i32.load memarg', 'i64.load memarg', 'f32.load memarg', 'f64.load memarg',
+  'i32.load8_s memarg', 'i32.load8_u memarg', 'i32.load16_s memarg', 'i32.load16_u memarg',
+  'i64.load8_s memarg', 'i64.load8_u memarg', 'i64.load16_s memarg', 'i64.load16_u memarg', 'i64.load32_s memarg', 'i64.load32_u memarg',
+  'i32.store memarg', 'i64.store memarg', 'f32.store memarg', 'f64.store memarg',
+  'i32.store8 memarg', 'i32.store16 memarg', 'i64.store8 memarg', 'i64.store16 memarg', 'i64.store32 memarg',
+  // 0x3f-0x40: memory size/grow
+  'memory.size opt_memory', 'memory.grow opt_memory',
+  // 0x41-0x44: const
+  'i32.const i32', 'i64.const i64', 'f32.const f32', 'f64.const f64',
+  // 0x45-0x4f: i32 comparison
   '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',
+  // 0x50-0x5a: i64 comparison
   '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',
+  // 0x5b-0x60: f32 comparison
   'f32.eq', 'f32.ne', 'f32.lt', 'f32.gt', 'f32.le', 'f32.ge',
+  // 0x61-0x66: f64 comparison
   'f64.eq', 'f64.ne', 'f64.lt', 'f64.gt', 'f64.le', 'f64.ge',
+  // 0x67-0x78: i32 arithmetic
   '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',
+  // 0x79-0x8a: i64 arithmetic
   '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',
+  // 0x8b-0x98: f32 arithmetic
   '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',
+  // 0x99-0xa6: f64 arithmetic
   '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',
+  // 0xa7-0xc4: conversions (no immediates)
   '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',
+  // 0xc0-0xc4: sign extension
   'i32.extend8_s', 'i32.extend16_s', 'i64.extend8_s', 'i64.extend16_s', 'i64.extend32_s', , , , , , , , , , , ,
-  'ref.null', 'ref.is_null', 'ref.func', 'ref.eq', 'ref.as_non_null', 'br_on_null', 'br_on_non_null', , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,
+  // 0xd0-0xd6: reference
+  'ref.null ref_null', 'ref.is_null', 'ref.func funcidx', 'ref.eq', 'ref.as_non_null', 'br_on_null labelidx', 'br_on_non_null labelidx',
+  // 0xd7-0xfa: padding to 0xfb (36 empty slots)
+  , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,
+  // 0xfb: GC instructions (nested array for multi-byte opcodes)
+  [
+    'struct.new typeidx', 'struct.new_default typeidx', 'struct.get typeidx_field', 'struct.get_s typeidx_field', 'struct.get_u typeidx_field', 'struct.set typeidx_field',
+    'array.new typeidx', 'array.new_default typeidx', 'array.new_fixed typeidx_multi', 'array.new_data typeidx_dataidx', 'array.new_elem typeidx_elemidx',
+    'array.get typeidx', 'array.get_s typeidx', 'array.get_u typeidx', 'array.set typeidx', 'array.len', 'array.fill typeidx', 'array.copy typeidx_typeidx',
+    'array.init_data typeidx_dataidx', 'array.init_elem typeidx_elemidx', 'ref.test reftype', '', 'ref.cast reftype', '', 'br_on_cast reftype2', 'br_on_cast_fail reftype2',
+    'any.convert_extern', 'extern.convert_any', 'ref.i31', 'i31.get_s', 'i31.get_u'
+  ],
 
-  // 0xFB 0xNN (0xFB shift)
-  'struct.new', 'struct.new_default', 'struct.get', 'struct.get_s', 'struct.get_u', 'struct.set', 'array.new', 'array.new_default', 'array.new_fixed', 'array.new_data', 'array.new_elem', 'array.get', 'array.get_s', 'array.get_u', 'array.set', 'array.len', 'array.fill', 'array.copy', 'array.init_data', 'array.init_elem', 'ref.test', '', 'ref.cast', '', 'br_on_cast', 'br_on_cast_fail', 'any.convert_extern', 'extern.convert_any', 'ref.i31', 'i31.get_s', 'i31.get_u', ,
+  // 0xfc: Bulk memory/table operations (nested array)
+  [
+    '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 dataidx_memoryidx', 'data.drop dataidx', 'memory.copy memoryidx_memoryidx', 'memory.fill memoryidx?',
+    'table.init reversed', 'elem.drop elemidx', 'table.copy tableidx_tableidx', 'table.grow tableidx', 'table.size tableidx', 'table.fill tableidx', ,
+    'i64.add128', 'i64.sub128', 'i64.mul_wide_s', 'i64.mul_wide_u'
+  ],
 
-  // 0xFC 0xNN (0x11b shift)
-  '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', ,
-  'i64.add128', 'i64.sub128', 'i64.mul_wide_s', 'i64.mul_wide_u', ,
+  // 0xfd: SIMD instructions (nested array)
+  [
+    'v128.load memarg', 'v128.load8x8_s memarg', 'v128.load8x8_u memarg', 'v128.load16x4_s memarg', 'v128.load16x4_u memarg',
+    'v128.load32x2_s memarg', 'v128.load32x2_u memarg', 'v128.load8_splat memarg', 'v128.load16_splat memarg', 'v128.load32_splat memarg',
+    'v128.load64_splat memarg', 'v128.store memarg', 'v128.const v128const', 'i8x16.shuffle shuffle',
+    'i8x16.swizzle', 'i8x16.splat', 'i16x8.splat', 'i32x4.splat', 'i64x2.splat', 'f32x4.splat', 'f64x2.splat',
+    'i8x16.extract_lane_s laneidx', 'i8x16.extract_lane_u laneidx', 'i8x16.replace_lane laneidx',
+    'i16x8.extract_lane_s laneidx', 'i16x8.extract_lane_u laneidx', 'i16x8.replace_lane laneidx',
+    'i32x4.extract_lane laneidx', 'i32x4.replace_lane laneidx', 'i64x2.extract_lane laneidx', 'i64x2.replace_lane laneidx',
+    'f32x4.extract_lane laneidx', 'f32x4.replace_lane laneidx', 'f64x2.extract_lane laneidx', 'f64x2.replace_lane laneidx',
+    '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 memlane', 'v128.load16_lane memlane', 'v128.load32_lane memlane', 'v128.load64_lane memlane',
+    'v128.store8_lane memlane', 'v128.store16_lane memlane', 'v128.store32_lane memlane', 'v128.store64_lane memlane',
+    'v128.load32_zero memarg', 'v128.load64_zero memarg', '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', , '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', , 'i32x4.all_true', 'i32x4.bitmask', , , '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', , , 'i32x4.sub', , , ,
+    'i32x4.mul', 'i32x4.min_s', 'i32x4.min_u', 'i32x4.max_s', 'i32x4.max_u', 'i32x4.dot_i16x8_s', ,
+    'i32x4.extmul_low_i16x8_s', 'i32x4.extmul_high_i16x8_s', 'i32x4.extmul_low_i16x8_u', 'i32x4.extmul_high_i16x8_u',
+    'i64x2.abs', 'i64x2.neg', , 'i64x2.all_true', 'i64x2.bitmask', , , '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', , , 'i64x2.sub', , , ,
+    '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', , 'f32x4.sqrt', 'f32x4.add', 'f32x4.sub', 'f32x4.mul', 'f32x4.div', 'f32x4.min', 'f32x4.max', 'f32x4.pmin', 'f32x4.pmax',
+    'f64x2.abs', 'f64x2.neg', , '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',
+    'i8x16.relaxed_swizzle', 'i32x4.relaxed_trunc_f32x4_s', 'i32x4.relaxed_trunc_f32x4_u', 'i32x4.relaxed_trunc_f64x2_s_zero',
+    'i32x4.relaxed_trunc_f64x2_u_zero', 'f32x4.relaxed_madd', 'f32x4.relaxed_nmadd', 'f64x2.relaxed_madd', 'f64x2.relaxed_nmadd',
+    'i8x16.relaxed_laneselect', 'i16x8.relaxed_laneselect', 'i32x4.relaxed_laneselect', 'i64x2.relaxed_laneselect',
+    'f32x4.relaxed_min', 'f32x4.relaxed_max', 'f64x2.relaxed_min', 'f64x2.relaxed_max',
+    'i16x8.relaxed_q15mulr_s', 'i16x8.relaxed_dot_i8x16_i7x16_s', 'i32x4.relaxed_dot_i8x16_i7x16_add_s'
+  ],
+  // 0xfe: atomic/thread instructions
+  [
+    'memory.atomic.notify memarg', 'memory.atomic.wait32 memarg', 'memory.atomic.wait64 memarg', 'atomic.fence opt_memory',
+    ,,,,,,,,,,,,
+    'i32.atomic.load memarg', 'i64.atomic.load memarg', 'i32.atomic.load8_u memarg', 'i32.atomic.load16_u memarg',
+    'i64.atomic.load8_u memarg', 'i64.atomic.load16_u memarg', 'i64.atomic.load32_u memarg', 'i32.atomic.store memarg',
+    'i64.atomic.store memarg', 'i32.atomic.store8 memarg', 'i32.atomic.store16 memarg', 'i64.atomic.store8 memarg',
+    'i64.atomic.store16 memarg', 'i64.atomic.store32 memarg', 'i32.atomic.rmw.add memarg', 'i64.atomic.rmw.add memarg',
+    'i32.atomic.rmw8.add_u memarg', 'i32.atomic.rmw16.add_u memarg', 'i64.atomic.rmw8.add_u memarg', 'i64.atomic.rmw16.add_u memarg',
+    'i64.atomic.rmw32.add_u memarg', 'i32.atomic.rmw.sub memarg', 'i64.atomic.rmw.sub memarg', 'i32.atomic.rmw8.sub_u memarg',
+    'i32.atomic.rmw16.sub_u memarg', 'i64.atomic.rmw8.sub_u memarg', 'i64.atomic.rmw16.sub_u memarg', 'i64.atomic.rmw32.sub_u memarg',
+    'i32.atomic.rmw.and memarg', 'i64.atomic.rmw.and memarg', 'i32.atomic.rmw8.and_u memarg', 'i32.atomic.rmw16.and_u memarg',
+    'i64.atomic.rmw8.and_u memarg', 'i64.atomic.rmw16.and_u memarg', 'i64.atomic.rmw32.and_u memarg', 'i32.atomic.rmw.or memarg',
+    'i64.atomic.rmw.or memarg', 'i32.atomic.rmw8.or_u memarg', 'i32.atomic.rmw16.or_u memarg', 'i64.atomic.rmw8.or_u memarg',
+    'i64.atomic.rmw16.or_u memarg', 'i64.atomic.rmw32.or_u memarg', 'i32.atomic.rmw.xor memarg', 'i64.atomic.rmw.xor memarg',
+    'i32.atomic.rmw8.xor_u memarg', 'i32.atomic.rmw16.xor_u memarg', 'i64.atomic.rmw8.xor_u memarg', 'i64.atomic.rmw16.xor_u memarg',
+    'i64.atomic.rmw32.xor_u memarg', 'i32.atomic.rmw.xchg memarg', 'i64.atomic.rmw.xchg memarg', 'i32.atomic.rmw8.xchg_u memarg',
+    'i32.atomic.rmw16.xchg_u memarg', 'i64.atomic.rmw8.xchg_u memarg', 'i64.atomic.rmw16.xchg_u memarg', 'i64.atomic.rmw32.xchg_u memarg',
+    'i32.atomic.rmw.cmpxchg memarg', 'i64.atomic.rmw.cmpxchg memarg', 'i32.atomic.rmw8.cmpxchg_u memarg', 'i32.atomic.rmw16.cmpxchg_u memarg',
+    'i64.atomic.rmw8.cmpxchg_u memarg', 'i64.atomic.rmw16.cmpxchg_u memarg', 'i64.atomic.rmw32.cmpxchg_u memarg'
+  ]
+]
 
-  // 0xFD 0xNN (0x133 shift)
-  'v128.load', 'v128.load8x8_s', 'v128.load8x8_u', 'v128.load16x4_s', 'v128.load16x4_u', 'v128.load32x2_s', 'v128.load32x2_u', 'v128.load8_splat', 'v128.load16_splat', 'v128.load32_splat', 'v128.load64_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', , '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', , 'i32x4.all_true', 'i32x4.bitmask', , , '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', , , 'i32x4.sub', , , , 'i32x4.mul', 'i32x4.min_s', 'i32x4.min_u', 'i32x4.max_s', 'i32x4.max_u', 'i32x4.dot_i16x8_s', , 'i32x4.extmul_low_i16x8_s', 'i32x4.extmul_high_i16x8_s', 'i32x4.extmul_low_i16x8_u', 'i32x4.extmul_high_i16x8_u', 'i64x2.abs', 'i64x2.neg', , 'i64x2.all_true', 'i64x2.bitmask', , , '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', , , 'i64x2.sub', , , , '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', , 'f32x4.sqrt', 'f32x4.add', 'f32x4.sub', 'f32x4.mul', 'f32x4.div', 'f32x4.min', 'f32x4.max', 'f32x4.pmin', 'f32x4.pmax', 'f64x2.abs', 'f64x2.neg', , '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',
-  // relaxed SIMD instructions
-  'i8x16.relaxed_swizzle', 'i32x4.relaxed_trunc_f32x4_s', 'i32x4.relaxed_trunc_f32x4_u', 'i32x4.relaxed_trunc_f64x2_s_zero', 'i32x4.relaxed_trunc_f64x2_u_zero', 'f32x4.relaxed_madd', 'f32x4.relaxed_nmadd', 'f64x2.relaxed_madd', 'f64x2.relaxed_nmadd', 'i8x16.relaxed_laneselect', 'i16x8.relaxed_laneselect', 'i32x4.relaxed_laneselect', 'i64x2.relaxed_laneselect', 'f32x4.relaxed_min', 'f32x4.relaxed_max', 'f64x2.relaxed_min', 'f64x2.relaxed_max', 'i16x8.relaxed_q15mulr_s', 'i16x8.relaxed_dot_i8x16_i7x16_s', 'i32x4.relaxed_dot_i8x16_i7x16_add_s'
-],
-  SECTION = { custom: 0, type: 1, import: 2, func: 3, table: 4, memory: 5, global: 6, tag: 13, export: 7, start: 8, elem: 9, datacount: 12, code: 10, data: 11 },
-  RECTYPE = { sub: 0x50, subfinal: 0x4F, rec: 0x4E },
-  DEFTYPE = { func: 0x60, struct: 0x5F, array: 0x5E, ...RECTYPE },
-  HEAPTYPE = { nofunc: 0x73, noextern: 0x72, noexn: 0x74, none: 0x71, func: 0x70, extern: 0x6F, exn: 0x75, any: 0x6E, eq: 0x6D, i31: 0x6C, struct: 0x6B, array: 0x6A },
-  REFTYPE = {
-    // absheaptype abbrs
-    nullfuncref: HEAPTYPE.nofunc,
-    nullexternref: HEAPTYPE.noextern,
-    nullexnref: HEAPTYPE.noexn,
-    nullref: HEAPTYPE.none,
-    funcref: HEAPTYPE.func,
-    externref: HEAPTYPE.extern,
-    exnref: HEAPTYPE.exn,
-    anyref: HEAPTYPE.any,
-    eqref: HEAPTYPE.eq,
-    i31ref: HEAPTYPE.i31,
-    structref: HEAPTYPE.struct,
-    arrayref: HEAPTYPE.array,
+// Binary section type codes
+export const SECTION = { custom: 0, type: 1, import: 2, func: 3, table: 4, memory: 5, tag: 13, global: 6, export: 7, start: 8, elem: 9, datacount: 12, code: 10, data: 11 }
 
-    // ref, refnull
-    ref: 0x64 /* -0x1c */, refnull: 0x63 /* -0x1d */
-  },
-  TYPE = { i8: 0x78, i16: 0x77, i32: 0x7f, i64: 0x7e, f32: 0x7d, f64: 0x7c, void: 0x40, v128: 0x7B, ...HEAPTYPE, ...REFTYPE },
-  KIND = { func: 0, table: 1, memory: 2, global: 3, tag: 4 },
-  // WAT escape codes: https://webassembly.github.io/spec/core/text/values.html#strings
-  ESCAPE = { n: 10, r: 13, t: 9, v: 11, '"': 34, "'": 39, '\\': 92 }
+// Type codes
+export const TYPE = {
+  // Value types
+  i8: 0x78, i16: 0x77, i32: 0x7f, i64: 0x7e, f32: 0x7d, f64: 0x7c, void: 0x40, v128: 0x7B,
+  // Heap types
+  exn: 0x69, noexn: 0x74, nofunc: 0x73, noextern: 0x72, none: 0x71, func: 0x70, extern: 0x6F, any: 0x6E, eq: 0x6D, i31: 0x6C, struct: 0x6B, array: 0x6A,
+  // Reference type abbreviations (absheaptype abbrs)
+  nullfuncref: 0x73, nullexternref: 0x72, nullexnref: 0x74, nullref: 0x71,
+  funcref: 0x70, externref: 0x6F, exnref: 0x69, anyref: 0x6E, eqref: 0x6D, i31ref: 0x6C, structref: 0x6B, arrayref: 0x6A,
+  // ref, refnull
+  ref: 0x64, // -0x1c
+  refnull: 0x63, // -0x1d
+  // Recursion group / type definition opcodes
+  sub: 0x50, subfinal: 0x4F, rec: 0x4E
+}
+
+// Type definition codes (different from heap types - func is 0x60 not 0x70)
+export const DEFTYPE = { func: 0x60, struct: 0x5F, array: 0x5E, sub: 0x50, subfinal: 0x4F, rec: 0x4E }
+
+// Import/export kind codes
+export const KIND = { func: 0, table: 1, memory: 2, global: 3, tag: 4 }

package/src/encode.js

@@ -1,40 +1,75 @@
-import { err, intRE, sepRE } from './util.js'
+/**
+ * Binary encoding utilities for WebAssembly.
+ * @module encode
+ * @see https://webassembly.github.io/spec/core/binary/values.html
+ */
 
-// encoding ref: https://github.com/j-s-n/WebBS/blob/master/compiler/byteCode.js
+import { err, intRE, sepRE } from './util.js'
 
-// uleb
+/**
+ * Encode unsigned LEB128. Handles both 32-bit numbers and 64-bit BigInts.
+ *
+ * @param {number|bigint|string|null} n - Value to encode
+ * @param {number[]} [buffer=[]] - Output buffer
+ * @returns {number[]} Encoded bytes
+ */
 export const uleb = (n, buffer = []) => {
   if (n == null) return buffer
-  if (typeof n === 'string') n = i32.parse(n)
+  if (typeof n === 'string') n = /[_x]/i.test(n) ? BigInt(n.replaceAll('_', '')) : i32.parse(n)
+
+  // Handle BigInt for 64-bit values
+  if (typeof n === 'bigint') {
+    while (true) {
+      const byte = Number(n & 0x7Fn)
+      n >>= 7n
+      if (n === 0n) {
+        buffer.push(byte)
+        break
+      }
+      buffer.push(byte | 0x80)
+    }
+    return buffer
+  }
 
-  let byte = n & 0b01111111;
-  n = n >>> 7;
+  // Handle regular numbers for 32-bit values
+  let byte = n & 0x7f
+  n >>>= 7
 
   if (n === 0) {
-    buffer.push(byte);
-    return buffer;
-  } else {
-    buffer.push(byte | 0b10000000);
-    return uleb(n, buffer);
+    buffer.push(byte)
+    return buffer
+  }
+  buffer.push(byte | 0x80)
+  return uleb(n, buffer)
+}
+
+/**
+ * Encode as fixed-width 5-byte ULEB128 (canonical form).
+ * Used by some tools for predictable binary layout.
+ *
+ * @param {number} value - 32-bit unsigned value
+ * @returns {number[]} 5-byte array
+ */
+export function uleb5(value) {
+  const result = [];
+  for (let i = 0; i < 5; i++) {
+    let byte = value & 0x7f;
+    value >>>= 7;
+    if (i < 4) {
+      byte |= 0x80; // Set continuation bit for first 4 bytes
+    }
+    result.push(byte);
   }
+  return result;
 }
 
-// fixed-width uleb
-// export function full_uleb(value) {
-//   const result = [];
-//   for (let i = 0; i < 5; i++) {
-//     let byte = value & 0x7f;
-//     value >>>= 7;
-//     if (i < 4) {
-//       byte |= 0x80; // Set continuation bit for first 4 bytes
-//     }
-//     result.push(byte);
-//   }
-//   return result;
-// }
-
-
-// leb
+/**
+ * Encode signed LEB128 for i32 values.
+ *
+ * @param {number|string} n - Signed 32-bit value
+ * @param {number[]} [buffer=[]] - Output buffer
+ * @returns {number[]} Encoded bytes
+ */
 export function i32(n, buffer = []) {
   if (typeof n === 'string') n = i32.parse(n)
 
@@ -56,9 +91,19 @@ const cleanInt = (v) => (!sepRE.test(v) && intRE.test(v=v.replaceAll('_',''))) ?
 // alias
 export const i8 = i32, i16 = i32
 
-i32.parse = n => parseInt(cleanInt(n))
+i32.parse = n => {
+  n = parseInt(cleanInt(n))
+  if (n < -0x80000000 || n > 0xffffffff) err(`i32 constant out of range`)
+  return n
+}
 
-// bigleb
+/**
+ * Encode signed LEB128 for i64 values (BigInt).
+ *
+ * @param {bigint|string} n - Signed 64-bit value
+ * @param {number[]} [buffer=[]] - Output buffer
+ * @returns {number[]} Encoded bytes
+ */
 export function i64(n, buffer = []) {
   if (typeof n === 'string') n = i64.parse(n)
 
@@ -76,6 +121,7 @@ export function i64(n, buffer = []) {
 i64.parse = n => {
   n = cleanInt(n)
   n = n[0] === '-' ? -BigInt(n.slice(1)) : BigInt(n) // can be -0x123
+  if (n < -0x8000000000000000n || n > 0xffffffffffffffffn) err(`i64 constant out of range`)
   byteView.setBigInt64(0, n)
   return byteView.getBigInt64(0)
 }
@@ -84,7 +130,7 @@ const byteView = new DataView(new Float64Array(1).buffer)
 
 const F32_SIGN = 0x80000000, F32_NAN = 0x7f800000
 export function f32(input, value, idx) {
-  if (~(idx = input.indexOf('nan:'))) {
+  if (typeof input === 'string' && ~(idx = input.indexOf('nan:'))) {
     value = i32.parse(input.slice(idx + 4))
     value |= F32_NAN
     if (input[0] === '-') value |= F32_SIGN
@@ -105,7 +151,7 @@ export function f32(input, value, idx) {
 
 const F64_SIGN = 0x8000000000000000n, F64_NAN = 0x7ff0000000000000n
 export function f64(input, value, idx) {
-  if (~(idx = input.indexOf('nan:'))) {
+  if (typeof input === 'string' && ~(idx = input.indexOf('nan:'))) {
     value = i64.parse(input.slice(idx + 4))
     value |= F64_NAN
     if (input[0] === '-') value |= F64_SIGN
@@ -141,12 +187,20 @@ f64.parse = (input, max=Number.MAX_VALUE) => {
     let [int, fract=''] = sig.split('.'); // integer and fractional parts
     let flen = fract.length ?? 0;
 
-    // FIXME: this is not accurate, it must be byte-perfect
-    sig = parseInt(int + fract); // 0x is included in int
-    exp = parseInt(exp, 10);
+    // Parse integer part
+    let intVal = parseInt(int); // 0x is included in int
+    isNaN(intVal) && err()
 
     // 0x10a.fbc = 0x10afbc * 16⁻³ = 266.9833984375
-    let value = sign * sig * (2 ** (exp - 4 * flen));
+    // Parse fractional part: fract / 16^flen
+    // For better precision, parse as (int + fract) / 16^flen then multiply by 16^flen for int part
+    // Equivalent to: intVal + parseInt('0x' + fract) / 16^flen
+    let fractVal = fract ? parseInt('0x' + fract) / (16 ** flen) : 0;
+
+    exp = parseInt(exp, 10);
+
+    // Combine: (int + fract) * 2^exp
+    let value = sign * (intVal + fractVal) * (2 ** exp);
 
     // make sure it is not Infinity
     value = Math.max(-max, Math.min(max, value))

package/src/parse.js

@@ -1,51 +1,60 @@
-import { unescape } from "./util.js"
-
-const OPAREN = 40, CPAREN = 41, OBRACK = 91, CBRACK = 93, SPACE = 32, DQUOTE = 34, PERIOD = 46,
-  _0 = 48, _9 = 57, SEMIC = 59, NEWLINE = 32, PLUS = 43, MINUS = 45, COLON = 58, BACKSLASH = 92, AT = 64
-
+import { err } from "./util.js"
 
 /**
  * Parses a wasm text string and constructs a nested array structure (AST).
+ * Each array node has `.i` property with source offset for error reporting.
  *
  * @param {string} str - The input string with WAT code to parse.
- * @param {object} options - Parse options, like comments, etc.
  * @returns {Array} An array representing the nested syntax tree (AST).
  */
-export default (str, o={ comments: false }) => {
-  let i = 0, level = [], buf = '', comment = ''
-
-  const commit = () => buf && (
-    level.push(buf),
-    buf = ''
-  )
+export default (str) => {
+  let i = 0, level = [], buf = '', q = 0, depth = 0
 
-  const parseLevel = () => {
-    for (let c, root, q, id; i < str.length;) {
+  const commit = () => buf && (level.push(buf), buf = '')
 
+  const parseLevel = (pos) => {
+    level.i = pos // store start position for error reporting
+    for (let c, root, p; i < str.length;) {
       c = str.charCodeAt(i)
-      if (q) {
+
+      // inside "..." or $"..."
+      if (q === 34) (buf += str[i++], c === 92 ? buf += str[i++] : c === 34 && (commit(), q = 0))
+      // inside (; ... ;) with nesting support (q=60 means depth 1, q=61 means depth 2, etc)
+      else if (q > 59) (
+        c === 40 && str.charCodeAt(i + 1) === 59 ? (q++, buf += str[i++] + str[i++]) : // nested (;
+        c === 59 && str.charCodeAt(i + 1) === 41 ? (buf += str[i++] + str[i++], --q === 59 && (commit(), q = 0)) : // ;)
         buf += str[i++]
-        if (c === BACKSLASH) buf += str[i++]
-        else if (c === DQUOTE) id && (buf = '$' + unescape(buf)), commit(), q = id = 0
-      }
-      else if (c === DQUOTE) {
-        q = c, id = buf == '$', !id && commit(), buf = '"', i++
-      }
-      else if (c === OPAREN) {
-        if (str.charCodeAt(i + 1) === SEMIC) comment = str.slice(i, i = str.indexOf(';)', i) + 2), o.comments && level.push(comment) // (; ... ;)
-        else if (str.charCodeAt(i + 1) === AT) commit(), i += 2, buf = '@', (root = level).push(level = []), parseLevel(), level = root // (@annotid ...)
-        else commit(), i++, (root = level).push(level = []), parseLevel(), level = root
-      }
-      else if (c === SEMIC && str.charCodeAt(i + 1) === SEMIC) comment = str.slice(i, i = str.indexOf('\n', i) + 1 || str.length), o.comments && level.push(comment)  // ;; ...
-      else if (c <= SPACE) commit(), i++
-      else if (c === CPAREN) return commit(), i++
+      )
+      // inside ;; ...\n
+      else if (q < 0) (c === 10 || c === 13 ? (buf += str[i++], commit(), q = 0) : buf += str[i++])
+      // start "
+      else if (c === 34) (buf !== '$' && commit(), q = 34, buf += str[i++])
+      // start (;
+      else if (c === 40 && str.charCodeAt(i + 1) === 59) (commit(), q = 60, buf = str[i++] + str[i++])
+      // start ;;
+      else if (c === 59 && str.charCodeAt(i + 1) === 59) (commit(), q = -1, buf = str[i++] + str[i++])
+      // start (@
+      else if (c === 40 && str.charCodeAt(i + 1) === 64) (commit(), p = i, i += 2, buf = '@', depth++, (root = level).push(level = []), parseLevel(p), level = root)
+      // start (
+      else if (c === 40) (commit(), p = i++, depth++, (root = level).push(level = []), parseLevel(p), level = root)
+      // end )
+      else if (c === 41) return commit(), i++, depth--
+      // whitespace
+      else if (c <= 32) (commit(), i++)
+      // other
       else buf += str[i++]
     }
 
+    q < 0 && commit() // trailing line comment
     commit()
   }
 
-  parseLevel()
+  parseLevel(0)
+
+  if (q === 34) err(`Unclosed quote`, i)
+  if (q > 59) err(`Unclosed block comment`, i)
+  if (depth > 0) err(`Unclosed parenthesis`, i)
+  if (i < str.length) err(`Unexpected closing parenthesis`, i)
 
-  return level.length > 1 ? level : level[0]
+  return level.length > 1 ? level : level[0] || []
 }

package/src/print.js

@@ -8,44 +8,105 @@ import parse from './parse.js';
  * @param {Object} [options={}] - Optional settings for printing.
  * @param {string} [options.indent='  '] - The string used for one level of indentation. Defaults to two spaces.
  * @param {string} [options.newline='\n'] - The string used for line breaks. Defaults to a newline character.
+ * @param {boolean} [options.comments=false] - Whether to include comments in the output. Defaults to false.
  * @returns {string} The formatted WAT string.
  */
 export default function print(tree, options = {}) {
   if (typeof tree === 'string') tree = parse(tree);
 
-  let { indent='  ', newline='\n' } = options;
+  let { indent='  ', newline='\n', comments=true } = options;
   indent ||= '', newline ||= ''; // false -> str
 
-  return typeof tree[0] === 'string' ? printNode(tree) : tree.map(node => printNode(node)).join(newline)
+  // If tree[0] is a string but NOT starting with `;` (comment), it's a keyword like `module` - print as single node
+  // Otherwise it's multiple nodes (comments + module) - print each separately
+  if (typeof tree[0] === 'string' && tree[0][0] !== ';') return printNode(tree)
+
+  // Multiple top-level nodes - filter out comments if comments option is false
+  return tree
+    .filter(node => comments || !isComment(node))
+    .map(node => printNode(node))
+    .join(newline)
+
+  function isComment(node) {
+    return typeof node === 'string' && node[1] === ';'
+  }
 
   function printNode(node, level = 0) {
     if (!Array.isArray(node)) return node
 
     let content = node[0]
+    if (!content) return ''
+    let afterLineComment = false // track if we just printed a line comment
+
+    // Special handling for try_table: keep catch clauses inline
+    if (content === 'try_table') {
+      let i = 1
+      // Add label if present
+      if (typeof node[i] === 'string' && node[i][0] === '$') content += ' ' + node[i++]
+      // Add blocktype if present
+      if (Array.isArray(node[i]) && (node[i][0] === 'result' || node[i][0] === 'type')) content += ' ' + printNode(node[i++], level)
+      // Add catch clauses inline
+      while (Array.isArray(node[i]) && /^catch/.test(node[i][0])) content += ' ' + printNode(node[i++], level).trim()
+      // Rest is body - print normally
+      for (; i < node.length; i++) content += Array.isArray(node[i]) ? newline + indent.repeat(level + 1) + printNode(node[i], level + 1) : ' ' + node[i]
+      return `(${content + newline + indent.repeat(level)})`
+    }
 
     // flat node (no deep subnodes), eg. (i32.const 1), (module (export "") 1)
-    let flat = !!newline && node.length < 4
+    // not flat if contains line comments (they need their own line)
+    let flat = !!newline && node.length < 4 && !node.some(n => typeof n === 'string' && n[0] === ';' && n[1] === ';')
     let curIndent = indent.repeat(level + 1)
 
     for (let i = 1; i < node.length; i++) {
-      // (<keyword> ...)
-      if (Array.isArray(node[i])) {
-        // check if it's still flat
-        if (flat) flat = node[i].every(subnode => !Array.isArray(subnode))
+      const sub = node[i].valueOf() // "\00abc\ff" strings are stored as arrays but have ._ with original value
 
-        // new line
-        content += newline + curIndent + printNode(node[i], level + 1)
+      // comments - skip if not enabled
+      if (typeof sub === 'string' && sub[1] === ';') {
+        if (!comments) continue
+        // line comments (;;) - MUST end with newline to avoid consuming following elements
+        if (sub[0] === ';') {
+          if (newline) {
+            // prettified: own line with indent, next element adds its own newline
+            content += newline + curIndent + sub.trimEnd()
+            afterLineComment = true
+          } else {
+            // minified: keep inline but must have newline after
+            const last = content[content.length - 1]
+            if (last && last !== ' ' && last !== '(') content += ' '
+            content += sub.trimEnd() + '\n'
+          }
+        }
+        // block comments ((;...;)) can stay inline
+        else {
+          const last = content[content.length - 1]
+          if (last && last !== ' ' && last !== '(') content += ' '
+          content += sub.trimEnd()
+        }
+      }
+      // (<keyword> ...)
+      else if (Array.isArray(sub)) {
+        if (flat) flat = sub.every(sub => !Array.isArray(sub))
+        content += newline + curIndent + printNode(sub, level + 1)
+        afterLineComment = false
       }
       // data chunks "\00..."
       else if (node[0] === 'data')   {
         flat = false;
         if (newline || content[content.length-1] !== ')') content += newline || ' '
-        content += curIndent + node[i]
+        content += curIndent + sub
+        afterLineComment = false
       }
       // inline nodes
       else {
-        if (newline || content[content.length-1] !== ')') content += ' '
-        content += node[i]
+        const last = content[content.length - 1]
+        // after line comment in prettified mode, need newline + indent
+        if (afterLineComment && newline) content += newline + curIndent
+        // after newline from line comment (minified), add indent
+        else if (last === '\n') content += ''
+        else if (last && last !== ')' && last !== ' ') content += ' '
+        else if (newline || last === ')') content += ' '
+        content += sub
+        afterLineComment = false
       }
     }