@ohm-js/wasm 0.2.0 → 0.3.1

package/dist/cli.js

@@ -1,11 +1,2234 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
 
 // src/cli.js
-import * as ohm from "ohm-js";
+import * as ohm2 from "ohm-js";
 import fs from "node:fs";
 import { basename } from "node:path";
 import { parseArgs } from "node:util";
-import { Compiler } from "./index.js";
+
+// ../../node_modules/.pnpm/@wasmgroundup+emit@1.0.2/node_modules/@wasmgroundup/emit/index.js
+var emit_exports = {};
+__export(emit_exports, {
+  CONTINUATION_BIT: () => CONTINUATION_BIT,
+  CUSTOM_NAME_SUB_SEC_FUNC: () => CUSTOM_NAME_SUB_SEC_FUNC,
+  CUSTOM_NAME_SUB_SEC_LOCAL: () => CUSTOM_NAME_SUB_SEC_LOCAL,
+  CUSTOM_NAME_SUB_SEC_MODULE: () => CUSTOM_NAME_SUB_SEC_MODULE,
+  I32_NEG_OFFSET: () => I32_NEG_OFFSET,
+  MAX_I32: () => MAX_I32,
+  MAX_U32: () => MAX_U32,
+  MIN_I32: () => MIN_I32,
+  MIN_U32: () => MIN_U32,
+  SECTION_ID_CODE: () => SECTION_ID_CODE,
+  SECTION_ID_CUSTOM: () => SECTION_ID_CUSTOM,
+  SECTION_ID_DATA: () => SECTION_ID_DATA,
+  SECTION_ID_ELEMENT: () => SECTION_ID_ELEMENT,
+  SECTION_ID_EXPORT: () => SECTION_ID_EXPORT,
+  SECTION_ID_FUNCTION: () => SECTION_ID_FUNCTION,
+  SECTION_ID_GLOBAL: () => SECTION_ID_GLOBAL,
+  SECTION_ID_IMPORT: () => SECTION_ID_IMPORT,
+  SECTION_ID_MEMORY: () => SECTION_ID_MEMORY,
+  SECTION_ID_START: () => SECTION_ID_START,
+  SECTION_ID_TABLE: () => SECTION_ID_TABLE,
+  SECTION_ID_TYPE: () => SECTION_ID_TYPE,
+  SEVEN_BIT_MASK_BIG_INT: () => SEVEN_BIT_MASK_BIG_INT,
+  blocktype: () => blocktype,
+  code: () => code,
+  codesec: () => codesec,
+  custom: () => custom,
+  customsec: () => customsec,
+  data: () => data,
+  datasec: () => datasec,
+  elem: () => elem,
+  elemsec: () => elemsec,
+  elemtype: () => elemtype,
+  export_: () => export_,
+  exportdesc: () => exportdesc,
+  exportsec: () => exportsec,
+  func: () => func,
+  funcidx: () => funcidx,
+  funcnamesubsec: () => funcnamesubsec,
+  funcsec: () => funcsec,
+  functype: () => functype,
+  global: () => global,
+  globalidx: () => globalidx,
+  globalsec: () => globalsec,
+  globaltype: () => globaltype,
+  i32: () => i32,
+  import_: () => import_,
+  importdesc: () => importdesc,
+  importsec: () => importsec,
+  indirectnameassoc: () => indirectnameassoc,
+  indirectnamemap: () => indirectnamemap,
+  instr: () => instr,
+  int32ToBytes: () => int32ToBytes,
+  labelidx: () => labelidx,
+  leb128: () => leb128,
+  limits: () => limits,
+  localidx: () => localidx,
+  localnamesubsec: () => localnamesubsec,
+  locals: () => locals,
+  magic: () => magic,
+  mem: () => mem,
+  memarg: () => memarg,
+  memidx: () => memidx,
+  memsec: () => memsec,
+  memtype: () => memtype,
+  module: () => module,
+  modulenamesubsec: () => modulenamesubsec,
+  mut: () => mut,
+  name: () => name,
+  nameassoc: () => nameassoc,
+  namedata: () => namedata,
+  namemap: () => namemap,
+  namesec: () => namesec,
+  namesubsection: () => namesubsection,
+  section: () => section,
+  sleb128: () => sleb128,
+  start: () => start,
+  startsec: () => startsec,
+  stringToBytes: () => stringToBytes,
+  table: () => table,
+  tableidx: () => tableidx,
+  tablesec: () => tablesec,
+  tabletype: () => tabletype,
+  typeidx: () => typeidx,
+  typesec: () => typesec,
+  u32: () => u32,
+  valtype: () => valtype,
+  vec: () => vec,
+  version: () => version
+});
+function stringToBytes(s) {
+  const bytes = new TextEncoder().encode(s);
+  return Array.from(bytes);
+}
+function magic() {
+  return stringToBytes("\0asm");
+}
+function version() {
+  return [1, 0, 0, 0];
+}
+var CONTINUATION_BIT = 128;
+var SEVEN_BIT_MASK_BIG_INT = 0b01111111n;
+function leb128(v) {
+  let val = BigInt(v);
+  let more = true;
+  const r = [];
+  while (more) {
+    const b = Number(val & SEVEN_BIT_MASK_BIG_INT);
+    val = val >> 7n;
+    more = val !== 0n;
+    if (more) {
+      r.push(b | CONTINUATION_BIT);
+    } else {
+      r.push(b);
+    }
+  }
+  return r;
+}
+var MIN_U32 = 0;
+var MAX_U32 = 2 ** 32 - 1;
+function u32(v) {
+  if (v < MIN_U32 || v > MAX_U32) {
+    throw Error(`Value out of range for u32: ${v}`);
+  }
+  return leb128(v);
+}
+function sleb128(v) {
+  let val = BigInt(v);
+  let more = true;
+  const r = [];
+  while (more) {
+    const b = Number(val & SEVEN_BIT_MASK_BIG_INT);
+    const signBitSet = !!(b & 64);
+    val = val >> 7n;
+    if (val === 0n && !signBitSet || val === -1n && signBitSet) {
+      more = false;
+      r.push(b);
+    } else {
+      r.push(b | CONTINUATION_BIT);
+    }
+  }
+  return r;
+}
+var MIN_I32 = -(2 ** 32 / 2);
+var MAX_I32 = 2 ** 32 / 2 - 1;
+var I32_NEG_OFFSET = 2 ** 32;
+function i32(v) {
+  if (v < MIN_I32 || v > MAX_U32) {
+    throw Error(`Value out of range for i32: ${v}`);
+  }
+  if (v > MAX_I32) {
+    return sleb128(v - I32_NEG_OFFSET);
+  }
+  return sleb128(v);
+}
+function section(id, contents) {
+  const sizeInBytes = contents.flat(Infinity).length;
+  return [id, u32(sizeInBytes), contents];
+}
+function vec(elements) {
+  return [u32(elements.length), elements];
+}
+var SECTION_ID_TYPE = 1;
+function functype(paramTypes, resultTypes) {
+  return [96, vec(paramTypes), vec(resultTypes)];
+}
+function typesec(functypes) {
+  return section(SECTION_ID_TYPE, vec(functypes));
+}
+var SECTION_ID_FUNCTION = 3;
+var typeidx = (x) => u32(x);
+function funcsec(typeidxs) {
+  return section(SECTION_ID_FUNCTION, vec(typeidxs));
+}
+var SECTION_ID_CODE = 10;
+function code(func2) {
+  const sizeInBytes = func2.flat(Infinity).length;
+  return [u32(sizeInBytes), func2];
+}
+function func(locals2, body) {
+  return [vec(locals2), body];
+}
+function codesec(codes) {
+  return section(SECTION_ID_CODE, vec(codes));
+}
+var instr = {
+  end: 11
+};
+var SECTION_ID_EXPORT = 7;
+function name(s) {
+  return vec(stringToBytes(s));
+}
+function export_(nm, exportdesc2) {
+  return [name(nm), exportdesc2];
+}
+function exportsec(exports) {
+  return section(SECTION_ID_EXPORT, vec(exports));
+}
+var funcidx = (x) => u32(x);
+var exportdesc = {
+  func(idx) {
+    return [0, funcidx(idx)];
+  }
+};
+function module(sections) {
+  return [magic(), version(), sections];
+}
+var valtype = {
+  i32: 127,
+  i64: 126,
+  f32: 125,
+  f64: 124
+};
+instr.i32 = { const: 65 };
+instr.i64 = { const: 66 };
+instr.f32 = { const: 67 };
+instr.f64 = { const: 68 };
+instr.i32.add = 106;
+instr.i32.sub = 107;
+instr.i32.mul = 108;
+instr.i32.div_s = 109;
+instr.local = {};
+instr.local.get = 32;
+instr.local.set = 33;
+instr.local.tee = 34;
+function locals(n, type) {
+  return [u32(n), type];
+}
+var localidx = (x) => u32(x);
+instr.drop = 26;
+instr.call = 16;
+instr.if = 4;
+instr.else = 5;
+var blocktype = { empty: 64, ...valtype };
+instr.i32.eq = 70;
+instr.i32.ne = 71;
+instr.i32.lt_s = 72;
+instr.i32.lt_u = 73;
+instr.i32.gt_s = 74;
+instr.i32.gt_u = 75;
+instr.i32.le_s = 76;
+instr.i32.le_u = 77;
+instr.i32.ge_s = 78;
+instr.i32.ge_u = 79;
+instr.i32.eqz = 69;
+instr.i32.and = 113;
+instr.i32.or = 114;
+var labelidx = u32;
+instr.block = 2;
+instr.loop = 3;
+instr.br = 12;
+instr.br_if = 13;
+var SECTION_ID_IMPORT = 2;
+function import_(mod, nm, d) {
+  return [name(mod), name(nm), d];
+}
+function importsec(ims) {
+  return section(SECTION_ID_IMPORT, vec(ims));
+}
+var importdesc = {
+  // x:typeidx
+  func(x) {
+    return [0, typeidx(x)];
+  }
+};
+var SECTION_ID_MEMORY = 5;
+function memsec(mems) {
+  return section(SECTION_ID_MEMORY, vec(mems));
+}
+function mem(memtype2) {
+  return memtype2;
+}
+function memtype(limits2) {
+  return limits2;
+}
+var limits = {
+  // n:u32
+  min(n) {
+    return [0, u32(n)];
+  },
+  // n:u32, m:u32
+  minmax(n, m) {
+    return [1, u32(n), u32(m)];
+  }
+};
+var memidx = u32;
+exportdesc.mem = (idx) => [2, memidx(idx)];
+instr.memory = {
+  size: 63,
+  // [] -> [i32]
+  grow: 64
+  // [i32] -> [i32]
+};
+instr.i32.load = 40;
+instr.i32.store = 54;
+function memarg(align, offset) {
+  return [u32(align), u32(offset)];
+}
+function int32ToBytes(v) {
+  return [v & 255, v >> 8 & 255, v >> 16 & 255, v >> 24 & 255];
+}
+instr.unreachable = 0;
+var SECTION_ID_DATA = 11;
+function data(x, e, bs) {
+  return [x, e, vec(bs)];
+}
+function datasec(segs) {
+  return section(SECTION_ID_DATA, vec(segs));
+}
+var SECTION_ID_CUSTOM = 0;
+function custom(name2, bytes) {
+  return [name2, bytes];
+}
+function customsec(custom2) {
+  return section(SECTION_ID_CUSTOM, custom2);
+}
+function namesec(namedata2) {
+  return customsec(custom(name("name"), namedata2));
+}
+function namedata(modulenamesubsec2, funcnamesubsec2, localnamesubsec2) {
+  return [modulenamesubsec2, funcnamesubsec2, localnamesubsec2];
+}
+var CUSTOM_NAME_SUB_SEC_MODULE = 0;
+function modulenamesubsec(n) {
+  return namesubsection(CUSTOM_NAME_SUB_SEC_MODULE, name(n));
+}
+var CUSTOM_NAME_SUB_SEC_FUNC = 1;
+function funcnamesubsec(namemap2) {
+  return namesubsection(CUSTOM_NAME_SUB_SEC_FUNC, namemap2);
+}
+function namesubsection(N, B) {
+  const flatB = B.flat(Infinity);
+  const size = u32(flatB.length);
+  return [N, size, flatB];
+}
+function namemap(nameassocs) {
+  return vec(nameassocs);
+}
+function nameassoc(idx, n) {
+  return [idx, name(n)];
+}
+var CUSTOM_NAME_SUB_SEC_LOCAL = 2;
+function localnamesubsec(indirectnamemap2) {
+  return namesubsection(CUSTOM_NAME_SUB_SEC_LOCAL, indirectnamemap2);
+}
+function indirectnamemap(indirectnameassocs) {
+  return vec(indirectnameassocs);
+}
+function indirectnameassoc(idx, namemap2) {
+  return [idx, namemap2];
+}
+var SECTION_ID_START = 8;
+var start = (x) => funcidx(x);
+function startsec(st) {
+  return section(SECTION_ID_START, st);
+}
+instr.global = {};
+instr.global.get = 35;
+instr.global.set = 36;
+var globalidx = (x) => u32(x);
+var SECTION_ID_GLOBAL = 6;
+var mut = {
+  const: 0,
+  var: 1
+};
+function globaltype(t, m) {
+  return [t, m];
+}
+function global(gt, e) {
+  return [gt, e];
+}
+function globalsec(globs) {
+  return section(SECTION_ID_GLOBAL, vec(globs));
+}
+var SECTION_ID_TABLE = 4;
+var elemtype = { funcref: 112 };
+function tabletype(et, lim) {
+  return [et, lim];
+}
+function table(tt) {
+  return tt;
+}
+function tablesec(tables) {
+  return section(SECTION_ID_TABLE, vec(tables));
+}
+var tableidx = (x) => u32(x);
+instr.call_indirect = 17;
+var SECTION_ID_ELEMENT = 9;
+function elem(x, e, ys) {
+  return [x, e, vec(ys)];
+}
+function elemsec(segs) {
+  return section(SECTION_ID_ELEMENT, vec(segs));
+}
+instr.nop = 1;
+instr.br_table = 14;
+instr.return = 15;
+instr.select = 27;
+instr.i64.load = 41;
+instr.f32.load = 42;
+instr.f64.load = 43;
+instr.i32.load8_s = 44;
+instr.i32.load8_u = 45;
+instr.i32.load16_s = 46;
+instr.i32.load16_u = 47;
+instr.i64.load8_s = 48;
+instr.i64.load8_u = 49;
+instr.i64.load16_s = 50;
+instr.i64.load16_u = 51;
+instr.i64.load32_s = 52;
+instr.i64.load32_u = 53;
+instr.i64.store = 55;
+instr.f32.store = 56;
+instr.f64.store = 57;
+instr.i32.store8 = 58;
+instr.i32.store16 = 59;
+instr.i64.store8 = 60;
+instr.i64.store16 = 61;
+instr.i64.store32 = 62;
+instr.i64.eqz = 80;
+instr.i64.eq = 81;
+instr.i64.ne = 82;
+instr.i64.lt_s = 83;
+instr.i64.lt_u = 84;
+instr.i64.gt_s = 85;
+instr.i64.gt_u = 86;
+instr.i64.le_s = 87;
+instr.i64.le_u = 88;
+instr.i64.ge_s = 89;
+instr.i64.ge_u = 90;
+instr.f32.eq = 91;
+instr.f32.ne = 92;
+instr.f32.lt = 93;
+instr.f32.gt = 94;
+instr.f32.le = 95;
+instr.f32.ge = 96;
+instr.f64.eq = 97;
+instr.f64.ne = 98;
+instr.f64.lt = 99;
+instr.f64.gt = 100;
+instr.f64.le = 101;
+instr.f64.ge = 102;
+instr.i32.clz = 103;
+instr.i32.ctz = 104;
+instr.i32.popcnt = 105;
+instr.i32.div_u = 110;
+instr.i32.rem_s = 111;
+instr.i32.rem_u = 112;
+instr.i32.xor = 115;
+instr.i32.shl = 116;
+instr.i32.shr_s = 117;
+instr.i32.shr_u = 118;
+instr.i32.rotl = 119;
+instr.i32.rotr = 120;
+instr.i64.clz = 121;
+instr.i64.ctz = 122;
+instr.i64.popcnt = 123;
+instr.i64.add = 124;
+instr.i64.sub = 125;
+instr.i64.mul = 126;
+instr.i64.div_s = 127;
+instr.i64.div_u = 128;
+instr.i64.rem_s = 129;
+instr.i64.rem_u = 130;
+instr.i64.and = 131;
+instr.i64.or = 132;
+instr.i64.xor = 133;
+instr.i64.shl = 134;
+instr.i64.shr_s = 135;
+instr.i64.shr_u = 136;
+instr.i64.rotl = 137;
+instr.i64.rotr = 138;
+instr.f32.abs = 139;
+instr.f32.neg = 140;
+instr.f32.ceil = 141;
+instr.f32.floor = 142;
+instr.f32.trunc = 143;
+instr.f32.nearest = 144;
+instr.f32.sqrt = 145;
+instr.f32.add = 146;
+instr.f32.sub = 147;
+instr.f32.mul = 148;
+instr.f32.div = 149;
+instr.f32.min = 150;
+instr.f32.max = 151;
+instr.f32.copysign = 152;
+instr.f64.abs = 153;
+instr.f64.neg = 154;
+instr.f64.ceil = 155;
+instr.f64.floor = 156;
+instr.f64.trunc = 157;
+instr.f64.nearest = 158;
+instr.f64.sqrt = 159;
+instr.f64.add = 160;
+instr.f64.sub = 161;
+instr.f64.mul = 162;
+instr.f64.div = 163;
+instr.f64.min = 164;
+instr.f64.max = 165;
+instr.f64.copysign = 166;
+instr.i32.wrap_i64 = 167;
+instr.i32.trunc_f32_s = 168;
+instr.i32.trunc_f32_u = 169;
+instr.i32.trunc_f64_s = 170;
+instr.i32.trunc_f64_u = 171;
+instr.i64.extend_i32_s = 172;
+instr.i64.extend_i32_u = 173;
+instr.i64.trunc_f32_s = 174;
+instr.i64.trunc_f32_u = 175;
+instr.i64.trunc_f64_s = 176;
+instr.i64.trunc_f64_u = 177;
+instr.f32.convert_i32_s = 178;
+instr.f32.convert_i32_u = 179;
+instr.f32.convert_i64_s = 180;
+instr.f32.convert_i64_u = 181;
+instr.f32.demote_f64 = 182;
+instr.f64.convert_i32_s = 183;
+instr.f64.convert_i32_u = 184;
+instr.f64.convert_i64_s = 185;
+instr.f64.convert_i64_u = 186;
+instr.f64.promote_f32 = 187;
+instr.i32.reinterpret_f32 = 188;
+instr.i64.reinterpret_f64 = 189;
+instr.f32.reinterpret_i32 = 190;
+instr.f64.reinterpret_i64 = 191;
+
+// src/Compiler.js
+import * as ohm from "ohm-js";
+
+// src/ir.ts
+var alt = (children) => ({
+  type: "Alt",
+  children,
+  outArity: outArity(children[0])
+});
+var any = () => ({ type: "Any" });
+var apply = (ruleName, children = []) => ({
+  type: "Apply",
+  ruleName,
+  children
+});
+var applyGeneralized = (ruleName, caseIdx) => ({
+  type: "ApplyGeneralized",
+  ruleName,
+  caseIdx
+});
+var caseInsensitive = (value) => ({
+  type: "CaseInsensitive",
+  value
+});
+var dispatch = (child, patterns) => ({
+  type: "Dispatch",
+  child,
+  patterns
+});
+var end = () => ({ type: "End" });
+var lex = (child) => ({
+  type: "Lex",
+  child,
+  outArity: outArity(child)
+});
+var lookahead = (child) => ({
+  type: "Lookahead",
+  child,
+  outArity: outArity(child)
+});
+var opt = (child) => ({ type: "Opt", child });
+var not = (child) => ({ type: "Not", child });
+var param = (index) => ({ type: "Param", index });
+var plus = (child) => ({ type: "Plus", child });
+var range = (lo, hi) => ({ type: "Range", lo, hi });
+var seq = (children) => ({
+  type: "Seq",
+  children,
+  outArity: children.reduce((acc, child) => acc + outArity(child), 0)
+});
+var star = (child) => ({ type: "Star", child });
+var terminal = (value, caseInsensitive2 = false) => ({
+  type: "Terminal",
+  value
+});
+var unicodeChar = (categoryOrProp) => ({
+  type: "UnicodeChar",
+  categoryOrProp
+});
+var liftedTerminal = (terminalId) => ({
+  type: "LiftedTerminal",
+  terminalId
+});
+function unreachable(x, msg) {
+  throw new Error(msg);
+}
+function checkNotNull(x, msg = "unexpected null value") {
+  if (x == null) throw new Error(msg);
+  return x;
+}
+function checkApplyLike(exp) {
+  return checkExprType(exp, "Apply", "LiftedTerminal", "Param");
+}
+function checkExprType(exp, ...types) {
+  if (!types.includes(exp.type)) {
+    throw new Error(`Expected one of [${types.join(", ")}], but got '${exp.type}'`);
+  }
+  return exp;
+}
+function substituteParams(exp, actuals) {
+  switch (exp.type) {
+    case "Param":
+      return checkNotNull(actuals[exp.index]);
+    case "Apply":
+      if (exp.children.length === 0) return exp;
+      return apply(
+        exp.ruleName,
+        exp.children.map((c) => {
+          const ans = substituteParams(c, actuals);
+          return checkApplyLike(ans);
+        })
+      );
+    case "Dispatch": {
+      const newChild = substituteParams(exp.child, actuals);
+      return dispatch(checkExprType(newChild, "Apply"), exp.patterns);
+    }
+    case "Alt":
+    case "Seq":
+      return {
+        type: exp.type,
+        children: exp.children.map((c) => substituteParams(c, actuals)),
+        outArity: exp.outArity
+      };
+    case "Lex":
+    case "Lookahead":
+      return {
+        type: exp.type,
+        child: substituteParams(exp.child, actuals),
+        outArity: exp.outArity
+      };
+    case "Not":
+    case "Opt":
+    case "Plus":
+    case "Star":
+      return {
+        type: exp.type,
+        child: substituteParams(exp.child, actuals)
+      };
+    case "Any":
+    case "ApplyGeneralized":
+    case "CaseInsensitive":
+    case "End":
+    case "LiftedTerminal":
+    case "Range":
+    case "Terminal":
+    case "UnicodeChar":
+      return exp;
+    default:
+      unreachable(exp, `not handled: ${exp}`);
+  }
+}
+function specializedName(app) {
+  if (app.type === "LiftedTerminal") {
+    return `$term$${app.terminalId}`;
+  }
+  const argsNames = app.children.map((c) => {
+    if (c.type === "Param") throw new Error(`unexpected Param`);
+    return specializedName(c);
+  }).join(",");
+  return app.ruleName + (argsNames.length > 0 ? `<${argsNames}>` : "");
+}
+function rewrite(exp, actions) {
+  const action = actions[exp.type];
+  if (action) {
+    return action(exp);
+  }
+  switch (exp.type) {
+    case "Alt":
+      return alt(exp.children.map((e) => rewrite(e, actions)));
+    case "Seq":
+      return seq(exp.children.map((e) => rewrite(e, actions)));
+    case "Any":
+    case "Apply":
+    case "ApplyGeneralized":
+    case "CaseInsensitive":
+    case "End":
+    case "LiftedTerminal":
+    case "Param":
+    case "Range":
+    case "Terminal":
+    case "UnicodeChar":
+      return exp;
+    case "Dispatch":
+      return { type: exp.type, child: rewrite(exp.child, actions), patterns: exp.patterns };
+    case "Lex":
+      return lex(rewrite(exp.child, actions));
+    case "Lookahead":
+      return lookahead(rewrite(exp.child, actions));
+    case "Not":
+      return not(rewrite(exp.child, actions));
+    case "Opt":
+      return opt(rewrite(exp.child, actions));
+    case "Plus":
+      return plus(rewrite(exp.child, actions));
+    case "Star":
+      return star(rewrite(exp.child, actions));
+    default:
+      unreachable(exp, `not handled: ${exp}`);
+  }
+}
+function toString(exp) {
+  switch (exp.type) {
+    case "Alt":
+      return `(${exp.children.map(toString).join(" | ")})`;
+    case "Seq":
+      return `(${exp.children.map(toString).join(" ")})`;
+    case "Any":
+      return "$any";
+    case "Apply":
+      return exp.children.length > 0 ? `${exp.ruleName}<${exp.children.map(toString).join(",")}>` : exp.ruleName;
+    case "ApplyGeneralized":
+      return `${exp.ruleName}<#${exp.caseIdx}>`;
+    case "CaseInsensitive":
+      return `$caseInsensitive<${JSON.stringify(exp.value)}>`;
+    case "End":
+      return "$end";
+    case "LiftedTerminal":
+      return `$term$${exp.terminalId}`;
+    case "Param":
+      return `$${exp.index}`;
+    case "Range":
+      return `${JSON.stringify(exp.lo)}..${JSON.stringify(exp.hi)}`;
+    case "Terminal":
+      return JSON.stringify(exp.value);
+    case "UnicodeChar":
+      return `$unicodeChar<${JSON.stringify(exp.categoryOrProp)}>`;
+    case "Dispatch":
+      return `$dispatch`;
+    // TODO: Improve this.
+    case "Lex":
+      return `#${toString(exp.child)}`;
+    case "Lookahead":
+      return `&${toString(exp.child)}`;
+    case "Not":
+      return `~${toString(exp.child)}`;
+    case "Opt":
+      return `${toString(exp.child)}?`;
+    case "Plus":
+      return `${toString(exp.child)}+`;
+    case "Star":
+      return `${toString(exp.child)}*`;
+    default:
+      unreachable(exp, `not handled: ${exp}`);
+  }
+}
+function outArity(exp) {
+  switch (exp.type) {
+    case "Alt":
+    case "Seq":
+    case "Lex":
+    case "Lookahead":
+      return exp.outArity;
+    case "Any":
+    case "Apply":
+    case "ApplyGeneralized":
+    case "CaseInsensitive":
+    case "End":
+    case "LiftedTerminal":
+    case "Param":
+    case "Range":
+    case "Terminal":
+    case "UnicodeChar":
+    case "Dispatch":
+      return 1;
+    case "Not":
+      return 0;
+    case "Opt":
+    case "Plus":
+    case "Star":
+      return 1;
+    default:
+      unreachable(exp, `not handled: ${exp}`);
+  }
+}
+
+// build/ohmRuntime.wasm_sections.ts
+function decodeBase64(str) {
+  const bytes = atob(str);
+  const result = [];
+  for (let i = 0; i < bytes.length; i++) {
+    result[i] = bytes.charCodeAt(i);
+  }
+  return result;
+}
+var destImportCount = 5;
+var startFuncidx = 51;
+var funcidxByName = {
+  dummy: 20,
+  match: 42,
+  evalApplyGeneralized: 43,
+  evalApplyNoMemo0: 44,
+  evalApply0: 41,
+  handleLeftRecursion: 40,
+  newTerminalNode: 45,
+  newNonterminalNode: 38,
+  newIterationNode: 46,
+  getBindingsLength: 47,
+  setBindingsLength: 48,
+  getCstRoot: 49,
+  doMatchUnicodeChar: 50
+};
+var typesec2 = {
+  entryCount: 10,
+  contents: decodeBase64(
+    "YAF/AX9gAn9/AGACf38Bf2AAAGAAAX9gAX8AYAR/f39/AGADf39/AGAFf39/f38Bf2AEf39/fwF/"
+  )
+};
+var importsec2 = {
+  entryCount: 5,
+  contents: decodeBase64(
+    "A2VudgVhYm9ydAAGCm9obVJ1bnRpbWUIcHJpbnRJMzIABQpvaG1SdW50aW1lD2ZpbGxJbnB1dEJ1ZmZlcgACCm9obVJ1bnRpbWUPaXNSdWxlU3ludGFjdGljAAAKb2htUnVudGltZRBtYXRjaFVuaWNvZGVDaGFyAAA="
+  )
+};
+var funcsec2 = {
+  entryCount: 47,
+  contents: decodeBase64("BQEAAQEBAQIHAQEBAQIDBQMDAwAAAAAAAgIGAAICAAIBCAcJAAACAAIIBAUEAAM=")
+};
+var globalsec2 = {
+  entryCount: 11,
+  contents: decodeBase64(
+    "fwFBAAt/AUEAC38BQQALfwBBAAt/AEEBC38AQQILfwFBAAt/AUEAC38AQQALfwFBAAt/AEGsgoggCw=="
+  )
+};
+var codesec2 = {
+  entryCount: 47,
+  contents: decodeBase64(
+    "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"
+  )
+};
+
+// src/Compiler.js
+var WASM_PAGE_SIZE = 64 * 1024;
+var DEBUG = process.env.OHM_DEBUG === "1";
+var FAST_SAVE_BINDINGS = true;
+var FAST_RESTORE_BINDINGS = true;
+var IMPLICIT_SPACE_SKIPPING = true;
+var EMIT_GENERALIZED_RULES = false;
+var { instr: instr2 } = emit_exports;
+var { pexprs } = ohm;
+var isNonNull = (x) => x != null;
+function assert(cond, msg) {
+  if (!cond) {
+    throw new Error(msg ?? "assertion failed");
+  }
+}
+function checkNotNull2(x, msg = "unexpected null value") {
+  assert(x != null, msg);
+  return x;
+}
+function checkNoUndefined(arr) {
+  assert(arr.indexOf(void 0) === -1, `found undefined @ ${arr.indexOf(void 0)}`);
+  return arr;
+}
+function setdefault(map, key, makeDefaultVal) {
+  if (!map.has(key)) map.set(key, makeDefaultVal());
+  return map.get(key);
+}
+var getNotNull = (map, k) => checkNotNull2(map.get(k), `not found: '${k}'`);
+var isApplyLike = (exp) => exp instanceof pexprs.Apply || exp instanceof pexprs.Param;
+function uniqueName(names, str) {
+  let name2 = str;
+  outer: if (names.has(str)) {
+    for (let i = 0; i < 1e3; i++) {
+      name2 = `${str}_${i}`;
+      if (!names.has(name2)) break outer;
+    }
+    throw new Error(`Unique name generation failed for ${str}`);
+  }
+  names.add(name2);
+  return name2;
+}
+function isSyntacticRule(ruleName) {
+  assert(ruleName[0] !== "$", ruleName);
+  return ruleName[0] === ruleName[0].toUpperCase();
+}
+var asciiChars = Array.from({ length: 128 }).map((_, i) => String.fromCharCode(i));
+var IndexedSet = class {
+  constructor() {
+    this._map = /* @__PURE__ */ new Map();
+  }
+  add(item) {
+    if (this._map.has(item)) {
+      return this._map.get(item);
+    }
+    const idx = this._map.size;
+    this._map.set(checkNotNull2(item), idx);
+    return idx;
+  }
+  getIndex(item) {
+    return this._map.get(item);
+  }
+  has(item) {
+    return this._map.has(item);
+  }
+  get size() {
+    return this._map.size;
+  }
+  keys() {
+    return [...this._map.keys()];
+  }
+  values() {
+    return [...this._map.keys()];
+  }
+  [Symbol.iterator]() {
+    return this._map[Symbol.iterator]();
+  }
+};
+function collectParams(exp, seen = /* @__PURE__ */ new Set()) {
+  switch (exp.constructor) {
+    case pexprs.Param:
+      if (!seen.has(exp.index)) {
+        seen.add(exp.index);
+        return [exp];
+      }
+      return [];
+    case pexprs.Alt:
+      return exp.terms.flatMap((e) => collectParams(e, seen));
+    case pexprs.Apply:
+      return exp.args.flatMap((e) => collectParams(e, seen));
+    case pexprs.Lookahead:
+    case pexprs.Not:
+    case pexprs.Opt:
+    case pexprs.Plus:
+    case pexprs.Seq:
+      return exp.factors.flatMap((e) => collectParams(e, seen));
+    case pexprs.Star:
+      return collectParams(exp.expr, seen);
+    case pexprs.Range:
+    case pexprs.Terminal:
+    case pexprs.UnicodeChar:
+      return [];
+    default:
+      throw new Error(`not handled: ${exp.constructor.name}`);
+  }
+}
+var prebuiltFuncidx = (nm) => checkNotNull2(funcidxByName[nm]);
+function mergeSections(sectionId, prebuiltSec, els) {
+  const count = prebuiltSec.entryCount + els.length;
+  return section(sectionId, [u32(count), prebuiltSec.contents, els]);
+}
+function functypeToString(paramTypes, resultTypes) {
+  const toStr = (t) => checkNotNull2(["f64", "f32", "i64", "i32"][t - valtype.f64]);
+  const params = paramTypes.map(toStr).join(",");
+  const results = resultTypes.map(toStr).join(",");
+  return "[" + params + "][" + results + "]";
+}
+var TypeMap = class {
+  constructor(startIdx = 0) {
+    this._map = /* @__PURE__ */ new Map();
+    this._startIdx = startIdx;
+  }
+  add(paramTypes, resultTypes) {
+    const key = functypeToString(paramTypes, resultTypes);
+    if (this._map.has(key)) {
+      return this._map.get(key)[0];
+    }
+    const idx = this._startIdx + this._map.size;
+    this._map.set(key, [idx, functype(paramTypes, resultTypes)]);
+    return idx;
+  }
+  addDecls(decls) {
+    for (const { paramTypes, resultTypes } of decls) {
+      this.add(paramTypes, resultTypes);
+    }
+  }
+  getIdx(paramTypes, resultTypes) {
+    const key = functypeToString(paramTypes, resultTypes);
+    return checkNotNull2(this._map.get(key))[0];
+  }
+  getIdxForDecl(decl) {
+    return this.getIdx(decl.paramTypes, decl.resultTypes);
+  }
+  getTypes() {
+    return [...this._map.values()].map(([_, t]) => t);
+  }
+};
+var Assembler = class _Assembler {
+  constructor(typeMap) {
+    this._globals = /* @__PURE__ */ new Map();
+    this._functionDecls = [];
+    this._blockStack = [];
+    this._code = [];
+    this._locals = void 0;
+    this._typeMap = typeMap;
+  }
+  addBlocktype(paramTypes, resultTypes) {
+    this._typeMap.add(paramTypes, resultTypes);
+  }
+  blocktype(paramTypes, resultTypes) {
+    const idx = this._typeMap.getIdx(paramTypes, resultTypes);
+    assert(idx !== -1, `Unknown blocktype: '${functypeToString(paramTypes, resultTypes)}'`);
+    return i32(idx);
+  }
+  doEmit(thunk) {
+    const oldCode = this._code;
+    this._code = [];
+    thunk();
+    const body = [...this._code, instr2.end];
+    this._code = oldCode;
+    return body;
+  }
+  addGlobal(name2, type, mut2, initThunk) {
+    assert(!this._globals.has(name2), `Global '${name2}' already exists`);
+    const idx = this._globals.size;
+    const initExpr = this.doEmit(initThunk);
+    this._globals.set(name2, { idx, type, mut: mut2, initExpr });
+    return idx;
+  }
+  addLocal(name2, type) {
+    assert(!this._locals.has(name2), `Local '${name2}' already exists`);
+    assert(type === valtype.i32, `invalid local type: ${type}`);
+    const idx = this._locals.size;
+    this._locals.set(name2, idx);
+    return idx;
+  }
+  addFunction(name2, paramTypes, resultTypes, bodyFn) {
+    this._locals = /* @__PURE__ */ new Map();
+    paramTypes.forEach((t, i) => {
+      this.addLocal(`__arg${i}`, t);
+    });
+    bodyFn(this);
+    this._functionDecls.push({
+      name: name2,
+      paramTypes,
+      resultTypes,
+      locals: [locals(this._locals.size, valtype.i32)],
+      // TODO: Support other types?
+      body: [...this._code, instr2.end]
+    });
+    this._code = [];
+    this._locals = void 0;
+  }
+  // Pure codegen helpers (used to generate the function bodies).
+  globalidx(name2) {
+    const { idx } = checkNotNull2(this._globals.get(name2), `Unknown global: ${name2}`);
+    return idx;
+  }
+  localidx(name2) {
+    return checkNotNull2(this._locals.get(name2), `Unknown local: ${name2}`);
+  }
+  emit(...bytes) {
+    this._code.push(...checkNoUndefined(bytes.flat(Infinity)));
+  }
+  block(bt, bodyThunk, label = "") {
+    this._blockOnly(bt, label);
+    bodyThunk();
+    this._endBlock();
+  }
+  // Prefer to use `block`, but for some cases it's more convenient to emit
+  // the block and the end separately.
+  // Note: `label` (if specified) is not unique (e.g., 'pexprEnd').
+  _blockOnly(bt, label) {
+    this.emit(instr2.block, bt);
+    this._blockStack.push(label ? `block:${label}` : "block");
+  }
+  // This should always be paired with `blockOnly`.
+  _endBlock() {
+    const what = this._blockStack.pop().split(":")[0];
+    assert(what === "block", "Invalid endBlock");
+    this.emit(instr2.end);
+  }
+  loop(bt, bodyThunk) {
+    this.emit(instr2.loop, bt);
+    this._blockStack.push("loop");
+    bodyThunk();
+    this._blockStack.pop();
+    this.emit(instr2.end);
+  }
+  if(bt, bodyThunk) {
+    this.ifElse(bt, bodyThunk);
+  }
+  ifElse(bt, thenThunk, elseThunk = void 0) {
+    this.emit(instr2.if, bt);
+    this._blockStack.push("if");
+    thenThunk();
+    if (elseThunk) {
+      this.emit(instr2.else);
+      elseThunk();
+    }
+    this._blockStack.pop();
+    this.emit(instr2.end);
+  }
+  ifFalse(bt, bodyThunk) {
+    this.emit(instr2.i32.eqz);
+    this.if(bt, bodyThunk);
+  }
+  br(depth) {
+    this.emit(instr2.br, labelidx(depth));
+  }
+  i32Add() {
+    this.emit(instr2.i32.add);
+  }
+  i32Const(value) {
+    this.emit(instr2.i32.const, i32(value));
+  }
+  i32Load(offset = 0) {
+    this.emit(instr2.i32.load, memarg(_Assembler.ALIGN_4_BYTES, offset));
+  }
+  i32Load8u(offset = 0) {
+    this.emit(instr2.i32.load8_u, memarg(_Assembler.ALIGN_1_BYTE, offset));
+  }
+  i32Mul() {
+    this.emit(instr2.i32.mul);
+  }
+  i32Eq() {
+    this.emit(instr2.i32.eq);
+  }
+  i32Ne() {
+    this.emit(instr2.i32.ne);
+  }
+  // Store [addr:i32, val:i32] -> []
+  i32Store(offset = 0) {
+    this.emit(instr2.i32.store, memarg(_Assembler.ALIGN_4_BYTES, offset));
+  }
+  i32Sub() {
+    this.emit(instr2.i32.sub);
+  }
+  globalGet(name2) {
+    this.emit(instr2.global.get, this.globalidx(name2));
+  }
+  globalSet(name2) {
+    this.emit(instr2.global.set, this.globalidx(name2));
+  }
+  localGet(name2) {
+    this.emit(instr2.local.get, this.localidx(name2));
+  }
+  localSet(name2) {
+    this.emit(instr2.local.set, this.localidx(name2));
+  }
+  localTee(name2) {
+    this.emit(instr2.local.tee, this.localidx(name2));
+  }
+  break(depth) {
+    const what = this._blockStack.at(-(depth + 1)).split(":")[0];
+    assert(what === "block" || what === "if", "Invalid break");
+    this.emit(instr2.br, labelidx(depth));
+  }
+  // Conditional break -- emits a `br_if` for the given depth.
+  condBreak(depth) {
+    const what = this._blockStack.at(-(depth + 1)).split(":")[0];
+    assert(what === "block" || what === "if", "Invalid condBreak");
+    this.emit(instr2.br_if, labelidx(depth));
+  }
+  continue(depth) {
+    const what = this._blockStack.at(-(depth + 1)).split(":")[0];
+    assert(what === "loop", "Invalid continue");
+    this.emit(instr2.br, labelidx(depth));
+  }
+  brTable(labels, defaultLabelidx) {
+    this.emit(instr2.br_table, vec(labels), defaultLabelidx);
+  }
+  return() {
+    this.emit(instr2.return);
+  }
+  // Emit a dense jump table (switch-like) using br_table.
+  switch(bt, discrimThunk, numCases, caseCb, defaultThunk) {
+    const startStackHeight = this._blockStack.length;
+    const labels = [];
+    for (let i = 0; i < numCases; i++) {
+      this._blockOnly(bt);
+      labels.push(labelidx(i));
+    }
+    this.block(blocktype.empty, () => {
+      discrimThunk();
+      this.brTable(labels, labelidx(labels.length));
+    });
+    for (let i = 0; i < numCases; i++) {
+      const depth = labels.length - (i + 1);
+      caseCb(i, depth);
+      this.break(depth);
+      this._endBlock();
+    }
+    assert(this._blockStack.length === startStackHeight);
+  }
+  // "Macros" -- codegen helpers specific to Ohm.
+  i32Inc() {
+    this.i32Const(1);
+    this.i32Add();
+  }
+  i32Dec() {
+    this.i32Const(1);
+    this.i32Sub();
+  }
+  dup() {
+    this.localTee("tmp");
+    this.localGet("tmp");
+  }
+  currCharCode() {
+    this.globalGet("pos");
+    this.i32Load8u(Compiler.INPUT_BUFFER_OFFSET);
+  }
+  nextCharCode() {
+    this.currCharCode();
+    this.incPos();
+  }
+  setRet(val) {
+    this.i32Const(val);
+    this.localSet("ret");
+  }
+  pushStackFrame(saveThunk) {
+    this.globalGet("sp");
+    this.i32Const(_Assembler.STACK_FRAME_SIZE_BYTES);
+    this.i32Sub();
+    this.globalSet("sp");
+    if (saveThunk) {
+      saveThunk();
+    } else {
+      this.savePos();
+      this.saveNumBindings();
+    }
+  }
+  popStackFrame() {
+    this.i32Const(_Assembler.STACK_FRAME_SIZE_BYTES);
+    this.globalGet("sp");
+    this.i32Add();
+    this.globalSet("sp");
+  }
+  // Save the current input position.
+  savePos() {
+    this.globalGet("sp");
+    this.globalGet("pos");
+    this.i32Store();
+  }
+  // Load the saved input position onto the stack.
+  getSavedPos() {
+    this.globalGet("sp");
+    this.i32Load();
+  }
+  restorePos() {
+    this.getSavedPos();
+    this.globalSet("pos");
+  }
+  saveNumBindings() {
+    this.globalGet("sp");
+    if (FAST_SAVE_BINDINGS) {
+      this.globalGet("bindings");
+      this.i32Load(12);
+    } else {
+      this.callPrebuiltFunc("getBindingsLength");
+    }
+    this.i32Store(4);
+  }
+  getSavedNumBindings() {
+    this.globalGet("sp");
+    this.i32Load(4);
+  }
+  restoreBindingsLength() {
+    if (FAST_RESTORE_BINDINGS) {
+      this.globalGet("bindings");
+      this.getSavedNumBindings();
+      this.i32Store(12);
+    } else {
+      this.getSavedNumBindings();
+      this.callPrebuiltFunc("setBindingsLength");
+    }
+  }
+  saveFailurePos() {
+    this.globalGet("sp");
+    this.localGet("failurePos");
+    this.i32Store();
+  }
+  restoreFailurePos() {
+    this.globalGet("sp");
+    this.i32Load();
+    this.localSet("failurePos");
+  }
+  saveGlobalFailurePos() {
+    this.globalGet("sp");
+    this.globalGet("rightmostFailurePos");
+    this.i32Store(4);
+  }
+  restoreGlobalFailurePos() {
+    this.globalGet("sp");
+    this.i32Load(4);
+    this.globalSet("rightmostFailurePos");
+  }
+  updateGlobalFailurePos() {
+    this.i32Max(
+      () => this.globalGet("rightmostFailurePos"),
+      () => this.localGet("failurePos")
+    );
+    this.globalSet("rightmostFailurePos");
+  }
+  updateLocalFailurePos(origPosThunk) {
+    this.i32Max(() => this.localGet("failurePos"), origPosThunk);
+    this.localSet("failurePos");
+  }
+  // Increment the current input position by 1.
+  // [i32, i32] -> [i32]
+  incPos() {
+    this.globalGet("pos");
+    this.i32Inc();
+    this.globalSet("pos");
+  }
+  callPrebuiltFunc(name2) {
+    this.emit(instr2.call, funcidx(prebuiltFuncidx(name2)));
+  }
+  newIterNodeWithSavedPosAndBindings(arity, isOpt = false) {
+    this.getSavedPos();
+    this.globalGet("pos");
+    this.getSavedNumBindings();
+    this.i32Const(arity);
+    this.i32Const(isOpt ? 1 : 0);
+    this.callPrebuiltFunc("newIterationNode");
+  }
+  newCaseInsensitiveNode(ruleId) {
+    this.getSavedPos();
+    this.globalGet("pos");
+    this.i32Const(ruleId);
+    this.globalGet("bindings");
+    this.i32Load(12);
+    this.i32Const(1);
+    this.i32Sub();
+    this.i32Const(-1);
+    this.callPrebuiltFunc("newNonterminalNode");
+  }
+  // [startIdx: i32] -> [ptr: i32]
+  newTerminalNode() {
+    this.localGet("postSpacesPos");
+    this.globalGet("pos");
+    this.callPrebuiltFunc("newTerminalNode");
+  }
+  i32Max(aThunk, bThunk) {
+    aThunk();
+    bThunk();
+    aThunk();
+    bThunk();
+    this.emit(instr2.i32.gt_s, instr2.select);
+  }
+  // Return the depth of the block with the given label.
+  depthOf(label) {
+    const i = this._blockStack.findLastIndex((what) => what === `block:${label}`);
+    assert(i !== -1, `Unknown label: ${label}`);
+    return this._blockStack.length - i - 1;
+  }
+  ruleEvalReturn() {
+    this.localGet("ret");
+    this.emit(instr2.i32.eqz, instr2.i32.eqz);
+    this.localGet("failurePos");
+    this.i32Const(1);
+    this.emit(instr2.i32.shl);
+    this.emit(instr2.i32.or);
+  }
+};
+Assembler.ALIGN_1_BYTE = 0;
+Assembler.ALIGN_4_BYTES = 2;
+Assembler.CST_NODE_HEADER_SIZE_BYTES = 8;
+Assembler.MEMO_COL_SIZE_BYTES = 4 * 256;
+Assembler.STACK_FRAME_SIZE_BYTES = 8;
+var Compiler = class {
+  constructor(grammar2) {
+    assert(grammar2 && "superGrammar" in grammar2, "Not a valid grammar: " + grammar2);
+    if (!(grammar2 instanceof ohm.ohmGrammar.constructor)) {
+      assert(
+        !!grammar2.source,
+        "Grammar smells fishy. Do you have multiple instances of ohm-js?"
+      );
+      grammar2 = ohm.grammar(grammar2.source.contents);
+    }
+    this.grammar = grammar2;
+    this.importDecls = [];
+    this.ruleIdByName = new IndexedSet();
+    this._ensureRuleId(grammar2.defaultStartRule);
+    this._ensureRuleId("$term");
+    this._ensureRuleId("$spaces");
+    this.rules = void 0;
+    this._nextLiftedId = 0;
+    this._lexContextStack = [];
+    this._applySpacesImplicit = apply("$spaces");
+  }
+  importCount() {
+    return importsec2.entryCount + this.importDecls.length;
+  }
+  ruleId(name2) {
+    return checkNotNull2(this.ruleIdByName.getIndex(name2), `Unknown rule: ${name2}`);
+  }
+  // This should be the only place where we assign rule IDs!
+  _ensureRuleId(name2, { notMemoized } = {}) {
+    const idx = this.ruleIdByName.add(name2);
+    assert(notMemoized || idx < 256, `too many rules: ${idx}`);
+    return idx;
+  }
+  inLexicalContext() {
+    return checkNotNull2(this._lexContextStack.at(-1));
+  }
+  liftPExpr(exp, isSyntactic) {
+    assert(!(exp instanceof pexprs.Terminal));
+    const name2 = `$lifted${this._nextLiftedId++}`;
+    const freeVars = collectParams(exp);
+    let body = exp;
+    let formals = [];
+    const maxIndex = freeVars.reduce((acc, param2) => Math.max(acc, param2.index), -1);
+    if (freeVars.length > 0) {
+      const newParams = new Array(maxIndex + 1);
+      freeVars.forEach((p, i) => {
+        newParams[p.index] = new pexprs.Param(i);
+      });
+      body = exp.substituteParams(newParams);
+      formals = newParams.filter(isNonNull).map((p) => `__${p.index}`);
+    }
+    const actuals = freeVars.filter(isNonNull);
+    const ruleInfo = { body, formals, isSyntactic, source: exp.source };
+    return [name2, ruleInfo, actuals];
+  }
+  // Return a funcidx corresponding to the eval function for the given rule.
+  ruleEvalFuncIdx(name2) {
+    const offset = this.importCount() + funcsec2.entryCount;
+    return funcidx(this.ruleId(name2) + offset);
+  }
+  // Return an object implementing all of the debug imports.
+  getDebugImports(log) {
+    const ans = {};
+    for (const decl of this.importDecls.filter((d) => d.module === "debug")) {
+      const { name: name2 } = decl;
+      ans[name2] = (arg) => {
+        log(name2, arg);
+      };
+    }
+    return ans;
+  }
+  normalize() {
+    assert(!this.rules, "already normalized");
+    this.simplifyApplications();
+    this.specializeApplications();
+  }
+  compile() {
+    this.normalize();
+    const typeMap = this.typeMap = new TypeMap(typesec2.entryCount);
+    const asm = this.asm = new Assembler(typeMap);
+    asm.addBlocktype([valtype.i32], []);
+    asm.addBlocktype([valtype.i32], [valtype.i32]);
+    asm.addBlocktype([], [valtype.i32]);
+    asm.addGlobal("pos", valtype.i32, mut.var, () => asm.i32Const(0));
+    asm.addGlobal("rightmostFailurePos", valtype.i32, mut.var, () => asm.i32Const(-1));
+    asm.addGlobal("sp", valtype.i32, mut.var, () => asm.i32Const(0));
+    asm.addGlobal("__Runtime.Stub", valtype.i32, mut.const, () => asm.i32Const(0));
+    asm.addGlobal("__Runtime.Minimal", valtype.i32, mut.const, () => asm.i32Const(1));
+    asm.addGlobal("__Runtime.Incremental", valtype.i32, mut.const, () => asm.i32Const(2));
+    asm.addGlobal("__startOffset", valtype.i32, mut.var, () => asm.i32Const(0));
+    asm.addGlobal("__offset", valtype.i32, mut.var, () => asm.i32Const(0));
+    asm.addGlobal("__ASC_RUNTIME", valtype.i32, mut.const, () => asm.i32Const(0));
+    asm.addGlobal("bindings", valtype.i32, mut.var, () => asm.i32Const(0));
+    asm.addGlobal("__heap_base", valtype.i32, mut.var, () => asm.i32Const(67240172));
+    if (DEBUG) {
+      for (let i = 0; i < 5e3; i++) {
+        this.importDecls.push({
+          module: "debug",
+          name: `debug${i}`,
+          paramTypes: [],
+          resultTypes: []
+        });
+      }
+    }
+    const functionDecls = this.functionDecls();
+    this.rewriteDebugLabels(functionDecls);
+    return this.buildModule(typeMap, functionDecls);
+  }
+  simplifyApplications() {
+    const { grammar: grammar2 } = this;
+    const lookUpRule = (name2) => ({
+      ...checkNotNull2(grammar2.rules[name2]),
+      isSyntactic: isSyntacticRule(name2)
+    });
+    const ownRuleNames = Object.keys(grammar2.rules).filter(
+      (name2) => Object.hasOwn(grammar2.rules, name2)
+    );
+    const rules = ownRuleNames.map((name2) => [name2, lookUpRule(name2)]);
+    rules.push(["spaces", lookUpRule("spaces")]);
+    const liftedTerminals = new IndexedSet();
+    const liftTerminal = ({ obj }) => {
+      const id = liftedTerminals.add(obj);
+      assert(id >= 0 && id < 65535, "too many terminals!");
+      return liftedTerminal(id);
+    };
+    const simplifyArg = (exp, isSyntactic) => {
+      if (isApplyLike(exp)) {
+        return simplify(exp, isSyntactic);
+      }
+      if (exp instanceof pexprs.Terminal) {
+        return liftTerminal(exp);
+      }
+      const [name2, info, env] = this.liftPExpr(exp, isSyntactic);
+      const args = env.map((p) => {
+        assert(p instanceof pexprs.Param, "Expected Param");
+        return param(p.index);
+      });
+      rules.push([name2, info]);
+      return apply(name2, args);
+    };
+    const simplify = (exp, isSyntactic) => {
+      if (exp instanceof pexprs.Alt) {
+        return alt(exp.terms.map((e) => simplify(e, isSyntactic)));
+      }
+      if (exp === pexprs.any) return any();
+      if (exp === pexprs.end) return end();
+      switch (exp.constructor) {
+        case pexprs.Apply: {
+          const ruleInfo = lookUpRule(exp.ruleName);
+          if (ruleInfo.body instanceof pexprs.CaseInsensitiveTerminal) {
+            assert(exp.args.length === 1 && exp.args[0] instanceof pexprs.Terminal);
+            return caseInsensitive(exp.args[0].obj);
+          }
+          rules.push([exp.ruleName, ruleInfo]);
+          return apply(
+            exp.ruleName,
+            exp.args.map((arg) => simplifyArg(arg, isSyntactic))
+          );
+        }
+        case pexprs.Lex:
+          return lex(simplify(exp.expr, true));
+        case pexprs.Lookahead:
+          return lookahead(simplify(exp.expr, isSyntactic));
+        case pexprs.Not:
+          return not(simplify(exp.expr, isSyntactic));
+        case pexprs.Opt:
+          return opt(simplify(exp.expr, isSyntactic));
+        case pexprs.Plus:
+          return plus(simplify(exp.expr, isSyntactic));
+        case pexprs.Seq:
+          return seq(exp.factors.map((e) => simplify(e, isSyntactic)));
+        case pexprs.Star:
+          return star(simplify(exp.expr, isSyntactic));
+        case pexprs.Param:
+          return param(exp.index);
+        case pexprs.Range:
+          return range(exp.from, exp.to);
+        case pexprs.Terminal:
+          return terminal(exp.obj);
+        case pexprs.UnicodeChar:
+          return unicodeChar(exp.categoryOrProp ?? exp["category"]);
+        default:
+          throw new Error(`not handled: ${exp.constructor.name}`);
+      }
+    };
+    const newRules = /* @__PURE__ */ new Map();
+    for (let i = 0; i < rules.length; i++) {
+      const [name2, info] = rules[i];
+      if (!newRules.has(name2)) {
+        newRules.set(name2, {
+          ...info,
+          body: simplify(info.body, info.isSyntactic)
+        });
+      }
+    }
+    this.rules = newRules;
+    this.liftedTerminals = liftedTerminals;
+  }
+  compileTerminalRule(name2) {
+    const { asm } = this;
+    this.beginLexContext(true);
+    asm.addFunction(`$${name2}`, [valtype.i32], [valtype.i32], () => {
+      asm.addLocal("ret", valtype.i32);
+      asm.addLocal("tmp", valtype.i32);
+      asm.addLocal("postSpacesPos", valtype.i32);
+      asm.addLocal("failurePos", valtype.i32);
+      asm.i32Const(-1);
+      asm.localSet("failurePos");
+      const values = this.liftedTerminals.values();
+      asm.switch(
+        blocktype.empty,
+        () => asm.localGet("__arg0"),
+        values.length,
+        (i) => this.emitTerminal(terminal(values[i])),
+        () => asm.emit(instr2.unreachable)
+      );
+      asm.localGet("ret");
+    });
+    this.endLexContext();
+    return this.asm._functionDecls.at(-1);
+  }
+  beginLexContext(initialVal) {
+    assert(this._lexContextStack.length === 0);
+    this._lexContextStack.push(initialVal);
+  }
+  endLexContext() {
+    this._lexContextStack.pop();
+    assert(this._lexContextStack.length === 0);
+  }
+  compileRule(name2) {
+    const { asm } = this;
+    const ruleInfo = getNotNull(this.rules, name2);
+    let paramTypes = [];
+    if (ruleInfo.patterns) {
+      paramTypes = [valtype.i32];
+    }
+    const restoreFailurePos = name2 === this._applySpacesImplicit.ruleName;
+    this.beginLexContext(!ruleInfo.isSyntactic);
+    asm.addFunction(`$${name2}`, paramTypes, [valtype.i32], () => {
+      asm.addLocal("ret", valtype.i32);
+      asm.addLocal("tmp", valtype.i32);
+      asm.addLocal("postSpacesPos", valtype.i32);
+      asm.addLocal("failurePos", valtype.i32);
+      asm.globalGet("rightmostFailurePos");
+      asm.localSet("failurePos");
+      if (restoreFailurePos) {
+        asm.addLocal("origFailurePos", valtype.i32);
+        asm.globalGet("rightmostFailurePos");
+        asm.localSet("origFailurePos");
+      }
+      asm.emit(`BEGIN eval:${name2}`);
+      this.emitPExpr(ruleInfo.body);
+      if (restoreFailurePos) {
+        asm.localGet("origFailurePos");
+        asm.dup();
+        asm.globalSet("rightmostFailurePos");
+        asm.localSet("failurePos");
+      }
+      asm.ruleEvalReturn();
+      asm.emit(`END eval:${name2}`);
+    });
+    this.endLexContext();
+    return this.asm._functionDecls.at(-1);
+  }
+  // Beginning with the default start rule, recursively visit all reachable
+  // parsing expressions. For all parameterized rules, create a specialized
+  // version of that rule for every possible set of actual parameters.
+  // At the end, there are no more applications with arguments.
+  specializeApplications() {
+    const newRules = /* @__PURE__ */ new Map();
+    const { rules } = this;
+    const patternsByRule = /* @__PURE__ */ new Map();
+    let hasCaseInsensitiveTerminals = false;
+    const specialize = (exp) => rewrite(exp, {
+      Apply: (app) => {
+        const { ruleName, children } = app;
+        const ruleInfo = getNotNull(rules, ruleName);
+        if (["liquidRawTagImpl", "liquidTagRule"].includes(ruleName)) {
+          return specialize(substituteParams(ruleInfo.body, children));
+        }
+        const specializedName2 = specializedName(app);
+        this._ensureRuleId(specializedName2);
+        if (!newRules.has(specializedName2)) {
+          newRules.set(specializedName2, {});
+          let body = specialize(substituteParams(ruleInfo.body, children));
+          if (children.length > 0) {
+            const rulePatterns = setdefault(patternsByRule, ruleName, () => /* @__PURE__ */ new Map());
+            rulePatterns.set(specializedName2, children);
+            if (EMIT_GENERALIZED_RULES) {
+              const caseIdx = rulePatterns.size - 1;
+              body = applyGeneralized(ruleName, caseIdx);
+            }
+          }
+          newRules.set(specializedName2, { ...ruleInfo, body, formals: [] });
+        }
+        return apply(specializedName2);
+      },
+      CaseInsensitive: (exp2) => {
+        hasCaseInsensitiveTerminals = true;
+        return exp2;
+      }
+    });
+    specialize(apply(this.grammar.defaultStartRule));
+    const spacesInfo = getNotNull(rules, "spaces");
+    newRules.set("$spaces", {
+      ...spacesInfo,
+      body: specialize(spacesInfo.body)
+    });
+    if (hasCaseInsensitiveTerminals) {
+      assert(!newRules.has("caseInsensitive"));
+      this._ensureRuleId("caseInsensitive", { notMemoized: true });
+      newRules.set("caseInsensitive", {
+        name: "caseInsensitive",
+        body: seq([not(end()), end()]),
+        // ~end end
+        formals: [],
+        description: ""
+      });
+    }
+    this.rules = newRules;
+    if (EMIT_GENERALIZED_RULES) {
+      const insertDispatches = (exp, patterns) => rewrite(exp, {
+        Apply: (app) => app.children.length === 0 ? app : dispatch(app, patterns),
+        Param: (p) => dispatch(p, patterns)
+      });
+      for (const [name2, patterns] of patternsByRule.entries()) {
+        this._ensureRuleId(name2, { notMemoized: true });
+        const ruleInfo = getNotNull(rules, name2);
+        const patternsArr = [...patterns.values()];
+        newRules.set(name2, {
+          ...ruleInfo,
+          body: insertDispatches(ruleInfo.body, patternsArr),
+          patterns: patternsArr
+        });
+      }
+    }
+  }
+  buildRuleNamesSection(ruleNames) {
+    return custom(name("ruleNames"), vec(ruleNames.map((n, i) => name(n))));
+  }
+  buildModule(typeMap, functionDecls) {
+    const ruleNames = this.ruleIdByName.values();
+    assert(destImportCount === this.importCount(), "import count mismatch");
+    ruleNames.forEach(
+      (n, i) => assert(i === this.ruleIdByName.getIndex(n), `out of order: ${n}`)
+    );
+    typeMap.addDecls(this.importDecls);
+    typeMap.addDecls(functionDecls);
+    const globals = [];
+    const imports = this.importDecls.map(
+      (f, i) => import_(f.module, f.name, importdesc.func(typeMap.getIdxForDecl(f)))
+    );
+    const funcs = functionDecls.map((f, i) => typeidx(typeMap.getIdxForDecl(f)));
+    const codes = functionDecls.map((f) => code(func(f.locals, f.body)));
+    const exportOffset = this.importCount() + funcsec2.entryCount;
+    const exports = functionDecls.map(
+      (f, i) => export_(f.name, exportdesc.func(i + exportOffset))
+    );
+    exports.push(export_("memory", exportdesc.mem(0)));
+    exports.push(export_("match", exportdesc.func(prebuiltFuncidx("match"))));
+    exports.push(export_("getCstRoot", exportdesc.func(prebuiltFuncidx("getCstRoot"))));
+    for (const [name2, { type, mut: mut2, initExpr }] of this.asm._globals.entries()) {
+      globals.push(global(globaltype(type, mut2), initExpr));
+      exports.push(export_(name2, [3, this.asm.globalidx(name2)]));
+    }
+    const numRules = this.ruleIdByName.size;
+    const table2 = table(
+      tabletype(elemtype.funcref, limits.minmax(numRules, numRules))
+    );
+    const tableData = ruleNames.map((name2) => this.ruleEvalFuncIdx(name2));
+    assert(numRules === tableData.length, "Invalid rule count");
+    const indexOfStart = functionDecls.findIndex((f) => f.name === "start");
+    assert(indexOfStart !== -1, "No start function found");
+    const startFuncidx2 = this.importCount() + funcsec2.entryCount + indexOfStart;
+    const mod = module([
+      mergeSections(SECTION_ID_TYPE, typesec2, typeMap.getTypes()),
+      mergeSections(SECTION_ID_IMPORT, importsec2, imports),
+      mergeSections(SECTION_ID_FUNCTION, funcsec2, funcs),
+      tablesec([table2]),
+      memsec([mem(memtype(limits.min(1024 + 24)))]),
+      globalsec(globals),
+      exportsec(exports),
+      startsec(start(startFuncidx2)),
+      elemsec([elem(tableidx(0), [instr2.i32.const, i32(0), instr2.end], tableData)]),
+      mergeSections(SECTION_ID_CODE, codesec2, codes),
+      customsec(this.buildRuleNamesSection(ruleNames)),
+      namesec(namedata(modulenamesubsec(this.grammar.name)))
+    ]);
+    const bytes = Uint8Array.from(mod.flat(Infinity));
+    return bytes;
+  }
+  // A *brilliant* way to add arbitrary labels to the generated code.
+  // Goes through the body of all functions in `decls`, and replaces any
+  // strings with a call to a dummy function with the same name.
+  // Ensures that there are no duplicate dummy function names, but does not
+  // guarantee that there are no collisions with other functions.
+  // Returns the list of dummy functions that need to be added to the module.
+  rewriteDebugLabels(decls) {
+    let nextIdx = 0;
+    const intoFuncidx = (i) => funcidx(importsec2.entryCount + i);
+    const names = /* @__PURE__ */ new Set();
+    for (let i = 0; i < decls.length; i++) {
+      const entry = decls[i];
+      entry.body = entry.body.flatMap((x) => {
+        if (typeof x !== "string") return x;
+        if (!DEBUG) return [];
+        const idx = nextIdx++;
+        const decl = checkNotNull2(this.importDecls[idx], "Too few debug functions!");
+        assert(decl.module === "debug");
+        decl.name = uniqueName(names, x);
+        let pushArg = [];
+        if (x.startsWith("END")) {
+          decl.paramTypes = [valtype.i32];
+          const retIdx = entry.paramTypes.length;
+          pushArg = [instr2.local.get, localidx(retIdx)];
+        }
+        return [...pushArg, instr2.call, intoFuncidx(idx)].flat(Infinity);
+      });
+    }
+  }
+  functionDecls() {
+    const ruleDecls = [];
+    for (const name2 of this.ruleIdByName.keys()) {
+      if (name2 === "$term") {
+        ruleDecls.push(this.compileTerminalRule(name2));
+      } else {
+        assert(!name2.startsWith("$term"));
+        ruleDecls.push(this.compileRule(name2));
+      }
+    }
+    const { asm } = this;
+    asm.addFunction("start", [], [], () => {
+      asm.emit(instr2.call, funcidx(startFuncidx));
+    });
+    ruleDecls.push(asm._functionDecls.at(-1));
+    return ruleDecls;
+  }
+  // Handle an application-like expression (i.e. an actual Apply, or a Param)
+  // in the *body* of the generalized version of a parameterized rule.
+  // Generalized rules can behave like a specific specialized version of the
+  // rule; they take an i32 `caseIdx` argument that selects the behaviour.
+  // Then, for any Param -- or Apply that involves a Param -- we dynamically
+  // dispatch to the correct specialized version of the rule.
+  emitDispatch({ child: exp, patterns }) {
+    const { asm } = this;
+    const handleCase = (i) => {
+      let newExp = substituteParams(exp, patterns[i]);
+      if (newExp.type === "Apply") {
+        newExp = apply(specializedName(newExp));
+      }
+      this.emitPExpr(newExp);
+    };
+    if (patterns.length === 1) {
+      handleCase(0);
+      return;
+    }
+    assert(patterns.length > 1);
+    asm.switch(
+      blocktype.empty,
+      () => asm.localGet("__arg0"),
+      patterns.length,
+      handleCase,
+      () => {
+        asm.emit(instr2.unreachable);
+      }
+    );
+  }
+  // Contract: emitPExpr always means we're going deeper in the PExpr tree.
+  emitPExpr(exp, { preHook, postHook } = {}) {
+    const { asm } = this;
+    const allowFastApply = !preHook && !postHook;
+    assert(!(exp.type === "Apply" && exp.children.length > 0));
+    if (exp.type === "Apply" && allowFastApply) {
+      asm.emit(`BEGIN apply:${exp.ruleName}`);
+      this.emitApply(exp);
+      asm.emit(`END apply:${exp.ruleName}`);
+      return;
+    }
+    if (exp.type === "ApplyGeneralized") {
+      assert(EMIT_GENERALIZED_RULES && allowFastApply);
+      asm.emit(`BEGIN applyGeneralized:${exp.ruleName}`);
+      this.emitApplyGeneralized(exp);
+      asm.emit(`END applyGeneralized:${exp.ruleName}`);
+      return;
+    }
+    const debugLabel = toString(exp);
+    asm.emit(`BEGIN ${debugLabel}`);
+    asm.pushStackFrame();
+    asm.block(
+      blocktype.empty,
+      () => {
+        if (preHook) preHook();
+        switch (exp.type) {
+          case "Alt":
+            this.emitAlt(exp);
+            break;
+          case "Any":
+            this.emitAny();
+            break;
+          case "CaseInsensitive":
+            this.emitCaseInsensitive(exp);
+            break;
+          case "Dispatch":
+            this.emitDispatch(exp);
+            break;
+          case "End":
+            this.emitEnd();
+            break;
+          case "Lex":
+            this.emitLex(exp);
+            break;
+          case "LiftedTerminal":
+            this.emitApplyTerm(exp);
+            break;
+          case "Lookahead":
+            this.emitLookahead(exp);
+            break;
+          case "Not":
+            this.emitNot(exp);
+            break;
+          case "Seq":
+            this.emitSeq(exp);
+            break;
+          case "Star":
+            this.emitStar(exp);
+            break;
+          case "Opt":
+            this.emitOpt(exp);
+            break;
+          case "Range":
+            this.emitRange(exp);
+            break;
+          case "Plus":
+            this.emitPlus(exp);
+            break;
+          case "Terminal":
+            this.emitTerminal(exp);
+            break;
+          case "UnicodeChar":
+            this.emitUnicodeChar(exp);
+            break;
+          case "Param":
+          // Fall through (Params should not exist at codegen time).
+          default:
+            throw new Error(`not handled: ${exp.type}`);
+        }
+      },
+      "pexprEnd"
+    );
+    if (postHook) postHook();
+    asm.popStackFrame();
+    asm.emit(`END ${debugLabel}`);
+  }
+  emitAlt(exp) {
+    const { asm } = this;
+    asm.block(blocktype.empty, () => {
+      for (const term of exp.children) {
+        this.emitPExpr(term);
+        asm.localGet("ret");
+        asm.condBreak(asm.depthOf("pexprEnd"));
+        asm.restorePos();
+        asm.restoreBindingsLength();
+      }
+    });
+  }
+  emitAny() {
+    const { asm } = this;
+    this.wrapTerminalLike(() => {
+      asm.i32Const(255);
+      asm.nextCharCode();
+      asm.i32Eq();
+      asm.condBreak(asm.depthOf("failure"));
+    });
+  }
+  emitApplyTerm({ terminalId }) {
+    const { asm } = this;
+    this.maybeEmitSpaceSkipping();
+    asm.globalGet("pos");
+    asm.localSet("tmp");
+    asm.i32Const(terminalId);
+    asm.emit(instr2.call, this.ruleEvalFuncIdx("$term"));
+    asm.localTee("ret");
+    asm.ifFalse(blocktype.empty, () => {
+      asm.updateLocalFailurePos(() => asm.localGet("tmp"));
+    });
+  }
+  // Emit an application of the generalized version of a parameterized rule.
+  // Need to know which case we're applying!
+  emitApplyGeneralized(exp) {
+    const { asm } = this;
+    asm.i32Const(this.ruleId(exp.ruleName));
+    asm.i32Const(exp.caseIdx);
+    asm.callPrebuiltFunc("evalApplyGeneralized");
+    asm.localSet("ret");
+  }
+  emitApply(exp) {
+    assert(exp.children.length === 0);
+    if (exp !== this._applySpacesImplicit) {
+      this.maybeEmitSpaceSkipping();
+    }
+    const { asm } = this;
+    asm.i32Const(this.ruleId(exp.ruleName));
+    if (exp.ruleName.includes("_")) {
+      asm.callPrebuiltFunc("evalApplyNoMemo0");
+    } else {
+      asm.callPrebuiltFunc("evalApply0");
+    }
+    asm.updateLocalFailurePos(() => asm.globalGet("rightmostFailurePos"));
+    asm.localSet("ret");
+  }
+  emitEnd() {
+    const { asm } = this;
+    this.wrapTerminalLike(() => {
+      asm.i32Const(255);
+      asm.currCharCode();
+      asm.i32Ne();
+      asm.condBreak(asm.depthOf("failure"));
+    });
+  }
+  emitFail() {
+    const { asm } = this;
+    asm.i32Const(0);
+    asm.localSet("ret");
+  }
+  emitLex({ child }) {
+    this._lexContextStack.push(true);
+    this.emitPExpr(child);
+    this._lexContextStack.pop();
+  }
+  emitLookahead({ child }) {
+    const { asm } = this;
+    this.emitPExpr(child);
+    asm.restoreBindingsLength();
+    asm.restorePos();
+  }
+  emitNot({ child }) {
+    const { asm } = this;
+    asm.pushStackFrame(() => {
+      asm.saveFailurePos();
+      asm.saveGlobalFailurePos();
+    });
+    this.emitPExpr(child);
+    asm.localGet("ret");
+    asm.emit(instr2.i32.eqz);
+    asm.localSet("ret");
+    asm.restoreGlobalFailurePos();
+    asm.restoreFailurePos();
+    asm.popStackFrame();
+    asm.restoreBindingsLength();
+    asm.restorePos();
+  }
+  emitOpt({ child }) {
+    const { asm } = this;
+    this.emitPExpr(child);
+    asm.localGet("ret");
+    asm.ifFalse(blocktype.empty, () => {
+      asm.restorePos();
+      asm.restoreBindingsLength();
+    });
+    asm.newIterNodeWithSavedPosAndBindings(outArity(child), true);
+    asm.localSet("ret");
+  }
+  emitPlus(plusExp) {
+    const { asm } = this;
+    this.emitPExpr(plusExp.child);
+    asm.localGet("ret");
+    asm.if(blocktype.empty, () => {
+      this.emitStar(plusExp);
+    });
+  }
+  emitRange(exp) {
+    assert(exp.lo.length === 1 && exp.hi.length === 1);
+    const lo = exp.lo.charCodeAt(0);
+    const hi = exp.hi.charCodeAt(0);
+    const { asm } = this;
+    this.wrapTerminalLike(() => {
+      asm.nextCharCode();
+      asm.dup();
+      asm.i32Const(hi);
+      asm.emit(instr2.i32.gt_u);
+      asm.condBreak(asm.depthOf("failure"));
+      asm.i32Const(lo);
+      asm.emit(instr2.i32.lt_u);
+      asm.condBreak(asm.depthOf("failure"));
+    });
+  }
+  emitSeq({ children }) {
+    const { asm } = this;
+    if (children.length === 0) {
+      asm.setRet(1);
+      return;
+    }
+    for (const c of children) {
+      this.emitPExpr(c);
+      asm.localGet("ret");
+      asm.emit(instr2.i32.eqz);
+      asm.condBreak(asm.depthOf("pexprEnd"));
+    }
+  }
+  maybeEmitSpaceSkipping() {
+    if (IMPLICIT_SPACE_SKIPPING && !this.inLexicalContext()) {
+      this.asm.emit("BEGIN space skipping");
+      this.emitApply(this._applySpacesImplicit);
+      this.asm.emit("END space skipping");
+    }
+  }
+  emitStar({ child }, { reuseStackFrame } = {}) {
+    const { asm } = this;
+    asm.pushStackFrame();
+    asm.block(
+      blocktype.empty,
+      () => {
+        asm.loop(blocktype.empty, () => {
+          asm.savePos();
+          asm.saveNumBindings();
+          this.emitPExpr(child);
+          asm.localGet("ret");
+          asm.emit(instr2.i32.eqz);
+          asm.condBreak(asm.depthOf("done"));
+          asm.continue(0);
+        });
+      },
+      "done"
+    );
+    asm.restorePos();
+    asm.restoreBindingsLength();
+    asm.popStackFrame();
+    asm.newIterNodeWithSavedPosAndBindings(outArity(child));
+    asm.localSet("ret");
+  }
+  wrapTerminalLike(thunk) {
+    const { asm } = this;
+    this.maybeEmitSpaceSkipping();
+    asm.globalGet("pos");
+    asm.localSet("postSpacesPos");
+    asm.block(
+      blocktype.empty,
+      () => {
+        asm.block(
+          blocktype.empty,
+          () => {
+            thunk();
+            asm.newTerminalNode();
+            asm.localSet("ret");
+            asm.break(asm.depthOf("_done"));
+          },
+          "failure"
+        );
+        asm.updateLocalFailurePos(() => asm.localGet("postSpacesPos"));
+        asm.setRet(0);
+      },
+      "_done"
+    );
+  }
+  emitCaseInsensitive({ value }) {
+    const { asm } = this;
+    assert(
+      [...value].every((c) => c <= "\x7F"),
+      "not supported: case-insensitive Unicode"
+    );
+    const str = value.toLowerCase();
+    asm.emit(JSON.stringify(`caseInsensitive:${value}`));
+    this.wrapTerminalLike(() => {
+      for (const c of [...str]) {
+        asm.i32Const(c.charCodeAt(0));
+        asm.currCharCode();
+        if ("a" <= c && c <= "z" || "A" <= c && c <= "Z") {
+          asm.i32Const(32);
+          asm.emit(instr2.i32.or);
+        }
+        asm.emit(instr2.i32.ne);
+        asm.condBreak(asm.depthOf("failure"));
+        asm.incPos();
+      }
+    });
+    asm.localGet("ret");
+    asm.if(blocktype.empty, () => {
+      asm.newCaseInsensitiveNode(this.ruleId("caseInsensitive"));
+      asm.localSet("ret");
+    });
+  }
+  emitTerminal(exp) {
+    const { asm } = this;
+    asm.emit(JSON.stringify(exp.value));
+    this.wrapTerminalLike(() => {
+      for (const c of [...exp.value]) {
+        asm.i32Const(c.charCodeAt(0));
+        asm.currCharCode();
+        asm.emit(instr2.i32.ne);
+        asm.condBreak(asm.depthOf("failure"));
+        asm.incPos();
+      }
+    });
+  }
+  emitUnicodeChar(exp) {
+    const { asm } = this;
+    assert(["Ll", "Lu", "Ltmo"].includes(exp.categoryOrProp));
+    const makeLabels = () => asciiChars.map((c) => {
+      const isLowercase = "a" <= c && c <= "z";
+      const isUppercase = "A" <= c && c <= "Z";
+      if (exp.categoryOrProp === "Lu" && isUppercase || exp.categoryOrProp === "Ll" && isLowercase) {
+        return labelidx(asm.depthOf("fastSuccess"));
+      }
+      return labelidx(asm.depthOf("failure"));
+    });
+    this.wrapTerminalLike(() => {
+      asm.block(
+        blocktype.empty,
+        () => {
+          asm.block(
+            blocktype.empty,
+            () => {
+              asm.block(
+                blocktype.empty,
+                () => {
+                  asm.currCharCode();
+                  asm.brTable(makeLabels(), labelidx(asm.depthOf("default")));
+                },
+                "default"
+              );
+              switch (exp.categoryOrProp) {
+                case "Lu":
+                  asm.i32Const(1 << 1);
+                  break;
+                case "Ll":
+                  asm.i32Const(1 << 2);
+                  break;
+                case "Ltmo":
+                  asm.i32Const(1 << 3 | 1 << 4 | 1 << 5);
+                  break;
+                default:
+                  assert(false, "not handled");
+              }
+              asm.callPrebuiltFunc("doMatchUnicodeChar");
+              asm.ifElse(
+                blocktype.empty,
+                () => asm.break(asm.depthOf("slowSuccess")),
+                () => asm.break(asm.depthOf("failure"))
+              );
+            },
+            "fastSuccess"
+          );
+          asm.incPos();
+        },
+        "slowSuccess"
+      );
+    });
+  }
+};
+Compiler.STACK_START_OFFSET = WASM_PAGE_SIZE;
+Compiler.INPUT_BUFFER_OFFSET = WASM_PAGE_SIZE;
+Compiler.MEMO_START_OFFSET = 2 * WASM_PAGE_SIZE;
+Compiler.CST_START_OFFSET = (1024 + 2) * WASM_PAGE_SIZE;
+var ConstantsForTesting = {
+  CST_NODE_SIZE_BYTES: checkNotNull2(Assembler.CST_NODE_HEADER_SIZE_BYTES),
+  CST_START_OFFSET: checkNotNull2(Compiler.CST_START_OFFSET),
+  MEMO_COL_SIZE_BYTES: checkNotNull2(Assembler.MEMO_COL_SIZE_BYTES),
+  MEMO_START_OFFSET: checkNotNull2(Compiler.MEMO_START_OFFSET)
+};
+
+// src/cli.js
 function main() {
   const argsConfig = {
     options: {
@@ -27,7 +2250,7 @@ function main() {
     process.exit(1);
   }
   const filename = args.positionals[0];
-  const ns = ohm.grammars(fs.readFileSync(filename, "utf8"));
+  const ns = ohm2.grammars(fs.readFileSync(filename, "utf8"));
   let g = Object.values(ns).at(-1);
   const { grammarName } = args.values;
   if (grammarName) {