watr 4.2.1 → 4.3.1

package/dist/watr.js

@@ -447,13 +447,14 @@ var INSTR = [
   ,
   ,
   ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
-  ,
+  // 0xe0-0xe6: stack switching (Phase 3)
+  "cont.new typeidx",
+  "cont.bind cont_bind",
+  "suspend tagidx",
+  "resume resume",
+  "resume_throw resume_throw",
+  "resume_throw_ref resume_throw_ref",
+  "switch switch_cont",
   ,
   ,
   ,
@@ -506,7 +507,165 @@ var INSTR = [
     "extern.convert_any",
     "ref.i31",
     "i31.get_s",
-    "i31.get_u"
+    "i31.get_u",
+    ,
+    "struct.new_desc typeidx",
+    "struct.new_default_desc typeidx",
+    "ref.get_desc typeidx",
+    "ref.cast_desc_eq reftype",
+    ,
+    "br_on_cast_desc_eq reftype2",
+    "br_on_cast_desc_eq_fail reftype2",
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    // stringref: 0xFB 0x80-0xB7
+    "string.new_utf8 memoryidx?",
+    "string.new_wtf16 memoryidx?",
+    "string.const stringidx",
+    "string.measure_utf8",
+    "string.measure_wtf8",
+    "string.measure_wtf16",
+    "string.encode_utf8 memoryidx?",
+    "string.encode_wtf16 memoryidx?",
+    "string.concat",
+    "string.eq",
+    "string.is_usv_sequence",
+    "string.new_lossy_utf8 memoryidx?",
+    "string.new_wtf8 memoryidx?",
+    "string.encode_lossy_utf8 memoryidx?",
+    "string.encode_wtf8 memoryidx?",
+    ,
+    // 0x8F
+    "string.as_wtf8",
+    "stringview_wtf8.advance",
+    "stringview_wtf8.encode_utf8 memoryidx?",
+    "stringview_wtf8.slice",
+    "stringview_wtf8.encode_lossy_utf8 memoryidx?",
+    "stringview_wtf8.encode_wtf8 memoryidx?",
+    ,
+    ,
+    // 0x96-0x97
+    "string.as_wtf16",
+    "stringview_wtf16.length",
+    "stringview_wtf16.get_codeunit",
+    "stringview_wtf16.encode memoryidx?",
+    "stringview_wtf16.slice",
+    ,
+    ,
+    ,
+    // 0x9D-0x9F
+    "string.as_iter",
+    "stringview_iter.next",
+    "stringview_iter.advance",
+    "stringview_iter.rewind",
+    "stringview_iter.slice",
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    ,
+    // 0xA5-0xAF
+    "string.new_utf8_array",
+    "string.new_wtf16_array",
+    "string.encode_utf8_array",
+    "string.encode_wtf16_array",
+    "string.new_lossy_utf8_array",
+    "string.new_wtf8_array",
+    "string.encode_lossy_utf8_array",
+    "string.encode_wtf8_array"
   ],
   // 0xfc: Bulk memory/table operations (nested array)
   [
@@ -896,7 +1055,7 @@ var INSTR = [
     "i64.atomic.rmw32.cmpxchg_u memarg"
   ]
 ];
-var SECTION = { custom: 0, type: 1, import: 2, func: 3, table: 4, memory: 5, tag: 13, global: 6, export: 7, start: 8, elem: 9, datacount: 12, code: 10, data: 11 };
+var SECTION = { custom: 0, type: 1, import: 2, func: 3, table: 4, memory: 5, tag: 13, strings: 14, global: 6, export: 7, start: 8, elem: 9, datacount: 12, code: 10, data: 11 };
 var TYPE = {
   // Value types
   i8: 120,
@@ -920,6 +1079,14 @@ var TYPE = {
   i31: 108,
   struct: 107,
   array: 106,
+  cont: 104,
+  nocont: 117,
+  // stack switching (Phase 3)
+  string: 103,
+  stringview_wtf8: 102,
+  stringview_wtf16: 96,
+  stringview_iter: 97,
+  // stringref
   // Reference type abbreviations (absheaptype abbrs)
   nullfuncref: 115,
   nullexternref: 114,
@@ -933,6 +1100,11 @@ var TYPE = {
   i31ref: 108,
   structref: 107,
   arrayref: 106,
+  contref: 104,
+  nocontref: 117,
+  // stack switching abbreviations
+  stringref: 103,
+  // stringref abbreviation
   // ref, refnull
   ref: 100,
   // -0x1c
@@ -943,7 +1115,7 @@ var TYPE = {
   subfinal: 79,
   rec: 78
 };
-var DEFTYPE = { func: 96, struct: 95, array: 94, sub: 80, subfinal: 79, rec: 78 };
+var DEFTYPE = { func: 96, struct: 95, array: 94, cont: 93, sub: 80, subfinal: 79, rec: 78 };
 var KIND = { func: 0, table: 1, memory: 2, global: 3, tag: 4 };
 
 // src/parse.js
@@ -962,10 +1134,10 @@ var parse_default = (str2) => {
           buf += str2[i++]
         )
       );
-      else if (q < 0) c === 10 || c === 13 ? (buf += str2[i++], commit(), q = 0) : buf += str2[i++];
+      else if (q < 0) c === 10 || c === 13 ? (buf += str2[i++], commit(), q = 0) : q === -2 && c === 41 ? (commit(), q = 0) : buf += str2[i++];
       else if (c === 34) buf !== "$" && commit(), q = 34, buf += str2[i++];
       else if (c === 40 && str2.charCodeAt(i + 1) === 59) commit(), q = 60, buf = str2[i++] + str2[i++];
-      else if (c === 59 && str2.charCodeAt(i + 1) === 59) commit(), q = -1, buf = str2[i++] + str2[i++];
+      else if (c === 59 && str2.charCodeAt(i + 1) === 59) commit(), q = str2.indexOf("\n", i) < 0 ? -2 : -1, buf = str2[i++] + str2[i++];
       else if (c === 40 && str2.charCodeAt(i + 1) === 64) commit(), p = i, i += 2, buf = "@", depth++, (root = level).push(level = []), parseLevel(p), level = root;
       else if (c === 40) commit(), p = i++, depth++, (root = level).push(level = []), parseLevel(p), level = root;
       else if (c === 41) return commit(), i++, depth--;
@@ -1010,6 +1182,17 @@ function compile(nodes) {
   else if (typeof nodes[0] === "string") nodes = [nodes];
   if (nodes[idx] === "binary") return Uint8Array.from(nodes.slice(++idx).flat());
   if (nodes[idx] === "quote") return compile(nodes.slice(++idx).map((v) => v.valueOf().slice(1, -1)).flat().join(""));
+  nodes = nodes.flatMap((n, i) => {
+    if (i < idx || !Array.isArray(n) || n[0] !== "import") return [n];
+    const [, mod, ...rest] = n;
+    if (!rest.some((r) => Array.isArray(r) && r[0] === "item")) return [n];
+    const lastIsType = Array.isArray(rest.at(-1)) && rest.at(-1)[0] !== "item";
+    if (lastIsType) {
+      const type = rest.at(-1);
+      return rest.slice(0, -1).filter((r) => r[0] === "item").map(([, nm]) => ["import", mod, nm, type]);
+    }
+    return rest.filter((r) => r[0] === "item").map(([, nm, type]) => ["import", mod, nm, type]);
+  });
   const ctx = [];
   for (let kind in SECTION) (ctx[SECTION[kind]] = ctx[kind] = []).name = kind;
   ctx.metadata = {};
@@ -1040,12 +1223,19 @@ function compile(nodes) {
       for (let i = 0; i < node.length; i++) {
         let [, ...subnode] = node[i];
         name(subnode, ctx.type);
+        const tdesc = [];
+        while (subnode[0]?.[0] === "descriptor" || subnode[0]?.[0] === "describes") tdesc.push(subnode.shift());
         (subnode = typedef(subnode, ctx)).push(i ? true : [ctx.type.length, node.length]);
+        if (tdesc.length) subnode.desc = subnode.desc ? [...tdesc, ...subnode.desc] : tdesc;
         ctx.type.push(subnode);
       }
     } else if (kind === "type") {
       name(node, ctx.type);
-      ctx.type.push(typedef(node, ctx));
+      const tdesc = [];
+      while (node[0]?.[0] === "descriptor" || node[0]?.[0] === "describes") tdesc.push(node.shift());
+      const td = typedef(node, ctx);
+      if (tdesc.length) td.desc = td.desc ? [...tdesc, ...td.desc] : tdesc;
+      ctx.type.push(td);
     } else if (kind === "start" || kind === "export") ctx[kind].push(node);
     else return true;
   }).forEach((n) => {
@@ -1068,7 +1258,8 @@ function compile(nodes) {
     } else if (kind === "memory") {
       const is64 = node[0] === "i64", idx2 = is64 ? 1 : 0;
       if (node[idx2]?.[0] === "data") {
-        let [, ...data] = node.splice(idx2, 1)[0], m = "" + Math.ceil(data.reduce((s, d) => s + d.length, 0) / 65536);
+        const ps = node.find((n2) => Array.isArray(n2) && n2[0] === "pagesize")?.[1] ?? 65536;
+        let [, ...data] = node.splice(idx2, 1)[0], m = "" + Math.ceil(data.reduce((s, d) => s + d.length, 0) / ps);
         ctx.data.push([["memory", items.length], [is64 ? "i64.const" : "i32.const", is64 ? 0n : 0], ...data]);
         node = is64 ? ["i64", m, m] : [m, m];
       }
@@ -1101,6 +1292,12 @@ function compile(nodes) {
     }
     return sections;
   };
+  const globalSection = bin(SECTION.global);
+  const elemSection = bin(SECTION.elem);
+  const codeSection = bin(SECTION.code);
+  const metaSection = binMeta();
+  const dataSection = bin(SECTION.data);
+  const stringsSection = ctx.strings.length ? [SECTION.strings, ...vec([0, ...vec(ctx.strings.map((s) => vec(s)))])] : [];
   return Uint8Array.from([
     0,
     97,
@@ -1119,14 +1316,15 @@ function compile(nodes) {
     ...bin(SECTION.table),
     ...bin(SECTION.memory),
     ...bin(SECTION.tag),
-    ...bin(SECTION.global),
+    ...stringsSection,
+    ...globalSection,
     ...bin(SECTION.export),
     ...bin(SECTION.start, false),
-    ...bin(SECTION.elem),
+    ...elemSection,
     ...bin(SECTION.datacount, false),
-    ...bin(SECTION.code),
-    ...binMeta(),
-    ...bin(SECTION.data)
+    ...codeSection,
+    ...metaSection,
+    ...dataSection
   ]);
 }
 var isIdx = (n) => n?.[0] === "$" || !isNaN(n);
@@ -1195,7 +1393,7 @@ function normalize(nodes, ctx) {
         out.push(...normalize(parts, ctx), "end");
       } else {
         const imm = [];
-        while (parts.length && (!Array.isArray(parts[0]) || "type,param,result,ref".includes(parts[0][0]))) imm.push(parts.shift());
+        while (parts.length && (!Array.isArray(parts[0]) || parts[0].valueOf !== Array.prototype.valueOf || "type,param,result,ref,exact,on".includes(parts[0][0]))) imm.push(parts.shift());
         out.push(...normalize(parts, ctx), op, ...imm);
         nodes.unshift(...out.splice(out.length - 1 - imm.length));
       }
@@ -1240,16 +1438,19 @@ var name = (node, list) => {
   return nm;
 };
 var typedef = ([dfn], ctx) => {
-  let subkind = "subfinal", supertypes = [], compkind;
+  let subkind = "subfinal", supertypes = [], compkind, desc = [];
   if (dfn[0] === "sub") {
     subkind = dfn.shift(), dfn[0] === "final" && (subkind += dfn.shift());
     dfn = (supertypes = dfn).pop();
+    supertypes = supertypes.filter((n) => Array.isArray(n) && (n[0] === "descriptor" || n[0] === "describes") ? (desc.push(n), false) : true);
   }
   [compkind, ...dfn] = dfn;
   if (compkind === "func") dfn = paramres(dfn), ctx.type["$" + dfn.join(">")] ??= ctx.type.length;
   else if (compkind === "struct") dfn = fieldseq(dfn, "field");
   else if (compkind === "array") [dfn] = dfn;
-  return [compkind, dfn, subkind, supertypes];
+  const result = [compkind, dfn, subkind, supertypes];
+  if (desc.length) result.desc = desc;
+  return result;
 };
 var build = [
   // (@custom "name" placement? data) - custom section builder
@@ -1264,29 +1465,37 @@ var build = [
   // (func params result)
   // (array i8)
   // (struct ...fields)
-  ([kind, fields, subkind, supertypes, rec], ctx) => {
+  // (cont $ft) - stack switching (Phase 3)
+  (node, ctx) => {
+    const [kind, fields, subkind, supertypes, rec] = node;
     if (rec === true) return;
-    let details;
+    const descPfx = (node.desc ?? []).flatMap(([clause, ref]) => [clause === "descriptor" ? 77 : 76, ...uleb(id(ref, ctx.type))]);
+    const comptype = (k, f) => {
+      if (k === "func") return [DEFTYPE.func, ...vec(f[0].map((t) => reftype(t, ctx))), ...vec(f[1].map((t) => reftype(t, ctx)))];
+      if (k === "array") return [DEFTYPE.array, ...fieldtype(f, ctx)];
+      if (k === "struct") return [DEFTYPE.struct, ...vec(f.map((t) => fieldtype(t, ctx)))];
+      if (k === "cont") return [DEFTYPE.cont, ...uleb(id(f[0] ?? f, ctx.type))];
+      return [DEFTYPE[k]];
+    };
     if (rec) {
-      kind = "rec";
-      let [from, length] = rec, subtypes = Array.from({ length }, (_, i) => build[SECTION.type](ctx.type[from + i].slice(0, 4), ctx));
-      details = vec(subtypes);
+      let [from, length] = rec;
+      const subtypes = Array.from({ length }, (_, i) => {
+        const t = ctx.type[from + i], sub = t.slice(0, 4);
+        if (t.desc) sub.desc = t.desc;
+        return build[SECTION.type](sub, ctx);
+      });
+      return [DEFTYPE.rec, ...vec(subtypes)];
     } else if (subkind === "sub" || supertypes?.length) {
-      details = [...vec(supertypes.map((n) => id(n, ctx.type))), ...build[SECTION.type]([kind, fields], ctx)];
-      kind = subkind;
-    } else if (kind === "func") {
-      details = [...vec(fields[0].map((t) => reftype(t, ctx))), ...vec(fields[1].map((t) => reftype(t, ctx)))];
-    } else if (kind === "array") {
-      details = fieldtype(fields, ctx);
-    } else if (kind === "struct") {
-      details = vec(fields.map((t) => fieldtype(t, ctx)));
+      return [DEFTYPE[subkind], ...vec(supertypes.map((n) => id(n, ctx.type))), ...descPfx, ...comptype(kind, fields)];
     }
-    return [DEFTYPE[kind], ...details];
+    return [...descPfx, ...comptype(kind, fields)];
   },
   // (import "math" "add" (func|table|global|memory|tag dfn?))
   ([mod, field, [kind, ...dfn]], ctx) => {
-    let details;
+    let details, kindByte = KIND[kind];
     if (kind === "func") {
+      const isExact = dfn[0] === "exact" && dfn.shift();
+      if (isExact) kindByte = 32;
       let [[, typeidx]] = dfn;
       details = uleb(id(typeidx, ctx.type));
     } else if (kind === "tag") {
@@ -1299,7 +1508,7 @@ var build = [
     } else if (kind === "table") {
       details = [...reftype(dfn.pop(), ctx), ...limits(dfn)];
     } else err(`Unknown kind ${kind}`);
-    return [...vec(mod), ...vec(field), KIND[kind], ...details];
+    return [...vec(mod), ...vec(field), kindByte, ...details];
   },
   // (func $name? ...params result ...body)
   ([[, typeidx]], ctx) => uleb(id(typeidx, ctx.type)),
@@ -1413,6 +1622,7 @@ var build = [
   // (data (i32.const 0) "\aa" "\bb"?)
   // (data (memory ref) (offset (i32.const 0)) "\aa" "\bb"?)
   // (data (global.get $x) "\aa" "\bb"?)
+  // (data (i8 1 2 3) ...) numeric values (WAT numeric values, Phase 2)
   (inits, ctx) => {
     let offset, memidx = 0;
     if (inits[0]?.[0] === "memory") {
@@ -1435,7 +1645,7 @@ var build = [
           [1]
         )
       ),
-      ...vec(inits.flat())
+      ...vec(inits.flatMap((item) => numdata(item) ?? [...item]))
     ];
   },
   // datacount
@@ -1443,7 +1653,13 @@ var build = [
   // (tag $name? (type idx))
   ([[, typeidx]], ctx) => [0, ...uleb(id(typeidx, ctx.type))]
 ];
-var reftype = (t, ctx) => t[0] === "ref" ? t[1] == "null" ? TYPE[t[2]] ? [TYPE[t[2]]] : [TYPE.refnull, ...uleb(id(t[t.length - 1], ctx.type))] : [TYPE.ref, ...uleb(TYPE[t[t.length - 1]] || id(t[t.length - 1], ctx.type))] : (
+var reftype = (t, ctx) => t[0] === "ref" ? t[1] == "null" ? (
+  // (ref null (exact $T)) - exact nullable ref
+  Array.isArray(t[2]) && t[2][0] === "exact" ? [TYPE.refnull, 98, ...uleb(id(t[2][1], ctx.type))] : TYPE[t[2]] ? [TYPE[t[2]]] : [TYPE.refnull, ...uleb(id(t[t.length - 1], ctx.type))]
+) : (
+  // (ref (exact $T)) - exact non-null ref
+  Array.isArray(t[1]) && t[1][0] === "exact" ? [TYPE.ref, 98, ...uleb(id(t[1][1], ctx.type))] : [TYPE.ref, ...uleb(TYPE[t[t.length - 1]] || id(t[t.length - 1], ctx.type))]
+) : (
   // abbrs
   [TYPE[t] ?? err(`Unknown type ${t}`)]
 );
@@ -1491,7 +1707,7 @@ var IMM = {
   },
   ref_null: (n, c) => {
     let t = n.shift();
-    return TYPE[t] ? [TYPE[t]] : uleb(id(t, c.type));
+    return Array.isArray(t) && t[0] === "exact" ? [98, ...uleb(id(t[1], c.type))] : TYPE[t] ? [TYPE[t]] : uleb(id(t, c.type));
   },
   memarg: (n, c, op) => memargEnc(n, op, isIdx(n[0]) && !isMemParam(n[0]) ? id(n.shift(), c.memory) : 0),
   opt_memory: (n, c) => uleb(id(isIdx(n[0]) ? n.shift() : 0, c.memory)),
@@ -1500,8 +1716,8 @@ var IMM = {
     return ht.length > 1 ? ht.slice(1) : ht;
   },
   reftype2: (n, c) => {
-    let b = blockid(n.shift(), c.block), h1 = reftype(n.shift(), c), h2 = reftype(n.shift(), c);
-    return [(h2[0] !== TYPE.ref) << 1 | h1[0] !== TYPE.ref, ...uleb(b), h1.pop(), h2.pop()];
+    let b = blockid(n.shift(), c.block), h1 = reftype(n.shift(), c), h2 = reftype(n.shift(), c), ht = (h) => h.length > 1 ? h.slice(1) : h;
+    return [(h2[0] !== TYPE.ref) << 1 | h1[0] !== TYPE.ref, ...uleb(b), ...ht(h1), ...ht(h2)];
   },
   v128const: (n) => {
     let [t, num] = n.shift().split("x"), bits = +t.slice(1), stride = bits >>> 3;
@@ -1539,6 +1755,11 @@ var IMM = {
   elemidx: (n, c) => uleb(id(n.shift(), c.elem)),
   tagidx: (n, c) => uleb(id(n.shift(), c.tag)),
   "memoryidx?": (n, c) => uleb(id(isIdx(n[0]) ? n.shift() : 0, c.memory)),
+  stringidx: (n, c) => {
+    let s = n.shift(), key = s.valueOf(), idx = c.strings.findIndex((x) => x.valueOf() === key);
+    if (idx < 0) idx = c.strings.push(s) - 1;
+    return uleb(idx);
+  },
   // Value type
   i32: (n) => i32(n.shift()),
   i64: (n) => i64(n.shift()),
@@ -1556,7 +1777,47 @@ var IMM = {
   typeidx_typeidx: (n, c) => [...uleb(id(n.shift(), c.type)), ...uleb(id(n.shift(), c.type))],
   dataidx_memoryidx: (n, c) => [...uleb(id(n.shift(), c.data)), ...uleb(id(n.shift(), c.memory))],
   memoryidx_memoryidx: (n, c) => [...uleb(id(n.shift(), c.memory)), ...uleb(id(n.shift(), c.memory))],
-  tableidx_tableidx: (n, c) => [...uleb(id(n.shift(), c.table)), ...uleb(id(n.shift(), c.table))]
+  tableidx_tableidx: (n, c) => [...uleb(id(n.shift(), c.table)), ...uleb(id(n.shift(), c.table))],
+  // stack switching handlers (Phase 3)
+  cont_bind: (n, c) => [...uleb(id(n.shift(), c.type)), ...uleb(id(n.shift(), c.type))],
+  switch_cont: (n, c) => [...uleb(id(n.shift(), c.type)), ...uleb(id(n.shift(), c.tag))],
+  resume: (n, c) => {
+    const typeidx = uleb(id(n.shift(), c.type));
+    const handlers = [];
+    let cnt = 0;
+    while (n[0]?.[0] === "on") {
+      const [, tag, label] = n.shift();
+      if (label === "switch") handlers.push(1, ...uleb(id(tag, c.tag)));
+      else handlers.push(0, ...uleb(id(tag, c.tag)), ...uleb(blockid(label, c.block)));
+      cnt++;
+    }
+    return [...typeidx, ...uleb(cnt), ...handlers];
+  },
+  resume_throw: (n, c) => {
+    const typeidx = uleb(id(n.shift(), c.type));
+    const exnidx = uleb(id(n.shift(), c.tag));
+    const handlers = [];
+    let cnt = 0;
+    while (n[0]?.[0] === "on") {
+      const [, tag, label] = n.shift();
+      if (label === "switch") handlers.push(1, ...uleb(id(tag, c.tag)));
+      else handlers.push(0, ...uleb(id(tag, c.tag)), ...uleb(blockid(label, c.block)));
+      cnt++;
+    }
+    return [...typeidx, ...exnidx, ...uleb(cnt), ...handlers];
+  },
+  resume_throw_ref: (n, c) => {
+    const typeidx = uleb(id(n.shift(), c.type));
+    const handlers = [];
+    let cnt = 0;
+    while (n[0]?.[0] === "on") {
+      const [, tag, label] = n.shift();
+      if (label === "switch") handlers.push(1, ...uleb(id(tag, c.tag)));
+      else handlers.push(0, ...uleb(id(tag, c.tag)), ...uleb(blockid(label, c.block)));
+      cnt++;
+    }
+    return [...typeidx, ...uleb(cnt), ...handlers];
+  }
 };
 var HANDLER = {};
 (function populate(items, pre) {
@@ -1616,17 +1877,36 @@ var align = (op) => {
   let k = op[i] === "l" ? i + 4 : i + 5, m = op.slice(k).match(/(\d+)(x|_|$)/);
   return Math.log2(m ? m[2] === "x" ? 8 : m[1] / 8 : +group / 8);
 };
+var numdata = (item) => {
+  if (!Array.isArray(item)) return null;
+  const [t, ...vs] = item;
+  if (t !== "i8" && t !== "i16" && t !== "i32" && t !== "i64" && t !== "f32" && t !== "f64") return null;
+  const out = [], dv = new DataView(new ArrayBuffer(8));
+  for (const v of vs) {
+    if (t === "i8") out.push(i32.parse(v) & 255 + 256 & 255);
+    else if (t === "i16") dv.setInt16(0, i32.parse(v), true), out.push(...new Uint8Array(dv.buffer, 0, 2));
+    else if (t === "i32") dv.setInt32(0, i32.parse(v), true), out.push(...new Uint8Array(dv.buffer, 0, 4));
+    else if (t === "i64") dv.setBigInt64(0, BigInt(v), true), out.push(...new Uint8Array(dv.buffer, 0, 8));
+    else if (t === "f32") out.push(...f32(v));
+    else if (t === "f64") out.push(...f64(v));
+  }
+  return out;
+};
 var limits = (node) => {
   const is64 = node[0] === "i64" && node.shift();
   const shared = node[node.length - 1] === "shared" && node.pop();
+  const psIdx = node.findIndex((n) => Array.isArray(n) && n[0] === "pagesize");
+  let psLog2 = -1;
+  if (psIdx >= 0) psLog2 = Math.log2(+node.splice(psIdx, 1)[0][1]);
   const hasMax = !isNaN(parseInt(node[1]));
-  const flag = (is64 ? 4 : 0) | (shared ? 2 : 0) | (hasMax ? 1 : 0);
+  const flag = (psLog2 >= 0 ? 8 : 0) | (is64 ? 4 : 0) | (shared ? 2 : 0) | (hasMax ? 1 : 0);
   const parse = is64 ? (v) => {
     if (typeof v === "bigint") return v;
     const str2 = typeof v === "string" ? v.replaceAll("_", "") : String(v);
     return BigInt(str2);
   } : parseUint;
-  return hasMax ? [flag, ...uleb(parse(node.shift())), ...uleb(parse(node.shift()))] : [flag, ...uleb(parse(node.shift()))];
+  const ps = psLog2 >= 0 ? uleb(psLog2) : [];
+  return hasMax ? [flag, ...uleb(parse(node.shift())), ...uleb(parse(node.shift())), ...ps] : [flag, ...uleb(parse(node.shift())), ...ps];
 };
 var parseUint = (v, max = 4294967295) => {
   const n = typeof v === "string" && v[0] !== "+" ? i32.parse(v) : typeof v === "number" ? v : err(`Bad int ${v}`);