@yuku-codegen/wasm 0.5.21

package/encode.js

@@ -0,0 +1,2367 @@
+// generated by tools/gen_estree_encoder.zig, do not edit
+const NULL = 0xFFFFFFFF;
+const _enc = new TextEncoder();
+const NODE_SIZE = 48;
+const HEADER_SIZE = 44;
+const NODE_FLAGS_OFFSET = 2;
+const NODE_FIELD0_OFFSET = 4;
+const NODE_HEADER_U32S = 2;
+const NODE_SPAN_START_U32 = 10;
+const NODE_SPAN_END_U32 = 11;
+const ATTACHED_COMMENT_SIZE = 12;
+const ATTACHED_COMMENT_FLAGS_OFFSET = 0;
+const ATTACHED_COMMENT_VALUE_START_OFFSET = 4;
+const ATTACHED_COMMENT_VALUE_END_OFFSET = 8;
+const FLAG_ATTACHED_COMMENTS = 2;
+const BINARY_OPS_INV = {"==": 0, "!=": 1, "===": 2, "!==": 3, "<": 4, "<=": 5, ">": 6, ">=": 7, "+": 8, "-": 9, "*": 10, "/": 11, "%": 12, "**": 13, "|": 14, "^": 15, "&": 16, "<<": 17, ">>": 18, ">>>": 19, "in": 20, "instanceof": 21};
+const LOGICAL_OPS_INV = {"&&": 0, "||": 1, "??": 2};
+const UNARY_OPS_INV = {"-": 0, "+": 1, "!": 2, "~": 3, "typeof": 4, "void": 5, "delete": 6};
+const UPDATE_OPS_INV = {"++": 0, "--": 1};
+const ASSIGNMENT_OPS_INV = {"=": 0, "+=": 1, "-=": 2, "*=": 3, "/=": 4, "%=": 5, "**=": 6, "<<=": 7, ">>=": 8, ">>>=": 9, "|=": 10, "^=": 11, "&=": 12, "||=": 13, "&&=": 14, "??=": 15};
+const VAR_KINDS_INV = {"var": 0, "let": 1, "const": 2, "using": 3, "await using": 4};
+const PROPERTY_KINDS_INV = {"init": 0, "get": 1, "set": 2};
+const METHOD_KINDS_INV = {"constructor": 0, "method": 1, "get": 2, "set": 3};
+const IMPORT_EXPORT_KINDS_INV = {"value": 0, "type": 1};
+const TS_TYPE_OPERATORS_INV = {"keyof": 0, "unique": 1, "readonly": 2};
+const TS_METHOD_SIGNATURE_KINDS_INV = {"method": 0, "get": 1, "set": 2};
+const TS_MODULE_KINDS_INV = {"namespace": 0, "module": 1};
+const IMPORT_PHASE_INV = {"source": 0, "defer": 1};
+const ACCESSIBILITY_INV = (v) =>
+  v == null ? 0
+  : v === "public" ? 1
+  : v === "private" ? 2
+  : 3;
+const TS_MAPPED_OPTIONAL_INV = (v) => v === true ? 1 : v === "+" ? 2 : v === "-" ? 3 : 0;
+const TS_MAPPED_READONLY_INV = (v) => v === true ? 1 : v === "+" ? 2 : v === "-" ? 3 : 0;
+function encode(program, lineStarts) {
+  const root = program;
+  const sizeHint = root.end || 0;
+  let nodeCap = Math.max(512, (sizeHint / 7) | 0);
+  let nodeAB = new ArrayBuffer(nodeCap * NODE_SIZE);
+  let nU8 = new Uint8Array(nodeAB);
+  let nU32 = new Uint32Array(nodeAB);
+  let nodeCount = 0;
+  let extraCap = Math.max(512, (sizeHint / 20) | 0);
+  let extras = new Uint32Array(extraCap);
+  let extraCount = 0;
+  let poolCap = Math.max(4096, (sizeHint / 8) | 0);
+  let pool = new Uint8Array(poolCap);
+  let poolLen = 0;
+  const strMap = new Map();
+  function alloc() {
+    if (nodeCount >= nodeCap) {
+      nodeCap *= 2;
+      const nb = new ArrayBuffer(nodeCap * NODE_SIZE);
+      new Uint8Array(nb).set(nU8);
+      nodeAB = nb; nU8 = new Uint8Array(nb); nU32 = new Uint32Array(nb);
+    }
+    const idx = nodeCount++;
+    const b = (idx * NODE_SIZE) >>> 2;
+    nU32[b + NODE_HEADER_U32S + 0] = NULL;
+    nU32[b + NODE_HEADER_U32S + 1] = NULL;
+    nU32[b + NODE_HEADER_U32S + 2] = NULL;
+    nU32[b + NODE_HEADER_U32S + 3] = NULL;
+    nU32[b + NODE_HEADER_U32S + 4] = NULL;
+    nU32[b + NODE_HEADER_U32S + 5] = NULL;
+    nU32[b + NODE_HEADER_U32S + 6] = NULL;
+    nU32[b + NODE_HEADER_U32S + 7] = NULL;
+    return idx;
+  }
+  function tagAt(idx, tag) { nU8[idx * NODE_SIZE] = tag; }
+  function flagsAt(idx, v) {
+    const o = idx * NODE_SIZE + NODE_FLAGS_OFFSET;
+    nU8[o] = v & 0xFF; nU8[o + 1] = (v >>> 8) & 0xFF;
+  }
+  function f0At(idx, v) {
+    const o = idx * NODE_SIZE + NODE_FIELD0_OFFSET;
+    nU8[o] = v & 0xFF; nU8[o + 1] = (v >>> 8) & 0xFF;
+  }
+  function slotAt(idx, slot, v) {
+    nU32[((idx * NODE_SIZE) >>> 2) + NODE_HEADER_U32S + slot] = v >>> 0;
+  }
+  function spanAt(idx, s, e) {
+    const b = (idx * NODE_SIZE) >>> 2;
+    nU32[b + NODE_SPAN_START_U32] = (s >>> 0);
+    nU32[b + NODE_SPAN_END_U32] = (e >>> 0);
+  }
+  function pushExtra(idx) {
+    if (extraCount >= extraCap) {
+      extraCap *= 2;
+      const ne = new Uint32Array(extraCap);
+      ne.set(extras); extras = ne;
+    }
+    extras[extraCount++] = idx >>> 0;
+  }
+  function encArr(arr, encEach) {
+    if (!arr || arr.length === 0) return { start: 0, len: 0 };
+    const len = arr.length;
+    const ids = new Array(len);
+    for (let i = 0; i < len; i++) ids[i] = encEach(arr[i]);
+    const start = extraCount;
+    for (let i = 0; i < len; i++) pushExtra(ids[i]);
+    return { start, len };
+  }
+  function encArrHoles(arr, encEach) {
+    if (!arr || arr.length === 0) return { start: 0, len: 0 };
+    const len = arr.length;
+    const ids = new Array(len);
+    for (let i = 0; i < len; i++) {
+      const e = arr[i];
+      ids[i] = e == null ? NULL : encEach(e);
+    }
+    const start = extraCount;
+    for (let i = 0; i < len; i++) pushExtra(ids[i]);
+    return { start, len };
+  }
+  function encStr(s) {
+    if (s == null || s === "") return { start: 0, end: 0 };
+    const hit = strMap.get(s);
+    if (hit !== undefined) return hit;
+    const n = s.length;
+    if (poolLen + n * 3 > poolCap) {
+      do { poolCap *= 2; } while (poolLen + n * 3 > poolCap);
+      const np = new Uint8Array(poolCap);
+      np.set(pool); pool = np;
+    }
+    const start = poolLen;
+    let p = start;
+    let ascii = true;
+    for (let i = 0; i < n; i++) {
+      const c = s.charCodeAt(i);
+      if (c < 0x80) { pool[p++] = c; } else { ascii = false; break; }
+    }
+    let r;
+    if (ascii) {
+      r = { start, end: p };
+      poolLen = p;
+    } else {
+      const bytes = _enc.encode(s);
+      pool.set(bytes, start);
+      r = { start, end: start + bytes.length };
+      poolLen = start + bytes.length;
+    }
+    strMap.set(s, r);
+    return r;
+  }
+  function asStart(n) { return (n && typeof n.start === "number") ? n.start : 0; }
+  function asEnd(n) { return (n && typeof n.end === "number") ? n.end : 0; }
+  function recordComments(n, idx) {
+    if (idx !== NULL && n && Array.isArray(n.comments) && n.comments.length > 0) {
+      commentsByIdx.set(idx, n.comments);
+    }
+  }
+  function encBindingTarget(n) {
+    if (n == null) return NULL;
+    if (n.type === "Identifier") return enc_binding_identifier(n);
+    return encNode(n);
+  }
+  function encLabel(n) {
+    if (n == null) return NULL;
+    return enc_label_identifier(n);
+  }
+  function encName(n) {
+    if (n == null) return NULL;
+    if (n.type === "Identifier") return enc_identifier_name(n);
+    return encNode(n);
+  }
+  function enc_sequence_expression(n) {
+    const c_expressions = encArr(n.expressions, encNode);
+    const idx = alloc();
+    tagAt(idx, 0);
+    f0At(idx, c_expressions.len);
+    slotAt(idx, 0, c_expressions.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_parenthesized_expression(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const idx = alloc();
+    tagAt(idx, 1);
+    slotAt(idx, 0, c_expression);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_arrow_function_expression(n) {
+    const params = encFormalParameters(n.params);
+    const body = encNode(n.body);
+    const tp = n.typeParameters == null ? NULL : encNode(n.typeParameters);
+    const rt_ = n.returnType == null ? NULL : encNode(n.returnType);
+    const idx = alloc();
+    tagAt(idx, 2);
+    slotAt(idx, 0, params);
+    slotAt(idx, 1, body);
+    slotAt(idx, 2, tp);
+    slotAt(idx, 3, rt_);
+    flagsAt(idx, (n.expression ? 1 : 0) | (n.async ? 2 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_function(n, kind) {
+    const id = n.id == null ? NULL : enc_binding_identifier(n.id);
+    const params = encFormalParameters(n.params);
+    const body = n.body == null ? NULL : encNode(n.body);
+    const tp = n.typeParameters == null ? NULL : encNode(n.typeParameters);
+    const rt_ = n.returnType == null ? NULL : encNode(n.returnType);
+    const idx = alloc();
+    tagAt(idx, 3);
+    slotAt(idx, 0, id);
+    slotAt(idx, 1, params);
+    slotAt(idx, 2, body);
+    slotAt(idx, 3, tp);
+    slotAt(idx, 4, rt_);
+    flagsAt(idx,
+      ((kind & 3) << 0)
+      | (n.generator ? 4 : 0)
+      | (n.async ? 8 : 0)
+      | (n.declare ? 16 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_block_statement(n) {
+    const c_body = encArr(n.body, encNode);
+    const idx = alloc();
+    tagAt(idx, 5);
+    f0At(idx, c_body.len);
+    slotAt(idx, 0, c_body.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function encFormalParameters(params) {
+    if (!params) {
+      const idx = alloc();
+      tagAt(idx, 6);
+      spanAt(idx, 0, 0);
+      return idx;
+    }
+    const items = [];
+    let rest = NULL;
+    for (let i = 0; i < params.length; i++) {
+      const p = params[i];
+      if (p && p.type === "RestElement") rest = enc_binding_rest_element(p);
+      else if (p && p.type === "TSParameterProperty") items.push(encNode(p));
+      else if (p && p.type === "Identifier" && p.name === "this")
+        items.push(enc_ts_this_parameter(p));
+      else items.push(enc_formal_parameter(p));
+    }
+    const ids = items;
+    const start = extraCount;
+    for (let i = 0; i < ids.length; i++) pushExtra(ids[i]);
+    const idx = alloc();
+    tagAt(idx, 6);
+    f0At(idx, ids.length);
+    slotAt(idx, 0, start);
+    slotAt(idx, 1, rest);
+    spanAt(idx, 0, 0);
+    return idx;
+  }
+  function enc_formal_parameter(p) {
+    const pat = encBindingTarget(p);
+    const idx = alloc();
+    tagAt(idx, 7);
+    slotAt(idx, 0, pat);
+    spanAt(idx, asStart(p), asEnd(p));
+    recordComments(p, idx);
+    return idx;
+  }
+  function enc_binary_expression(n) {
+    const c_left = n.left == null ? NULL : encNode(n.left);
+    const c_right = n.right == null ? NULL : encNode(n.right);
+    const idx = alloc();
+    tagAt(idx, 8);
+    slotAt(idx, 0, c_left);
+    slotAt(idx, 1, c_right);
+    flagsAt(idx, 0 | (BINARY_OPS_INV[n.operator] | 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_logical_expression(n) {
+    const c_left = n.left == null ? NULL : encNode(n.left);
+    const c_right = n.right == null ? NULL : encNode(n.right);
+    const idx = alloc();
+    tagAt(idx, 9);
+    slotAt(idx, 0, c_left);
+    slotAt(idx, 1, c_right);
+    flagsAt(idx, 0 | (LOGICAL_OPS_INV[n.operator] | 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_conditional_expression(n) {
+    const c_test = n.test == null ? NULL : encNode(n.test);
+    const c_consequent = n.consequent == null ? NULL : encNode(n.consequent);
+    const c_alternate = n.alternate == null ? NULL : encNode(n.alternate);
+    const idx = alloc();
+    tagAt(idx, 10);
+    slotAt(idx, 0, c_test);
+    slotAt(idx, 1, c_consequent);
+    slotAt(idx, 2, c_alternate);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_unary_expression(n) {
+    const a = n.argument == null ? NULL : encNode(n.argument);
+    const idx = alloc();
+    tagAt(idx, 11);
+    slotAt(idx, 0, a);
+    flagsAt(idx, UNARY_OPS_INV[n.operator] | 0);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_update_expression(n) {
+    const c_argument = n.argument == null ? NULL : encNode(n.argument);
+    const idx = alloc();
+    tagAt(idx, 12);
+    slotAt(idx, 0, c_argument);
+    flagsAt(idx, 0 | (UPDATE_OPS_INV[n.operator] | 0) | (n.prefix ? 2 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_assignment_expression(n) {
+    const c_left = n.left == null ? NULL : encNode(n.left);
+    const c_right = n.right == null ? NULL : encNode(n.right);
+    const idx = alloc();
+    tagAt(idx, 13);
+    slotAt(idx, 0, c_left);
+    slotAt(idx, 1, c_right);
+    flagsAt(idx, 0 | (ASSIGNMENT_OPS_INV[n.operator] | 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_array_expression(n) {
+    const c_elements = encArrHoles(n.elements, encNode);
+    const idx = alloc();
+    tagAt(idx, 14);
+    f0At(idx, c_elements.len);
+    slotAt(idx, 0, c_elements.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_object_expression(n) {
+    const c_properties = encArr(n.properties, encNode);
+    const idx = alloc();
+    tagAt(idx, 15);
+    f0At(idx, c_properties.len);
+    slotAt(idx, 0, c_properties.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_spread_element(n) {
+    const c_argument = n.argument == null ? NULL : encNode(n.argument);
+    const idx = alloc();
+    tagAt(idx, 16);
+    slotAt(idx, 0, c_argument);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_object_property(n) {
+    const k = n.key == null
+      ? NULL
+      : (n.computed ? encNode(n.key) : encName(n.key));
+    const v = n.value == null ? NULL : encNode(n.value);
+    const idx = alloc();
+    tagAt(idx, 17);
+    slotAt(idx, 0, k); slotAt(idx, 1, v);
+    flagsAt(idx,
+      ((PROPERTY_KINDS_INV[n.kind] | 0) << 0)
+      | (n.method ? 4 : 0)
+      | (n.shorthand ? 8 : 0)
+      | (n.computed ? 16 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_member_expression(n) {
+    const o = n.object == null ? NULL : encNode(n.object);
+    const p = n.property == null
+      ? NULL
+      : (n.computed ? encNode(n.property) : encName(n.property));
+    const idx = alloc();
+    tagAt(idx, 18);
+    slotAt(idx, 0, o); slotAt(idx, 1, p);
+    flagsAt(idx, (n.computed ? 1 : 0) | (n.optional ? 2 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_call_expression(n) {
+    const c_callee = n.callee == null ? NULL : encNode(n.callee);
+    const c_arguments = encArr(n.arguments, encNode);
+    const c_type_arguments = n.typeArguments == null ? NULL : encNode(n.typeArguments);
+    const idx = alloc();
+    tagAt(idx, 19);
+    slotAt(idx, 0, c_callee);
+    f0At(idx, c_arguments.len);
+    slotAt(idx, 1, c_arguments.start);
+    slotAt(idx, 2, c_type_arguments);
+    flagsAt(idx, 0 | (n.optional ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_chain_expression(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const idx = alloc();
+    tagAt(idx, 20);
+    slotAt(idx, 0, c_expression);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_tagged_template_expression(n) {
+    const c_tag = n.tag == null ? NULL : encNode(n.tag);
+    const c_quasi = n.quasi == null ? NULL : encNode(n.quasi);
+    const c_type_arguments = n.typeArguments == null ? NULL : encNode(n.typeArguments);
+    const idx = alloc();
+    tagAt(idx, 21);
+    slotAt(idx, 0, c_tag);
+    slotAt(idx, 1, c_quasi);
+    slotAt(idx, 2, c_type_arguments);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_new_expression(n) {
+    const c_callee = n.callee == null ? NULL : encNode(n.callee);
+    const c_arguments = encArr(n.arguments, encNode);
+    const c_type_arguments = n.typeArguments == null ? NULL : encNode(n.typeArguments);
+    const idx = alloc();
+    tagAt(idx, 22);
+    slotAt(idx, 0, c_callee);
+    f0At(idx, c_arguments.len);
+    slotAt(idx, 1, c_arguments.start);
+    slotAt(idx, 2, c_type_arguments);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_await_expression(n) {
+    const c_argument = n.argument == null ? NULL : encNode(n.argument);
+    const idx = alloc();
+    tagAt(idx, 23);
+    slotAt(idx, 0, c_argument);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_yield_expression(n) {
+    const c_argument = n.argument == null ? NULL : encNode(n.argument);
+    const idx = alloc();
+    tagAt(idx, 24);
+    slotAt(idx, 0, c_argument);
+    flagsAt(idx, 0 | (n.delegate ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_meta_property(n) {
+    const c_meta = n.meta == null ? NULL : encNode(n.meta);
+    const c_property = n.property == null ? NULL : encNode(n.property);
+    const idx = alloc();
+    tagAt(idx, 25);
+    slotAt(idx, 0, c_meta);
+    slotAt(idx, 1, c_property);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_decorator(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const idx = alloc();
+    tagAt(idx, 26);
+    slotAt(idx, 0, c_expression);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_class(n, kind) {
+    const decs = encArr(n.decorators, encNode);
+    const id = n.id == null ? NULL : enc_binding_identifier(n.id);
+    const sc = n.superClass == null ? NULL : encNode(n.superClass);
+    const body = n.body == null ? NULL : encNode(n.body);
+    const tp = n.typeParameters == null ? NULL : encNode(n.typeParameters);
+    const sta = n.superTypeArguments == null ? NULL : encNode(n.superTypeArguments);
+    const imps = encArr(n.implements, encNode);
+    const idx = alloc();
+    tagAt(idx, 27);
+    f0At(idx, decs.len);
+    slotAt(idx, 0, decs.start);
+    slotAt(idx, 1, id);
+    slotAt(idx, 2, sc);
+    slotAt(idx, 3, body);
+    slotAt(idx, 4, tp);
+    slotAt(idx, 5, sta);
+    slotAt(idx, 6, imps.start);
+    slotAt(idx, 7, imps.len);
+    flagsAt(idx, ((kind & 1) << 0) | (n.abstract ? 2 : 0) | (n.declare ? 4 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_class_body(n) {
+    const c_body = encArr(n.body, encNode);
+    const idx = alloc();
+    tagAt(idx, 28);
+    f0At(idx, c_body.len);
+    slotAt(idx, 0, c_body.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_method_definition(n, abstract) {
+    const decs = encArr(n.decorators, encNode);
+    const k = n.computed ? encNode(n.key) : encName(n.key);
+    const v = encNode(n.value);
+    const idx = alloc();
+    tagAt(idx, 29);
+    f0At(idx, decs.len);
+    slotAt(idx, 0, decs.start);
+    slotAt(idx, 1, k);
+    slotAt(idx, 2, v);
+    flagsAt(idx,
+      ((METHOD_KINDS_INV[n.kind] | 0) << 0) |
+      (n.computed ? 4 : 0) |
+      (n.static ? 8 : 0) |
+      (n.override ? 16 : 0) |
+      (n.optional ? 32 : 0) |
+      (abstract ? 64 : 0) |
+      (ACCESSIBILITY_INV(n.accessibility) << 7));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_property_definition(n, accessor, abstract) {
+    const decs = encArr(n.decorators, encNode);
+    const k = n.computed ? encNode(n.key) : encName(n.key);
+    const v = n.value == null ? NULL : encNode(n.value);
+    const ta = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 30);
+    f0At(idx, decs.len);
+    slotAt(idx, 0, decs.start);
+    slotAt(idx, 1, k);
+    slotAt(idx, 2, v);
+    slotAt(idx, 3, ta);
+    flagsAt(idx,
+      (n.computed ? 1 : 0) |
+      (n.static ? 2 : 0) |
+      (accessor ? 4 : 0) |
+      (n.declare ? 8 : 0) |
+      (n.override ? 16 : 0) |
+      (n.optional ? 32 : 0) |
+      (n.definite ? 64 : 0) |
+      (n.readonly ? 128 : 0) |
+      (abstract ? 256 : 0) |
+      (ACCESSIBILITY_INV(n.accessibility) << 9));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_static_block(n) {
+    const c_body = encArr(n.body, encNode);
+    const idx = alloc();
+    tagAt(idx, 31);
+    f0At(idx, c_body.len);
+    slotAt(idx, 0, c_body.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_super(n) {
+    const idx = alloc();
+    tagAt(idx, 32);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_string_literal(n) {
+    const s = encStr(typeof n.value === "string" ? n.value : "");
+    const r = encStr(typeof n.raw === "string" ? n.raw : "");
+    const idx = alloc();
+    tagAt(idx, 33);
+    slotAt(idx, 0, s.start); slotAt(idx, 1, s.end);
+    slotAt(idx, 2, r.start); slotAt(idx, 3, r.end);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_numeric_literal(n) {
+    const raw = typeof n.raw === "string" ? n.raw : String(n.value);
+    let kind = 0;
+    if (raw.length > 1 && raw.charCodeAt(0) === 48) {
+      const c = raw.charCodeAt(1);
+      if (c === 120 || c === 88) kind = 1;
+      else if (c === 111 || c === 79) kind = 2;
+      else if (c === 98 || c === 66) kind = 3;
+    }
+    const r = encStr(raw);
+    const idx = alloc();
+    tagAt(idx, 34);
+    flagsAt(idx, kind);
+    slotAt(idx, 0, r.start); slotAt(idx, 1, r.end);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_bigint_literal(n) {
+    const raw = typeof n.bigint === "string" ? n.bigint : String(n.value);
+    const r = encStr(raw);
+    const idx = alloc();
+    tagAt(idx, 35);
+    slotAt(idx, 0, r.start); slotAt(idx, 1, r.end);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_boolean_literal(n) {
+    const idx = alloc();
+    tagAt(idx, 36);
+    flagsAt(idx, n.value ? 1 : 0);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_null_literal(n) {
+    const idx = alloc();
+    tagAt(idx, 37);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_this_expression(n) {
+    const idx = alloc();
+    tagAt(idx, 38);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_regexp_literal(n) {
+    const p = encStr(n.regex && n.regex.pattern || "");
+    const fl = encStr(n.regex && n.regex.flags || "");
+    const idx = alloc();
+    tagAt(idx, 39);
+    slotAt(idx, 0, p.start); slotAt(idx, 1, p.end);
+    slotAt(idx, 2, fl.start); slotAt(idx, 3, fl.end);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_template_literal(n) {
+    const c_quasis = encArr(n.quasis, encNode);
+    const c_expressions = encArr(n.expressions, encNode);
+    const idx = alloc();
+    tagAt(idx, 40);
+    f0At(idx, c_quasis.len);
+    slotAt(idx, 0, c_quasis.start);
+    slotAt(idx, 1, c_expressions.start);
+    slotAt(idx, 2, c_expressions.len);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_template_element(n) {
+    const v = (n.value || {});
+    const undef = v.cooked == null;
+    const c = encStr(undef ? "" : v.cooked);
+    const idx = alloc();
+    tagAt(idx, 41);
+    flagsAt(idx, (n.tail ? 1 : 0) | (undef ? 2 : 0));
+    slotAt(idx, 0, c.start); slotAt(idx, 1, c.end);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_identifier_reference(n) {
+    const c_name = encStr(n.name);
+    const idx = alloc();
+    tagAt(idx, 42);
+    slotAt(idx, 0, c_name.start);
+    slotAt(idx, 1, c_name.end);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_private_identifier(n) {
+    const c_name = encStr(n.name);
+    const idx = alloc();
+    tagAt(idx, 43);
+    slotAt(idx, 0, c_name.start);
+    slotAt(idx, 1, c_name.end);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_binding_identifier(n) {
+    const c_name = encStr(n.name);
+    const c_decorators = encArr(n.decorators, encNode);
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 44);
+    slotAt(idx, 0, c_name.start);
+    slotAt(idx, 1, c_name.end);
+    f0At(idx, c_decorators.len);
+    slotAt(idx, 2, c_decorators.start);
+    slotAt(idx, 3, c_type_annotation);
+    flagsAt(idx, 0 | (n.optional ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_identifier_name(n) {
+    const c_name = encStr(n.name);
+    const idx = alloc();
+    tagAt(idx, 45);
+    slotAt(idx, 0, c_name.start);
+    slotAt(idx, 1, c_name.end);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_label_identifier(n) {
+    const c_name = encStr(n.name);
+    const idx = alloc();
+    tagAt(idx, 46);
+    slotAt(idx, 0, c_name.start);
+    slotAt(idx, 1, c_name.end);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_expression_statement(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const idx = alloc();
+    tagAt(idx, 47);
+    slotAt(idx, 0, c_expression);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_if_statement(n) {
+    const c_test = n.test == null ? NULL : encNode(n.test);
+    const c_consequent = n.consequent == null ? NULL : encNode(n.consequent);
+    const c_alternate = n.alternate == null ? NULL : encNode(n.alternate);
+    const idx = alloc();
+    tagAt(idx, 48);
+    slotAt(idx, 0, c_test);
+    slotAt(idx, 1, c_consequent);
+    slotAt(idx, 2, c_alternate);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_switch_statement(n) {
+    const c_discriminant = n.discriminant == null ? NULL : encNode(n.discriminant);
+    const c_cases = encArr(n.cases, encNode);
+    const idx = alloc();
+    tagAt(idx, 49);
+    slotAt(idx, 0, c_discriminant);
+    f0At(idx, c_cases.len);
+    slotAt(idx, 1, c_cases.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_switch_case(n) {
+    const c_test = n.test == null ? NULL : encNode(n.test);
+    const c_consequent = encArr(n.consequent, encNode);
+    const idx = alloc();
+    tagAt(idx, 50);
+    slotAt(idx, 0, c_test);
+    f0At(idx, c_consequent.len);
+    slotAt(idx, 1, c_consequent.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_for_statement(n) {
+    const c_init = n.init == null ? NULL : encNode(n.init);
+    const c_test = n.test == null ? NULL : encNode(n.test);
+    const c_update = n.update == null ? NULL : encNode(n.update);
+    const c_body = n.body == null ? NULL : encNode(n.body);
+    const idx = alloc();
+    tagAt(idx, 51);
+    slotAt(idx, 0, c_init);
+    slotAt(idx, 1, c_test);
+    slotAt(idx, 2, c_update);
+    slotAt(idx, 3, c_body);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_for_in_statement(n) {
+    const c_left = n.left == null ? NULL : encNode(n.left);
+    const c_right = n.right == null ? NULL : encNode(n.right);
+    const c_body = n.body == null ? NULL : encNode(n.body);
+    const idx = alloc();
+    tagAt(idx, 52);
+    slotAt(idx, 0, c_left);
+    slotAt(idx, 1, c_right);
+    slotAt(idx, 2, c_body);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_for_of_statement(n) {
+    const c_left = n.left == null ? NULL : encNode(n.left);
+    const c_right = n.right == null ? NULL : encNode(n.right);
+    const c_body = n.body == null ? NULL : encNode(n.body);
+    const idx = alloc();
+    tagAt(idx, 53);
+    slotAt(idx, 0, c_left);
+    slotAt(idx, 1, c_right);
+    slotAt(idx, 2, c_body);
+    flagsAt(idx, 0 | (n.await ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_while_statement(n) {
+    const c_test = n.test == null ? NULL : encNode(n.test);
+    const c_body = n.body == null ? NULL : encNode(n.body);
+    const idx = alloc();
+    tagAt(idx, 54);
+    slotAt(idx, 0, c_test);
+    slotAt(idx, 1, c_body);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_do_while_statement(n) {
+    const c_body = n.body == null ? NULL : encNode(n.body);
+    const c_test = n.test == null ? NULL : encNode(n.test);
+    const idx = alloc();
+    tagAt(idx, 55);
+    slotAt(idx, 0, c_body);
+    slotAt(idx, 1, c_test);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_break_statement(n) {
+    const c_label = n.label == null ? NULL : encLabel(n.label);
+    const idx = alloc();
+    tagAt(idx, 56);
+    slotAt(idx, 0, c_label);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_continue_statement(n) {
+    const c_label = n.label == null ? NULL : encLabel(n.label);
+    const idx = alloc();
+    tagAt(idx, 57);
+    slotAt(idx, 0, c_label);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_labeled_statement(n) {
+    const c_label = n.label == null ? NULL : encLabel(n.label);
+    const c_body = n.body == null ? NULL : encNode(n.body);
+    const idx = alloc();
+    tagAt(idx, 58);
+    slotAt(idx, 0, c_label);
+    slotAt(idx, 1, c_body);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_with_statement(n) {
+    const c_object = n.object == null ? NULL : encNode(n.object);
+    const c_body = n.body == null ? NULL : encNode(n.body);
+    const idx = alloc();
+    tagAt(idx, 59);
+    slotAt(idx, 0, c_object);
+    slotAt(idx, 1, c_body);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_return_statement(n) {
+    const c_argument = n.argument == null ? NULL : encNode(n.argument);
+    const idx = alloc();
+    tagAt(idx, 60);
+    slotAt(idx, 0, c_argument);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_throw_statement(n) {
+    const c_argument = n.argument == null ? NULL : encNode(n.argument);
+    const idx = alloc();
+    tagAt(idx, 61);
+    slotAt(idx, 0, c_argument);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_try_statement(n) {
+    const c_block = n.block == null ? NULL : encNode(n.block);
+    const c_handler = n.handler == null ? NULL : encNode(n.handler);
+    const c_finalizer = n.finalizer == null ? NULL : encNode(n.finalizer);
+    const idx = alloc();
+    tagAt(idx, 62);
+    slotAt(idx, 0, c_block);
+    slotAt(idx, 1, c_handler);
+    slotAt(idx, 2, c_finalizer);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_catch_clause(n) {
+    const c_param = n.param == null ? NULL : encBindingTarget(n.param);
+    const c_body = n.body == null ? NULL : encNode(n.body);
+    const idx = alloc();
+    tagAt(idx, 63);
+    slotAt(idx, 0, c_param);
+    slotAt(idx, 1, c_body);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_debugger_statement(n) {
+    const idx = alloc();
+    tagAt(idx, 64);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_empty_statement(n) {
+    const idx = alloc();
+    tagAt(idx, 65);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_variable_declaration(n) {
+    const c_declarators = encArr(n.declarations, encNode);
+    const idx = alloc();
+    tagAt(idx, 66);
+    f0At(idx, c_declarators.len);
+    slotAt(idx, 0, c_declarators.start);
+    flagsAt(idx, 0 | (VAR_KINDS_INV[n.kind] | 0) | (n.declare ? 8 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_variable_declarator(n) {
+    const c_id = n.id == null ? NULL : encBindingTarget(n.id);
+    const c_init = n.init == null ? NULL : encNode(n.init);
+    const idx = alloc();
+    tagAt(idx, 67);
+    slotAt(idx, 0, c_id);
+    slotAt(idx, 1, c_init);
+    flagsAt(idx, 0 | (n.definite ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_directive(n) {
+    const e = encNode(n.expression);
+    const dv = encStr(n.directive);
+    const idx = alloc();
+    tagAt(idx, 68);
+    slotAt(idx, 0, e);
+    slotAt(idx, 1, dv.start); slotAt(idx, 2, dv.end);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_assignment_pattern(n) {
+    const c_left = n.left == null ? NULL : encBindingTarget(n.left);
+    const c_right = n.right == null ? NULL : encNode(n.right);
+    const c_decorators = encArr(n.decorators, encNode);
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 69);
+    slotAt(idx, 0, c_left);
+    slotAt(idx, 1, c_right);
+    f0At(idx, c_decorators.len);
+    slotAt(idx, 2, c_decorators.start);
+    slotAt(idx, 3, c_type_annotation);
+    flagsAt(idx, 0 | (n.optional ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_binding_rest_element(n) {
+    const c_argument = n.argument == null ? NULL : encBindingTarget(n.argument);
+    const c_decorators = encArr(n.decorators, encNode);
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 70);
+    slotAt(idx, 0, c_argument);
+    f0At(idx, c_decorators.len);
+    slotAt(idx, 1, c_decorators.start);
+    slotAt(idx, 2, c_type_annotation);
+    flagsAt(idx, 0 | (n.optional ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_array_pattern(n) {
+    const els = n.elements || [];
+    let rest = NULL;
+    const items = [];
+    for (let i = 0; i < els.length; i++) {
+      const e = els[i];
+      if (e == null) items.push(null);
+      else if (e.type === "RestElement") rest = enc_binding_rest_element(e);
+      else items.push(e);
+    }
+    const r = encArrHoles(items, encBindingTarget);
+    const decs = encArr(n.decorators, encNode);
+    const ta = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 71);
+    f0At(idx, r.len);
+    slotAt(idx, 0, r.start);
+    slotAt(idx, 1, rest);
+    slotAt(idx, 2, decs.start); slotAt(idx, 3, decs.len);
+    slotAt(idx, 4, ta);
+    flagsAt(idx, n.optional ? 1 : 0);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_object_pattern(n) {
+    const props = n.properties || [];
+    let rest = NULL;
+    const items = [];
+    for (let i = 0; i < props.length; i++) {
+      const p = props[i];
+      if (p && p.type === "RestElement") rest = enc_binding_rest_element(p);
+      else items.push(p);
+    }
+    const r = encArr(items, enc_binding_property);
+    const decs = encArr(n.decorators, encNode);
+    const ta = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 72);
+    f0At(idx, r.len);
+    slotAt(idx, 0, r.start);
+    slotAt(idx, 1, rest);
+    slotAt(idx, 2, decs.start); slotAt(idx, 3, decs.len);
+    slotAt(idx, 4, ta);
+    flagsAt(idx, n.optional ? 1 : 0);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_binding_property(p) {
+    const k = p.key == null
+      ? NULL
+      : (p.computed ? encNode(p.key) : encName(p.key));
+    const v = p.value == null ? NULL : encBindingTarget(p.value);
+    const idx = alloc();
+    tagAt(idx, 73);
+    slotAt(idx, 0, k); slotAt(idx, 1, v);
+    flagsAt(idx, (p.shorthand ? 1 : 0) | (p.computed ? 2 : 0));
+    spanAt(idx, asStart(p), asEnd(p));
+    return idx;
+  }
+  function enc_program(n) {
+    const body = encArr(n.body, encNode);
+    const hb = n.hashbang && typeof n.hashbang.value === "string"
+      ? encStr(n.hashbang.value)
+      : null;
+    const idx = alloc();
+    tagAt(idx, 74);
+    f0At(idx, body.len);
+    slotAt(idx, 0, body.start);
+    if (hb) { slotAt(idx, 1, hb.start); slotAt(idx, 2, hb.end); }
+    flagsAt(idx, (n.sourceType === "script" ? 0 : 1) | (hb ? 2 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_import_expression(n) {
+    const c_source = n.source == null ? NULL : encNode(n.source);
+    const c_options = n.options == null ? NULL : encNode(n.options);
+    const idx = alloc();
+    tagAt(idx, 75);
+    slotAt(idx, 0, c_source);
+    slotAt(idx, 1, c_options);
+    flagsAt(idx, 0 | (n.phase != null ? 1 | ((IMPORT_PHASE_INV[n.phase] | 0) << 1) : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_import_declaration(n) {
+    const c_specifiers = encArr(n.specifiers, encNode);
+    const c_source = n.source == null ? NULL : encNode(n.source);
+    const c_attributes = encArr(n.attributes, encNode);
+    const idx = alloc();
+    tagAt(idx, 76);
+    f0At(idx, c_specifiers.len);
+    slotAt(idx, 0, c_specifiers.start);
+    slotAt(idx, 1, c_source);
+    slotAt(idx, 2, c_attributes.start);
+    slotAt(idx, 3, c_attributes.len);
+    flagsAt(idx, 0 | (n.phase != null ? 1 | ((IMPORT_PHASE_INV[n.phase] | 0) << 1) : 0) | ((IMPORT_EXPORT_KINDS_INV[n.importKind] | 0) << 2));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_import_specifier(n) {
+    const c_imported = n.imported == null ? NULL : encName(n.imported);
+    const c_local = n.local == null ? NULL : encBindingTarget(n.local);
+    const idx = alloc();
+    tagAt(idx, 77);
+    slotAt(idx, 0, c_imported);
+    slotAt(idx, 1, c_local);
+    flagsAt(idx, 0 | (IMPORT_EXPORT_KINDS_INV[n.importKind] | 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_import_default_specifier(n) {
+    const c_local = n.local == null ? NULL : encBindingTarget(n.local);
+    const idx = alloc();
+    tagAt(idx, 78);
+    slotAt(idx, 0, c_local);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_import_namespace_specifier(n) {
+    const c_local = n.local == null ? NULL : encBindingTarget(n.local);
+    const idx = alloc();
+    tagAt(idx, 79);
+    slotAt(idx, 0, c_local);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_import_attribute(n) {
+    const c_key = n.key == null ? NULL : encName(n.key);
+    const c_value = n.value == null ? NULL : encNode(n.value);
+    const idx = alloc();
+    tagAt(idx, 80);
+    slotAt(idx, 0, c_key);
+    slotAt(idx, 1, c_value);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_export_named_declaration(n) {
+    const c_declaration = n.declaration == null ? NULL : encNode(n.declaration);
+    const c_specifiers = encArr(n.specifiers, encNode);
+    const c_source = n.source == null ? NULL : encNode(n.source);
+    const c_attributes = encArr(n.attributes, encNode);
+    const idx = alloc();
+    tagAt(idx, 81);
+    slotAt(idx, 0, c_declaration);
+    f0At(idx, c_specifiers.len);
+    slotAt(idx, 1, c_specifiers.start);
+    slotAt(idx, 2, c_source);
+    slotAt(idx, 3, c_attributes.start);
+    slotAt(idx, 4, c_attributes.len);
+    flagsAt(idx, 0 | (IMPORT_EXPORT_KINDS_INV[n.exportKind] | 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_export_default_declaration(n) {
+    const c_declaration = n.declaration == null ? NULL : encNode(n.declaration);
+    const idx = alloc();
+    tagAt(idx, 82);
+    slotAt(idx, 0, c_declaration);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_export_all_declaration(n) {
+    const c_exported = n.exported == null ? NULL : encName(n.exported);
+    const c_source = n.source == null ? NULL : encNode(n.source);
+    const c_attributes = encArr(n.attributes, encNode);
+    const idx = alloc();
+    tagAt(idx, 83);
+    slotAt(idx, 0, c_exported);
+    slotAt(idx, 1, c_source);
+    f0At(idx, c_attributes.len);
+    slotAt(idx, 2, c_attributes.start);
+    flagsAt(idx, 0 | (IMPORT_EXPORT_KINDS_INV[n.exportKind] | 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_export_specifier(n) {
+    const c_local = n.local == null ? NULL : encNode(n.local);
+    const c_exported = n.exported == null ? NULL : encName(n.exported);
+    const idx = alloc();
+    tagAt(idx, 84);
+    slotAt(idx, 0, c_local);
+    slotAt(idx, 1, c_exported);
+    flagsAt(idx, 0 | (IMPORT_EXPORT_KINDS_INV[n.exportKind] | 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_type_annotation(n) {
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 85);
+    slotAt(idx, 0, c_type_annotation);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_any_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 86);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_unknown_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 87);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_never_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 88);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_void_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 89);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_null_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 90);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_undefined_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 91);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_string_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 92);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_number_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 93);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_bigint_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 94);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_boolean_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 95);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_symbol_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 96);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_object_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 97);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_intrinsic_keyword(n) {
+    const idx = alloc();
+    tagAt(idx, 98);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_this_type(n) {
+    const idx = alloc();
+    tagAt(idx, 99);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_type_reference(n) {
+    const c_type_name = n.typeName == null ? NULL : encNode(n.typeName);
+    const c_type_arguments = n.typeArguments == null ? NULL : encNode(n.typeArguments);
+    const idx = alloc();
+    tagAt(idx, 100);
+    slotAt(idx, 0, c_type_name);
+    slotAt(idx, 1, c_type_arguments);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_qualified_name(n) {
+    const c_left = n.left == null ? NULL : encNode(n.left);
+    const c_right = n.right == null ? NULL : encName(n.right);
+    const idx = alloc();
+    tagAt(idx, 101);
+    slotAt(idx, 0, c_left);
+    slotAt(idx, 1, c_right);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_type_query(n) {
+    const c_expr_name = n.exprName == null ? NULL : encNode(n.exprName);
+    const c_type_arguments = n.typeArguments == null ? NULL : encNode(n.typeArguments);
+    const idx = alloc();
+    tagAt(idx, 102);
+    slotAt(idx, 0, c_expr_name);
+    slotAt(idx, 1, c_type_arguments);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_import_type(n) {
+    const c_source = n.source == null ? NULL : encNode(n.source);
+    const c_options = n.options == null ? NULL : encNode(n.options);
+    const c_qualifier = n.qualifier == null ? NULL : encName(n.qualifier);
+    const c_type_arguments = n.typeArguments == null ? NULL : encNode(n.typeArguments);
+    const idx = alloc();
+    tagAt(idx, 103);
+    slotAt(idx, 0, c_source);
+    slotAt(idx, 1, c_options);
+    slotAt(idx, 2, c_qualifier);
+    slotAt(idx, 3, c_type_arguments);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_type_parameter(n) {
+    const c_name = n.name == null ? NULL : encBindingTarget(n.name);
+    const c_constraint = n.constraint == null ? NULL : encNode(n.constraint);
+    const c_default = n.default == null ? NULL : encNode(n.default);
+    const idx = alloc();
+    tagAt(idx, 104);
+    slotAt(idx, 0, c_name);
+    slotAt(idx, 1, c_constraint);
+    slotAt(idx, 2, c_default);
+    flagsAt(idx, 0 | (n.in ? 1 : 0) | (n.out ? 2 : 0) | (n.const ? 4 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_type_parameter_declaration(n) {
+    const c_params = encArr(n.params, encNode);
+    const idx = alloc();
+    tagAt(idx, 105);
+    f0At(idx, c_params.len);
+    slotAt(idx, 0, c_params.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_type_parameter_instantiation(n) {
+    const c_params = encArr(n.params, encNode);
+    const idx = alloc();
+    tagAt(idx, 106);
+    f0At(idx, c_params.len);
+    slotAt(idx, 0, c_params.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_literal_type(n) {
+    const c_literal = n.literal == null ? NULL : encNode(n.literal);
+    const idx = alloc();
+    tagAt(idx, 107);
+    slotAt(idx, 0, c_literal);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_template_literal_type(n) {
+    const c_quasis = encArr(n.quasis, encNode);
+    const c_types = encArr(n.types, encNode);
+    const idx = alloc();
+    tagAt(idx, 108);
+    f0At(idx, c_quasis.len);
+    slotAt(idx, 0, c_quasis.start);
+    slotAt(idx, 1, c_types.start);
+    slotAt(idx, 2, c_types.len);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_array_type(n) {
+    const c_element_type = n.elementType == null ? NULL : encNode(n.elementType);
+    const idx = alloc();
+    tagAt(idx, 109);
+    slotAt(idx, 0, c_element_type);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_indexed_access_type(n) {
+    const c_object_type = n.objectType == null ? NULL : encNode(n.objectType);
+    const c_index_type = n.indexType == null ? NULL : encNode(n.indexType);
+    const idx = alloc();
+    tagAt(idx, 110);
+    slotAt(idx, 0, c_object_type);
+    slotAt(idx, 1, c_index_type);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_tuple_type(n) {
+    const c_element_types = encArr(n.elementTypes, encNode);
+    const idx = alloc();
+    tagAt(idx, 111);
+    f0At(idx, c_element_types.len);
+    slotAt(idx, 0, c_element_types.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_named_tuple_member(n) {
+    const c_label = n.label == null ? NULL : encNode(n.label);
+    const c_element_type = n.elementType == null ? NULL : encNode(n.elementType);
+    const idx = alloc();
+    tagAt(idx, 112);
+    slotAt(idx, 0, c_label);
+    slotAt(idx, 1, c_element_type);
+    flagsAt(idx, 0 | (n.optional ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_optional_type(n) {
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 113);
+    slotAt(idx, 0, c_type_annotation);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_rest_type(n) {
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 114);
+    slotAt(idx, 0, c_type_annotation);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_jsdoc_nullable_type(n) {
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 115);
+    slotAt(idx, 0, c_type_annotation);
+    flagsAt(idx, 0 | (n.postfix ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_jsdoc_non_nullable_type(n) {
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 116);
+    slotAt(idx, 0, c_type_annotation);
+    flagsAt(idx, 0 | (n.postfix ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_jsdoc_unknown_type(n) {
+    const idx = alloc();
+    tagAt(idx, 117);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_union_type(n) {
+    const c_types = encArr(n.types, encNode);
+    const idx = alloc();
+    tagAt(idx, 118);
+    f0At(idx, c_types.len);
+    slotAt(idx, 0, c_types.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_intersection_type(n) {
+    const c_types = encArr(n.types, encNode);
+    const idx = alloc();
+    tagAt(idx, 119);
+    f0At(idx, c_types.len);
+    slotAt(idx, 0, c_types.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_conditional_type(n) {
+    const c_check_type = n.checkType == null ? NULL : encNode(n.checkType);
+    const c_extends_type = n.extendsType == null ? NULL : encNode(n.extendsType);
+    const c_true_type = n.trueType == null ? NULL : encNode(n.trueType);
+    const c_false_type = n.falseType == null ? NULL : encNode(n.falseType);
+    const idx = alloc();
+    tagAt(idx, 120);
+    slotAt(idx, 0, c_check_type);
+    slotAt(idx, 1, c_extends_type);
+    slotAt(idx, 2, c_true_type);
+    slotAt(idx, 3, c_false_type);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_infer_type(n) {
+    const c_type_parameter = n.typeParameter == null ? NULL : encNode(n.typeParameter);
+    const idx = alloc();
+    tagAt(idx, 121);
+    slotAt(idx, 0, c_type_parameter);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_type_operator(n) {
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 122);
+    slotAt(idx, 0, c_type_annotation);
+    flagsAt(idx, 0 | (TS_TYPE_OPERATORS_INV[n.operator] | 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_parenthesized_type(n) {
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 123);
+    slotAt(idx, 0, c_type_annotation);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_function_type(n) {
+    const tp = n.typeParameters == null ? NULL : encNode(n.typeParameters);
+    const params = encFormalParameters(n.params);
+    const rt_ = n.returnType == null ? NULL : encNode(n.returnType);
+    const idx = alloc();
+    tagAt(idx, 124);
+    slotAt(idx, 0, tp); slotAt(idx, 1, params); slotAt(idx, 2, rt_);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_constructor_type(n) {
+    const tp = n.typeParameters == null ? NULL : encNode(n.typeParameters);
+    const params = encFormalParameters(n.params);
+    const rt_ = n.returnType == null ? NULL : encNode(n.returnType);
+    const idx = alloc();
+    tagAt(idx, 125);
+    slotAt(idx, 0, tp); slotAt(idx, 1, params); slotAt(idx, 2, rt_);
+    flagsAt(idx, n.abstract ? 1 : 0);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_type_predicate(n) {
+    const c_parameter_name = n.parameterName == null ? NULL : encNode(n.parameterName);
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 126);
+    slotAt(idx, 0, c_parameter_name);
+    slotAt(idx, 1, c_type_annotation);
+    flagsAt(idx, 0 | (n.asserts ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_type_literal(n) {
+    const c_members = encArr(n.members, encNode);
+    const idx = alloc();
+    tagAt(idx, 127);
+    f0At(idx, c_members.len);
+    slotAt(idx, 0, c_members.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_mapped_type(n) {
+    const k = encNode(n.key);
+    const c = encNode(n.constraint);
+    const nt = n.nameType == null ? NULL : encNode(n.nameType);
+    const ta = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 128);
+    slotAt(idx, 0, k); slotAt(idx, 1, c); slotAt(idx, 2, nt); slotAt(idx, 3, ta);
+    flagsAt(idx,
+      (TS_MAPPED_OPTIONAL_INV(n.optional) << 0)
+      | (TS_MAPPED_READONLY_INV(n.readonly) << 2));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_property_signature(n) {
+    const k = n.computed ? encNode(n.key) : encName(n.key);
+    const ta = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 129);
+    slotAt(idx, 0, k); slotAt(idx, 1, ta);
+    flagsAt(idx,
+      (n.computed ? 1 : 0)
+      | (n.optional ? 2 : 0)
+      | (n.readonly ? 4 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_method_signature(n) {
+    const k = n.computed ? encNode(n.key) : encName(n.key);
+    const tp = n.typeParameters == null ? NULL : encNode(n.typeParameters);
+    const params = encFormalParameters(n.params);
+    const rt_ = n.returnType == null ? NULL : encNode(n.returnType);
+    const idx = alloc();
+    tagAt(idx, 130);
+    slotAt(idx, 0, k);
+    slotAt(idx, 1, tp);
+    slotAt(idx, 2, params);
+    slotAt(idx, 3, rt_);
+    flagsAt(idx,
+      (n.computed ? 4 : 0)
+      | (n.optional ? 8 : 0)
+      | ((TS_METHOD_SIGNATURE_KINDS_INV[n.kind] | 0) << 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_call_signature_declaration(n) {
+    const tp = n.typeParameters == null ? NULL : encNode(n.typeParameters);
+    const params = encFormalParameters(n.params);
+    const rt_ = n.returnType == null ? NULL : encNode(n.returnType);
+    const idx = alloc();
+    tagAt(idx, 131);
+    slotAt(idx, 0, tp); slotAt(idx, 1, params); slotAt(idx, 2, rt_);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_construct_signature_declaration(n) {
+    const tp = n.typeParameters == null ? NULL : encNode(n.typeParameters);
+    const params = encFormalParameters(n.params);
+    const rt_ = n.returnType == null ? NULL : encNode(n.returnType);
+    const idx = alloc();
+    tagAt(idx, 132);
+    slotAt(idx, 0, tp); slotAt(idx, 1, params); slotAt(idx, 2, rt_);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_index_signature(n) {
+    const ps = encArr(n.parameters, encBindingTarget);
+    const ta = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 133);
+    f0At(idx, ps.len);
+    slotAt(idx, 0, ps.start);
+    slotAt(idx, 1, ta);
+    flagsAt(idx, (n.readonly ? 1 : 0) | (n.static ? 2 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_type_alias_declaration(n) {
+    const c_id = n.id == null ? NULL : encBindingTarget(n.id);
+    const c_type_parameters = n.typeParameters == null ? NULL : encNode(n.typeParameters);
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 134);
+    slotAt(idx, 0, c_id);
+    slotAt(idx, 1, c_type_parameters);
+    slotAt(idx, 2, c_type_annotation);
+    flagsAt(idx, 0 | (n.declare ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_interface_declaration(n) {
+    const c_id = n.id == null ? NULL : encBindingTarget(n.id);
+    const c_type_parameters = n.typeParameters == null ? NULL : encNode(n.typeParameters);
+    const c_extends = encArr(n.extends, encNode);
+    const c_body = n.body == null ? NULL : encNode(n.body);
+    const idx = alloc();
+    tagAt(idx, 135);
+    slotAt(idx, 0, c_id);
+    slotAt(idx, 1, c_type_parameters);
+    f0At(idx, c_extends.len);
+    slotAt(idx, 2, c_extends.start);
+    slotAt(idx, 3, c_body);
+    flagsAt(idx, 0 | (n.declare ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_interface_body(n) {
+    const c_body = encArr(n.body, encNode);
+    const idx = alloc();
+    tagAt(idx, 136);
+    f0At(idx, c_body.len);
+    slotAt(idx, 0, c_body.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_interface_heritage(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const c_type_arguments = n.typeArguments == null ? NULL : encNode(n.typeArguments);
+    const idx = alloc();
+    tagAt(idx, 137);
+    slotAt(idx, 0, c_expression);
+    slotAt(idx, 1, c_type_arguments);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_class_implements(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const c_type_arguments = n.typeArguments == null ? NULL : encNode(n.typeArguments);
+    const idx = alloc();
+    tagAt(idx, 138);
+    slotAt(idx, 0, c_expression);
+    slotAt(idx, 1, c_type_arguments);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_enum_declaration(n) {
+    const c_id = n.id == null ? NULL : encBindingTarget(n.id);
+    const c_body = n.body == null ? NULL : encNode(n.body);
+    const idx = alloc();
+    tagAt(idx, 139);
+    slotAt(idx, 0, c_id);
+    slotAt(idx, 1, c_body);
+    flagsAt(idx, 0 | (n.const ? 1 : 0) | (n.declare ? 2 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_enum_body(n) {
+    const c_members = encArr(n.members, encNode);
+    const idx = alloc();
+    tagAt(idx, 140);
+    f0At(idx, c_members.len);
+    slotAt(idx, 0, c_members.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_enum_member(n) {
+    const id = n.computed ? encNode(n.id) : encName(n.id);
+    const init = n.initializer == null ? NULL : encNode(n.initializer);
+    const idx = alloc();
+    tagAt(idx, 141);
+    slotAt(idx, 0, id); slotAt(idx, 1, init);
+    flagsAt(idx, n.computed ? 1 : 0);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_module_declaration(n) {
+    const id = encNode(n.id);
+    const body = n.body == null ? NULL : encNode(n.body);
+    const idx = alloc();
+    tagAt(idx, 142);
+    slotAt(idx, 0, id);
+    slotAt(idx, 1, body);
+    flagsAt(idx, ((TS_MODULE_KINDS_INV[n.kind] | 0) << 0) | (n.declare ? 2 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_module_block(n) {
+    const c_body = encArr(n.body, encNode);
+    const idx = alloc();
+    tagAt(idx, 143);
+    f0At(idx, c_body.len);
+    slotAt(idx, 0, c_body.start);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_global_declaration(n) {
+    const id = encNode(n.id);
+    const body = encNode(n.body);
+    const idx = alloc();
+    tagAt(idx, 144);
+    slotAt(idx, 0, id);
+    slotAt(idx, 1, body);
+    flagsAt(idx, n.declare ? 1 : 0);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_parameter_property(n) {
+    const c_decorators = encArr(n.decorators, encNode);
+    const c_parameter = n.parameter == null ? NULL : encBindingTarget(n.parameter);
+    const idx = alloc();
+    tagAt(idx, 145);
+    f0At(idx, c_decorators.len);
+    slotAt(idx, 0, c_decorators.start);
+    slotAt(idx, 1, c_parameter);
+    flagsAt(idx, 0 | (n.override ? 1 : 0) | (n.readonly ? 2 : 0) | (ACCESSIBILITY_INV(n.accessibility) << 2));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_this_parameter(n) {
+    const ta = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 146);
+    slotAt(idx, 0, ta);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_as_expression(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 147);
+    slotAt(idx, 0, c_expression);
+    slotAt(idx, 1, c_type_annotation);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_satisfies_expression(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const idx = alloc();
+    tagAt(idx, 148);
+    slotAt(idx, 0, c_expression);
+    slotAt(idx, 1, c_type_annotation);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_type_assertion(n) {
+    const c_type_annotation = n.typeAnnotation == null ? NULL : encNode(n.typeAnnotation);
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const idx = alloc();
+    tagAt(idx, 149);
+    slotAt(idx, 0, c_type_annotation);
+    slotAt(idx, 1, c_expression);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_non_null_expression(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const idx = alloc();
+    tagAt(idx, 150);
+    slotAt(idx, 0, c_expression);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_instantiation_expression(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const c_type_arguments = n.typeArguments == null ? NULL : encNode(n.typeArguments);
+    const idx = alloc();
+    tagAt(idx, 151);
+    slotAt(idx, 0, c_expression);
+    slotAt(idx, 1, c_type_arguments);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_export_assignment(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const idx = alloc();
+    tagAt(idx, 152);
+    slotAt(idx, 0, c_expression);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_namespace_export_declaration(n) {
+    const c_id = n.id == null ? NULL : encNode(n.id);
+    const idx = alloc();
+    tagAt(idx, 153);
+    slotAt(idx, 0, c_id);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_import_equals_declaration(n) {
+    const c_id = n.id == null ? NULL : encBindingTarget(n.id);
+    const c_module_reference = n.moduleReference == null ? NULL : encNode(n.moduleReference);
+    const idx = alloc();
+    tagAt(idx, 154);
+    slotAt(idx, 0, c_id);
+    slotAt(idx, 1, c_module_reference);
+    flagsAt(idx, 0 | (IMPORT_EXPORT_KINDS_INV[n.importKind] | 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_ts_external_module_reference(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const idx = alloc();
+    tagAt(idx, 155);
+    slotAt(idx, 0, c_expression);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_element(n) {
+    const c_opening_element = n.openingElement == null ? NULL : encNode(n.openingElement);
+    const c_children = encArr(n.children, encNode);
+    const c_closing_element = n.closingElement == null ? NULL : encNode(n.closingElement);
+    const idx = alloc();
+    tagAt(idx, 156);
+    slotAt(idx, 0, c_opening_element);
+    f0At(idx, c_children.len);
+    slotAt(idx, 1, c_children.start);
+    slotAt(idx, 2, c_closing_element);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_opening_element(n) {
+    const c_name = n.name == null ? NULL : encNode(n.name);
+    const c_attributes = encArr(n.attributes, encNode);
+    const c_type_arguments = n.typeArguments == null ? NULL : encNode(n.typeArguments);
+    const idx = alloc();
+    tagAt(idx, 157);
+    slotAt(idx, 0, c_name);
+    f0At(idx, c_attributes.len);
+    slotAt(idx, 1, c_attributes.start);
+    slotAt(idx, 2, c_type_arguments);
+    flagsAt(idx, 0 | (n.selfClosing ? 1 : 0));
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_closing_element(n) {
+    const c_name = n.name == null ? NULL : encNode(n.name);
+    const idx = alloc();
+    tagAt(idx, 158);
+    slotAt(idx, 0, c_name);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_fragment(n) {
+    const c_opening_fragment = n.openingFragment == null ? NULL : encNode(n.openingFragment);
+    const c_children = encArr(n.children, encNode);
+    const c_closing_fragment = n.closingFragment == null ? NULL : encNode(n.closingFragment);
+    const idx = alloc();
+    tagAt(idx, 159);
+    slotAt(idx, 0, c_opening_fragment);
+    f0At(idx, c_children.len);
+    slotAt(idx, 1, c_children.start);
+    slotAt(idx, 2, c_closing_fragment);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_opening_fragment(n) {
+    const idx = alloc();
+    tagAt(idx, 160);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_closing_fragment(n) {
+    const idx = alloc();
+    tagAt(idx, 161);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_identifier(n) {
+    const c_name = encStr(n.name);
+    const idx = alloc();
+    tagAt(idx, 162);
+    slotAt(idx, 0, c_name.start);
+    slotAt(idx, 1, c_name.end);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_namespaced_name(n) {
+    const c_namespace = n.namespace == null ? NULL : encNode(n.namespace);
+    const c_name = n.name == null ? NULL : encNode(n.name);
+    const idx = alloc();
+    tagAt(idx, 163);
+    slotAt(idx, 0, c_namespace);
+    slotAt(idx, 1, c_name);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_member_expression(n) {
+    const c_object = n.object == null ? NULL : encNode(n.object);
+    const c_property = n.property == null ? NULL : encNode(n.property);
+    const idx = alloc();
+    tagAt(idx, 164);
+    slotAt(idx, 0, c_object);
+    slotAt(idx, 1, c_property);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_attribute(n) {
+    const c_name = n.name == null ? NULL : encNode(n.name);
+    const c_value = n.value == null ? NULL : encNode(n.value);
+    const idx = alloc();
+    tagAt(idx, 165);
+    slotAt(idx, 0, c_name);
+    slotAt(idx, 1, c_value);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_spread_attribute(n) {
+    const c_argument = n.argument == null ? NULL : encNode(n.argument);
+    const idx = alloc();
+    tagAt(idx, 166);
+    slotAt(idx, 0, c_argument);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_expression_container(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const idx = alloc();
+    tagAt(idx, 167);
+    slotAt(idx, 0, c_expression);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_empty_expression(n) {
+    const idx = alloc();
+    tagAt(idx, 168);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_text(n) {
+    const v = encStr(n.value || "");
+    const idx = alloc();
+    tagAt(idx, 169);
+    slotAt(idx, 0, v.start); slotAt(idx, 1, v.end);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  function enc_jsx_spread_child(n) {
+    const c_expression = n.expression == null ? NULL : encNode(n.expression);
+    const idx = alloc();
+    tagAt(idx, 170);
+    slotAt(idx, 0, c_expression);
+    spanAt(idx, asStart(n), asEnd(n));
+    recordComments(n, idx);
+    return idx;
+  }
+  const commentsByIdx = new Map();
+  function encNode(n) {
+    if (n == null) return NULL;
+    switch (n.type) {
+      case "Identifier": return enc_identifier_reference(n);
+      case "PrivateIdentifier": return enc_private_identifier(n);
+      case "Literal": {
+        if (n.regex) return enc_regexp_literal(n);
+        if (typeof n.bigint === "string") return enc_bigint_literal(n);
+        const v = n.value;
+        if (v === null) return typeof n.raw === "string" && n.raw !== "null"
+          ? enc_numeric_literal(n)
+          : enc_null_literal(n);
+        if (typeof v === "boolean") return enc_boolean_literal(n);
+        if (typeof v === "string") return enc_string_literal(n);
+        if (typeof v === "number") return enc_numeric_literal(n);
+        throw new Error("yuku-codegen: unrecognised Literal value");
+      }
+      case "FunctionDeclaration": return enc_function(n, 0);
+      case "FunctionExpression": return enc_function(n, 1);
+      case "TSDeclareFunction": return enc_function(n, 2);
+      case "TSEmptyBodyFunctionExpression": return enc_function(n, 3);
+      case "ClassDeclaration": return enc_class(n, 0);
+      case "ClassExpression": return enc_class(n, 1);
+      case "MethodDefinition": return enc_method_definition(n, false);
+      case "TSAbstractMethodDefinition": return enc_method_definition(n, true);
+      case "PropertyDefinition": return enc_property_definition(n, false, false);
+      case "TSAbstractPropertyDefinition": return enc_property_definition(n, false, true);
+      case "AccessorProperty": return enc_property_definition(n, true, false);
+      case "TSAbstractAccessorProperty": return enc_property_definition(n, true, true);
+      case "RestElement": return enc_binding_rest_element(n);
+      case "TSModuleDeclaration": return n.global
+        ? enc_ts_global_declaration(n)
+        : enc_ts_module_declaration(n);
+      case "ExpressionStatement": return n.directive != null
+        ? enc_directive(n)
+        : enc_expression_statement(n);
+      case "SequenceExpression": return enc_sequence_expression(n);
+      case "ParenthesizedExpression": return enc_parenthesized_expression(n);
+      case "ArrowFunctionExpression": return enc_arrow_function_expression(n);
+      case "BlockStatement": return enc_block_statement(n);
+      case "BinaryExpression": return enc_binary_expression(n);
+      case "LogicalExpression": return enc_logical_expression(n);
+      case "ConditionalExpression": return enc_conditional_expression(n);
+      case "UnaryExpression": return enc_unary_expression(n);
+      case "UpdateExpression": return enc_update_expression(n);
+      case "AssignmentExpression": return enc_assignment_expression(n);
+      case "ArrayExpression": return enc_array_expression(n);
+      case "ObjectExpression": return enc_object_expression(n);
+      case "SpreadElement": return enc_spread_element(n);
+      case "Property": return enc_object_property(n);
+      case "MemberExpression": return enc_member_expression(n);
+      case "CallExpression": return enc_call_expression(n);
+      case "ChainExpression": return enc_chain_expression(n);
+      case "TaggedTemplateExpression": return enc_tagged_template_expression(n);
+      case "NewExpression": return enc_new_expression(n);
+      case "AwaitExpression": return enc_await_expression(n);
+      case "YieldExpression": return enc_yield_expression(n);
+      case "MetaProperty": return enc_meta_property(n);
+      case "Decorator": return enc_decorator(n);
+      case "ClassBody": return enc_class_body(n);
+      case "StaticBlock": return enc_static_block(n);
+      case "Super": return enc_super(n);
+      case "ThisExpression": return enc_this_expression(n);
+      case "TemplateLiteral": return enc_template_literal(n);
+      case "TemplateElement": return enc_template_element(n);
+      case "IfStatement": return enc_if_statement(n);
+      case "SwitchStatement": return enc_switch_statement(n);
+      case "SwitchCase": return enc_switch_case(n);
+      case "ForStatement": return enc_for_statement(n);
+      case "ForInStatement": return enc_for_in_statement(n);
+      case "ForOfStatement": return enc_for_of_statement(n);
+      case "WhileStatement": return enc_while_statement(n);
+      case "DoWhileStatement": return enc_do_while_statement(n);
+      case "BreakStatement": return enc_break_statement(n);
+      case "ContinueStatement": return enc_continue_statement(n);
+      case "LabeledStatement": return enc_labeled_statement(n);
+      case "WithStatement": return enc_with_statement(n);
+      case "ReturnStatement": return enc_return_statement(n);
+      case "ThrowStatement": return enc_throw_statement(n);
+      case "TryStatement": return enc_try_statement(n);
+      case "CatchClause": return enc_catch_clause(n);
+      case "DebuggerStatement": return enc_debugger_statement(n);
+      case "EmptyStatement": return enc_empty_statement(n);
+      case "VariableDeclaration": return enc_variable_declaration(n);
+      case "VariableDeclarator": return enc_variable_declarator(n);
+      case "AssignmentPattern": return enc_assignment_pattern(n);
+      case "ArrayPattern": return enc_array_pattern(n);
+      case "ObjectPattern": return enc_object_pattern(n);
+      case "Program": return enc_program(n);
+      case "ImportExpression": return enc_import_expression(n);
+      case "ImportDeclaration": return enc_import_declaration(n);
+      case "ImportSpecifier": return enc_import_specifier(n);
+      case "ImportDefaultSpecifier": return enc_import_default_specifier(n);
+      case "ImportNamespaceSpecifier": return enc_import_namespace_specifier(n);
+      case "ImportAttribute": return enc_import_attribute(n);
+      case "ExportNamedDeclaration": return enc_export_named_declaration(n);
+      case "ExportDefaultDeclaration": return enc_export_default_declaration(n);
+      case "ExportAllDeclaration": return enc_export_all_declaration(n);
+      case "ExportSpecifier": return enc_export_specifier(n);
+      case "TSTypeAnnotation": return enc_ts_type_annotation(n);
+      case "TSAnyKeyword": return enc_ts_any_keyword(n);
+      case "TSUnknownKeyword": return enc_ts_unknown_keyword(n);
+      case "TSNeverKeyword": return enc_ts_never_keyword(n);
+      case "TSVoidKeyword": return enc_ts_void_keyword(n);
+      case "TSNullKeyword": return enc_ts_null_keyword(n);
+      case "TSUndefinedKeyword": return enc_ts_undefined_keyword(n);
+      case "TSStringKeyword": return enc_ts_string_keyword(n);
+      case "TSNumberKeyword": return enc_ts_number_keyword(n);
+      case "TSBigIntKeyword": return enc_ts_bigint_keyword(n);
+      case "TSBooleanKeyword": return enc_ts_boolean_keyword(n);
+      case "TSSymbolKeyword": return enc_ts_symbol_keyword(n);
+      case "TSObjectKeyword": return enc_ts_object_keyword(n);
+      case "TSIntrinsicKeyword": return enc_ts_intrinsic_keyword(n);
+      case "TSThisType": return enc_ts_this_type(n);
+      case "TSTypeReference": return enc_ts_type_reference(n);
+      case "TSQualifiedName": return enc_ts_qualified_name(n);
+      case "TSTypeQuery": return enc_ts_type_query(n);
+      case "TSImportType": return enc_ts_import_type(n);
+      case "TSTypeParameter": return enc_ts_type_parameter(n);
+      case "TSTypeParameterDeclaration": return enc_ts_type_parameter_declaration(n);
+      case "TSTypeParameterInstantiation": return enc_ts_type_parameter_instantiation(n);
+      case "TSLiteralType": return enc_ts_literal_type(n);
+      case "TSTemplateLiteralType": return enc_ts_template_literal_type(n);
+      case "TSArrayType": return enc_ts_array_type(n);
+      case "TSIndexedAccessType": return enc_ts_indexed_access_type(n);
+      case "TSTupleType": return enc_ts_tuple_type(n);
+      case "TSNamedTupleMember": return enc_ts_named_tuple_member(n);
+      case "TSOptionalType": return enc_ts_optional_type(n);
+      case "TSRestType": return enc_ts_rest_type(n);
+      case "TSJSDocNullableType": return enc_ts_jsdoc_nullable_type(n);
+      case "TSJSDocNonNullableType": return enc_ts_jsdoc_non_nullable_type(n);
+      case "TSJSDocUnknownType": return enc_ts_jsdoc_unknown_type(n);
+      case "TSUnionType": return enc_ts_union_type(n);
+      case "TSIntersectionType": return enc_ts_intersection_type(n);
+      case "TSConditionalType": return enc_ts_conditional_type(n);
+      case "TSInferType": return enc_ts_infer_type(n);
+      case "TSTypeOperator": return enc_ts_type_operator(n);
+      case "TSParenthesizedType": return enc_ts_parenthesized_type(n);
+      case "TSFunctionType": return enc_ts_function_type(n);
+      case "TSConstructorType": return enc_ts_constructor_type(n);
+      case "TSTypePredicate": return enc_ts_type_predicate(n);
+      case "TSTypeLiteral": return enc_ts_type_literal(n);
+      case "TSMappedType": return enc_ts_mapped_type(n);
+      case "TSPropertySignature": return enc_ts_property_signature(n);
+      case "TSMethodSignature": return enc_ts_method_signature(n);
+      case "TSCallSignatureDeclaration": return enc_ts_call_signature_declaration(n);
+      case "TSConstructSignatureDeclaration": return enc_ts_construct_signature_declaration(n);
+      case "TSIndexSignature": return enc_ts_index_signature(n);
+      case "TSTypeAliasDeclaration": return enc_ts_type_alias_declaration(n);
+      case "TSInterfaceDeclaration": return enc_ts_interface_declaration(n);
+      case "TSInterfaceBody": return enc_ts_interface_body(n);
+      case "TSInterfaceHeritage": return enc_ts_interface_heritage(n);
+      case "TSClassImplements": return enc_ts_class_implements(n);
+      case "TSEnumDeclaration": return enc_ts_enum_declaration(n);
+      case "TSEnumBody": return enc_ts_enum_body(n);
+      case "TSEnumMember": return enc_ts_enum_member(n);
+      case "TSModuleBlock": return enc_ts_module_block(n);
+      case "TSParameterProperty": return enc_ts_parameter_property(n);
+      case "TSAsExpression": return enc_ts_as_expression(n);
+      case "TSSatisfiesExpression": return enc_ts_satisfies_expression(n);
+      case "TSTypeAssertion": return enc_ts_type_assertion(n);
+      case "TSNonNullExpression": return enc_ts_non_null_expression(n);
+      case "TSInstantiationExpression": return enc_ts_instantiation_expression(n);
+      case "TSExportAssignment": return enc_ts_export_assignment(n);
+      case "TSNamespaceExportDeclaration": return enc_ts_namespace_export_declaration(n);
+      case "TSImportEqualsDeclaration": return enc_ts_import_equals_declaration(n);
+      case "TSExternalModuleReference": return enc_ts_external_module_reference(n);
+      case "JSXElement": return enc_jsx_element(n);
+      case "JSXOpeningElement": return enc_jsx_opening_element(n);
+      case "JSXClosingElement": return enc_jsx_closing_element(n);
+      case "JSXFragment": return enc_jsx_fragment(n);
+      case "JSXOpeningFragment": return enc_jsx_opening_fragment(n);
+      case "JSXClosingFragment": return enc_jsx_closing_fragment(n);
+      case "JSXIdentifier": return enc_jsx_identifier(n);
+      case "JSXNamespacedName": return enc_jsx_namespaced_name(n);
+      case "JSXMemberExpression": return enc_jsx_member_expression(n);
+      case "JSXAttribute": return enc_jsx_attribute(n);
+      case "JSXSpreadAttribute": return enc_jsx_spread_attribute(n);
+      case "JSXExpressionContainer": return enc_jsx_expression_container(n);
+      case "JSXEmptyExpression": return enc_jsx_empty_expression(n);
+      case "JSXText": return enc_jsx_text(n);
+      case "JSXSpreadChild": return enc_jsx_spread_child(n);
+      default: throw new Error("yuku-codegen: unsupported ESTree node type: " + n.type);
+    }
+  }
+  const progIdx = encNode(root);
+  const POSITION_INV = { "before": 0, "after": 1, "inside": 2 };
+  const attached = commentsByIdx.size > 0;
+  let attachedCount = 0;
+  let offsetsBytes = null;
+  let attachedBytes = null;
+  if (attached) {
+    for (const arr of commentsByIdx.values()) attachedCount += arr.length;
+    const offsets = new Uint32Array(nodeCount + 1);
+    for (const [idx, arr] of commentsByIdx) offsets[idx] = arr.length;
+    let sum = 0;
+    for (let i = 0; i < nodeCount; i++) {
+      const c = offsets[i];
+      offsets[i] = sum;
+      sum += c;
+    }
+    offsets[nodeCount] = sum;
+    offsetsBytes = offsets.buffer;
+    attachedBytes = new ArrayBuffer(attachedCount * ATTACHED_COMMENT_SIZE);
+    const cU8 = new Uint8Array(attachedBytes);
+    const cDV = new DataView(attachedBytes);
+    const cursor = new Uint32Array(nodeCount);
+    for (const [idx, arr] of commentsByIdx) {
+      for (let j = 0; j < arr.length; j++) {
+        const c = arr[j];
+        const slot = offsets[idx] + cursor[idx]; cursor[idx]++;
+        let f = 0;
+        if (c.type === "Block") f |= 1;
+        f |= ((POSITION_INV[c.position] ?? 0) & 3) << 1;
+        if (c.sameLine) f |= 8;
+        const v = encStr(typeof c.value === "string" ? c.value : "");
+        const o = slot * ATTACHED_COMMENT_SIZE;
+        cU8[o + ATTACHED_COMMENT_FLAGS_OFFSET] = f;
+        cDV.setUint32(o + ATTACHED_COMMENT_VALUE_START_OFFSET, v.start, true);
+        cDV.setUint32(o + ATTACHED_COMMENT_VALUE_END_OFFSET, v.end, true);
+      }
+    }
+  }
+  const lineStartsCount = Array.isArray(lineStarts) ? lineStarts.length : 0;
+  let lineStartsBytes = null;
+  if (lineStartsCount > 0) {
+    lineStartsBytes = new ArrayBuffer(lineStartsCount * 4);
+    const lsDV = new DataView(lineStartsBytes);
+    for (let i = 0; i < lineStartsCount; i++) {
+      lsDV.setUint32(i * 4, lineStarts[i] >>> 0, true);
+    }
+  }
+  const totalNodeBytes = nodeCount * NODE_SIZE;
+  const totalExtraBytes = extraCount * 4;
+  const totalOffsetsBytes = attached ? (nodeCount + 1) * 4 : 0;
+  const totalAttachedBytes = attachedCount * ATTACHED_COMMENT_SIZE;
+  const totalLineStartsBytes = lineStartsCount * 4;
+  const finalSize =
+    HEADER_SIZE + totalNodeBytes + totalExtraBytes + poolLen +
+    totalOffsetsBytes + totalAttachedBytes + totalLineStartsBytes;
+  const out = new ArrayBuffer(finalSize);
+  const outU8 = new Uint8Array(out);
+  const outU32 = new Uint32Array(out, 0, (finalSize >>> 2));
+  outU32[0] = nodeCount;
+  outU32[1] = extraCount;
+  outU32[2] = poolLen;
+  outU32[3] = 0;
+  outU32[4] = 0;
+  outU32[5] = attachedCount;
+  outU32[6] = lineStartsCount;
+  outU32[7] = 0;
+  outU32[8] = progIdx;
+  outU32[9] = attached ? FLAG_ATTACHED_COMMENTS : 0;
+  outU32[10] = 0;
+  const nodesOff = HEADER_SIZE;
+  const extrasOff = nodesOff + totalNodeBytes;
+  const poolOff = extrasOff + totalExtraBytes;
+  const offsetsOff = poolOff + poolLen;
+  const attachedOff = offsetsOff + totalOffsetsBytes;
+  const lineStartsOff = attachedOff + totalAttachedBytes;
+  outU8.set(new Uint8Array(nodeAB, 0, totalNodeBytes), nodesOff);
+  outU8.set(new Uint8Array(extras.buffer, 0, totalExtraBytes), extrasOff);
+  outU8.set(pool.subarray(0, poolLen), poolOff);
+  if (offsetsBytes !== null) outU8.set(new Uint8Array(offsetsBytes), offsetsOff);
+  if (attachedBytes !== null) outU8.set(new Uint8Array(attachedBytes), attachedOff);
+  if (lineStartsBytes !== null) outU8.set(new Uint8Array(lineStartsBytes), lineStartsOff);
+  return out;
+}
+export { encode };