@mudlet/mudlet-web 0.4.5 → 1.0.0

package/dist-lib/mud/triggers/legacyColorPatterns.d.ts

@@ -0,0 +1,58 @@
+/** Mudlet's `TTrigger::scmIgnored` — "any colour here". */
+export declare const COLOR_IGNORED = -1;
+/** Mudlet's `TTrigger::scmDefault` — the console's own colour, a colour to
+ *  match rather than an "any". */
+export declare const COLOR_DEFAULT = -2;
+/**
+ * The modern pattern text for a colour pair.
+ *
+ * Both channels ignored yields the empty string, exactly as
+ * `createColorPatternText` does — desktop's comment calls it "equivalent to an
+ * empty other trigger type", and an empty pattern is compacted out of the list
+ * rather than matching everything.
+ */
+export declare function colorPatternText(fg: number, bg: number): string;
+/**
+ * Rewrite a pre-3.17 `FG<n>BG<n>` colour pattern into the modern form, or
+ * return the text unchanged when it is not one.
+ *
+ * Deliberately narrow: anything that is already modern, or that is neither
+ * (`FG(4)BG(-2)`, a hand-typed string), is left exactly as it was, and the
+ * runtime refuses it. Desktop does the same — its regex does not match the
+ * parenthesised form either, which is why that form matches nothing on desktop.
+ */
+export declare function remapLegacyColorPattern(text: string): string;
+/**
+ * Rewrite a modern `ANSI_COLORS_F{…}_B{…}` colour pattern back into the
+ * `FG<n>BG<n>` numbering a save file uses, or return the text unchanged when it
+ * is not one.
+ *
+ * The save-file numbers are NOT the ANSI ones the runtime matches on, and
+ * Mudlet converts in both directions — `remapColorsToAnsiNumber` on the way in
+ * (XMLimport.cpp:1425) and `remapAnsiToColorNumber` on the way out
+ * (XMLexport.cpp:1031, "Revert the first 16 ANSI colour codes back to the wrong
+ * values that are still used in the save files"). Mudlet Web had only the reading
+ * half, so an exported colour trigger carried the in-memory text into the file
+ * — where desktop's reader does not recognise it, and the trigger comes back as
+ * a colour pattern nothing can parse.
+ */
+export declare function toSaveFileColorPattern(text: string): string;
+/**
+ * Parse a colour-trigger pattern into its `[fg, bg]` ANSI pair, in any of the
+ * three spellings one can arrive in:
+ *
+ *  - `ANSI_COLORS_F{003}_B{IGNORE}` — the wire form desktop writes, and so what
+ *    every imported package and profile carries;
+ *  - `FG4BG0` — the pre-3.17 save-file numbering, remapped on the way through;
+ *  - `3,-1` — the plain pair the editor writes.
+ *
+ * `IGNORE` and a missing/unparsable channel are {@link COLOR_IGNORED} ("any",
+ * -1); `DEFAULT` is {@link COLOR_DEFAULT} (-2), the console's own colour, which
+ * is a colour to match rather than an "any".
+ *
+ * Shared so the trigger engine and the editor cannot disagree about what a
+ * pattern says. They did: the editor read only the plain pair, so a colour
+ * trigger that came in with a package fired correctly but showed up in the
+ * pattern row as "any/any" (mudlet-web#158).
+ */
+export declare function parseColorPattern(text: string): [number, number];

package/dist-lib/mud/triggers/pcre/Pcre2.d.ts

@@ -1,3 +1,23 @@
+/** pcre2_match option: the subject has already been checked for valid UTF, so
+ *  don't scan it again. Only honoured by a patched wasm — see the header. */
+export declare const PCRE2_NO_UTF_CHECK = 1073741824;
+/**
+ * The match limit trigger and alias patterns are compiled with, as a
+ * start-of-pattern verb. PCRE2's default is 10 000 000, which desktop's JIT
+ * gets through in a blink; the wasm build here is the interpreter, at about
+ * 50 ns a step, so a nested quantifier like `^(\w+\s?)+$` failing on an
+ * ordinary 50-character line spent half a second to several seconds per line
+ * before giving up (#435) — the page frozen all the while, for a pattern that
+ * then counts as no match anyway (#361). Half a million steps gives up in
+ * tens of milliseconds, and is still more than ten times what an ordinary
+ * pattern needs on a 20 kB line (a few tens of thousands), so no line that
+ * matched before stops matching. A pattern carrying its own
+ * `(*LIMIT_MATCH=n)` comes after this one, and its value wins.
+ * Lua's `rex` keeps the library default: it is lrexlib, where a script can
+ * read the limit back (rex.config) and handle MATCHLIMIT itself.
+ */
+export declare const ENGINE_MATCH_LIMIT = 500000;
+export declare const ENGINE_MATCH_LIMIT_VERB = "(*LIMIT_MATCH=500000)";
 export type Pcre2MatchGroup = {
     start: number;
     end: number;
@@ -10,17 +30,79 @@ export type Pcre2Match = {
     [k: number]: Pcre2MatchGroup;
     [k: string]: Pcre2MatchGroup | number;
 };
+/** `subject` without its unpaired surrogates — what Mudlet's pcre2 sees. */
+export declare function pcreSubject(subject: string): string;
 /** Drop the cached line so the next match re-encodes. Used after teardown or
  *  when callers want to be sure a stale buffer can't be reused. */
 export declare function resetLineBuffer(): void;
+/**
+ * Whether `pattern` (as compiled, with no flags) starts with a top-level `.+`,
+ * `.+?` or `.++` that PCRE2 may be told to match ANCHORED — see the note above.
+ * Conservative: anything the scan is unsure of is a no.
+ */
+export declare function leadingDotPlus(pattern: string): boolean;
 export default class Pcre2 {
     private codePtr;
     private matchData;
+    /** {@link leadingDotPlus} of the pattern: match it ANCHORED, stretch by stretch. */
+    private readonly dotPlus;
     private readonly nametable;
+    /** The name table in PCRE2's own order (sorted by name), duplicates kept. */
+    private readonly nameEntries;
+    /** Whether {@link init} has resolved, so a pattern can be compiled
+     *  synchronously right now. */
+    static get ready(): boolean;
     static init(): Promise<void>;
+    /** The PCRE2 library's own version string (`pcre2_config(PCRE2_CONFIG_VERSION)`),
+     *  e.g. "10.42 2022-12-11" — what lrexlib's `rex.version()` reports. */
+    static version(): string;
     constructor(pattern: string, flags?: string);
+    /** `[name, group number]` for each named group, in PCRE2's name-table
+     *  order — what lrexlib walks to add named captures to a result table. */
+    get groupNames(): ReadonlyArray<[string, number]>;
+    /** The number of capturing groups (PCRE2_INFO_CAPTURECOUNT): the match
+     *  data is sized from the pattern, one ovector pair more than that. */
+    get captureCount(): number;
     destroy(): void;
     match(subject: string, start?: number): Pcre2Match | null;
-    matchAll(subject: string): Pcre2Match[];
+    /**
+     * {@link match} without the end-of-subject guard: `startOffset` may equal
+     * `subject.length`, where a pattern that can match nothing still finds its
+     * empty match. That is where TAlias::match's global loop tries after a
+     * match that ran to the end of the command.
+     */
+    matchFrom(subject: string, startOffset: number, options?: number): Pcre2Match | null;
+    private matchOnce;
+    /**
+     * {@link matchFrom} as Mudlet's trigger and alias code calls pcre2_match:
+     * any error is "no match". TTrigger::match_perl and TAlias::match treat a
+     * negative return from the first pcre2_match the same whatever it is, so a
+     * pattern that backtracks into the match limit (-47) is simply a pattern
+     * that did not match this line, and the triggers and aliases after it still
+     * run. Throwing here took the rest of the line's pass with it (#361).
+     */
+    tryMatchFrom(subject: string, startOffset: number, options?: number): Pcre2Match | null;
+    /**
+     * Every match of the pattern in `subject`, by Mudlet's global-match loop
+     * (TTrigger::match_perl under "match all", and TAlias::match, which always
+     * runs it) — pcre2demo's loop:
+     *
+     *  - resume at the end of the last match, even when that is the end of the
+     *    subject, where a pattern that can match nothing still finds its empty
+     *    match (`(\d*)` on a line gives one there);
+     *  - after an EMPTY match, first ask again at the same offset with
+     *    PCRE2_NOTEMPTY_ATSTART | PCRE2_ANCHORED, so a pattern that preferred
+     *    nothing still reports the non-empty match it could make there (`a??`
+     *    on "aa" gives "", "a", "", "a", ""); only when that fails step one
+     *    code point on and match normally from there;
+     *  - stop after an empty match at the end of the subject.
+     *
+     * `lenient` is how the trigger and alias engines call it: an error from
+     * pcre2_match (the match limit, say) ends the loop with what was found so
+     * far, and an error on the first call means no match — desktop's
+     * `if (rc < 0) goto END`. Without it the error is thrown, as
+     * {@link matchFrom} throws.
+     */
+    matchAll(subject: string, lenient?: boolean): Pcre2Match[];
     private getLastError;
 }

package/dist-lib/oauth-callback.html

@@ -0,0 +1,94 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="referrer" content="no-referrer">
+<title>Sign-in</title>
+<!--
+  Redirect target for the client-driven GMCP Char.Login OAuth flow
+  (src/mud/protocol/oauthClientFlow.ts). The identity provider sends the
+  player here with ?code=…&state=… (or ?error=…). This page reports those
+  over a same-origin BroadcastChannel to the app tab that started the
+  sign-in, strips them from the address bar, and says how it went. It
+  never renders anything taken from the URL.
+
+  Desktop Mudlet's equivalent is the loopback listener in OAuthClientFlow.cpp,
+  whose response pages these messages follow.
+-->
+<style>
+  :root { color-scheme: light dark; --bg: #f6f6f4; --fg: #1f2328; --muted: #59636e; }
+  @media (prefers-color-scheme: dark) { :root { --bg: #16181d; --fg: #e6e6e6; --muted: #9aa4af; } }
+  html, body { margin: 0; height: 100%; background: var(--bg); color: var(--fg);
+    font: 16px/1.5 system-ui, -apple-system, "Segoe UI", Roboto, sans-serif; }
+  main { min-height: 100%; display: grid; place-items: center; padding: 16px; box-sizing: border-box; }
+  p { max-width: 32em; text-align: center; margin: 0; }
+  small { display: block; margin-top: 8px; color: var(--muted); }
+</style>
+</head>
+<body>
+<main><p id="msg" role="status" aria-live="polite">Finishing your sign-in…</p></main>
+<script>
+(function () {
+  'use strict';
+  var CHANNEL = 'mudlet-web-oauth';
+  var msg = document.getElementById('msg');
+  function show(text, hint) {
+    msg.textContent = text;
+    if (hint) {
+      var s = document.createElement('small');
+      s.textContent = hint;
+      msg.appendChild(s);
+    }
+  }
+
+  // Providers answer in the query (the default response_mode) and, rarely, the
+  // fragment. Read both, then take them out of the address bar and history.
+  var params = new URLSearchParams(location.search);
+  if (!params.has('state') && location.hash.length > 1) {
+    params = new URLSearchParams(location.hash.slice(1));
+  }
+  var state = params.get('state') || '';
+  var code = params.get('code') || '';
+  var error = params.get('error') || '';
+  try { history.replaceState(null, '', location.pathname); } catch (e) { /* ignore */ }
+
+  if (!state || (!code && !error)) {
+    show('There is no sign-in to finish here.', 'You can close this tab.');
+    return;
+  }
+  if (typeof BroadcastChannel === 'undefined') {
+    show('This browser cannot hand the sign-in back to Mudlet.', 'Please return to the game and try again.');
+    return;
+  }
+
+  var channel = new BroadcastChannel(CHANNEL);
+  var settled = false;
+  function finish(ok) {
+    if (settled) return;
+    settled = true;
+    channel.close();
+    if (ok === true) {
+      show('You are signed in. You can close this tab and return to the game.');
+      setTimeout(function () { try { window.close(); } catch (e) { /* ignore */ } }, 1500);
+    } else if (ok === false) {
+      show(error ? 'The sign-in was not completed.' : 'The sign-in did not complete.',
+           'You can close this tab and return to the game.');
+    } else {
+      show('The game tab that started this sign-in did not answer.',
+           'If it is still open, return to it; otherwise reconnect and try again.');
+    }
+  }
+  channel.onmessage = function (ev) {
+    var d = ev.data;
+    if (d && d.type === 'ack' && d.state === state) finish(d.ok === true);
+  };
+  var payload = { type: 'callback', state: state };
+  if (code) payload.code = code;
+  if (error) payload.error = error;
+  channel.postMessage(payload);
+  setTimeout(function () { finish(null); }, 4000);
+})();
+</script>
+</body>
+</html>

package/dist-lib/pcre2Wasm.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Give pcre2-wasm-universal's `_match` export an `options` argument.
+ *
+ * The library's C wrapper is
+ *
+ *     int match(code, subject, length, startOffset, matchData)
+ *         { return pcre2_match(code, subject, length, startOffset, 0, matchData, NULL); }
+ *
+ * and its `compile` always sets PCRE2_UTF. With options fixed at 0, every
+ * pcre2_match call checks that the subject is valid UTF-16 from the start
+ * offset to the END of the subject, so a global match — one call per match,
+ * each starting where the last one ended — costs the number of matches times
+ * the length of the line: quadratic. A 64 kB line of 13 000 words took twenty
+ * times as long as an 8 kB one. Mudlet (and pcre2_substitute itself) checks the
+ * subject once and passes PCRE2_NO_UTF_CHECK for the rest of the loop, which
+ * needs the options argument the wrapper doesn't pass through.
+ *
+ * The wrapper compiles to
+ *
+ *     local.get 0  local.get 1  local.get 2  local.get 3
+ *     i32.const 0                                ;; options
+ *     local.get 4
+ *     call $pcre2_match_16
+ *
+ * so the patch retypes `_match` to take a sixth i32 (the module already
+ * declares that exact signature, for pcre2_match_16 itself) and swaps
+ * `i32.const 0` for `local.get 5`. Both edits are the same size as what they
+ * replace, so no section or body length moves. A caller passing five arguments
+ * still gets options 0 — JS fills the missing one with `undefined` → 0 — and a
+ * caller passing six to the unpatched module has the sixth dropped, so either
+ * side can be old without breaking the other; only the speed differs.
+ *
+ * Returns a patched copy, or null when the bytes aren't the build this patch
+ * was written against (anything unexpected, so the caller falls back to the
+ * module as shipped rather than a guess). Already-patched input comes back
+ * unchanged, so it is safe to apply twice.
+ *
+ * UPGRADING pcre2-wasm-universal. This was derived against 1.0.0's
+ * dist/libpcre2.wasm (sha256 5ea911ab…0dc99e). The fallback keeps a new build
+ * correct, but at runtime it is silent: the speed-up is simply gone, and long
+ * lines go back to quadratic. So a bump that changes the wasm must re-derive
+ * the patch: disassemble the new binary (e.g. `wasm2wat`), find `_match`'s
+ * export and body, check it is still the pass-through above with options
+ * hard-coded to 0 and that a 6×i32 → i32 signature still exists, and adjust
+ * what `patch`/`bodyMatches` expect. If upstream grew a real options argument,
+ * drop this patch (and the transform in vitest.config.ts) instead.
+ *
+ * The bump can't slip through unnoticed: tests/triggers/pcreMatchAllLinear.test.ts
+ * ("recognises the installed pcre2-wasm-universal build" and "runs the wasm
+ * this suite patched") fails in `yarn test` with "pcre2 wasm patch did not
+ * apply; see vite-plugin/pcre2Wasm.ts" when the installed binary isn't
+ * recognised or the loaded module ignores PCRE2_NO_UTF_CHECK.
+ */
+export declare function patchLibpcre2Wasm(input: Uint8Array): Uint8Array<ArrayBuffer> | null;

package/dist-lib/pcre2Wasm.js

@@ -0,0 +1,241 @@
+/**
+ * Give pcre2-wasm-universal's `_match` export an `options` argument.
+ *
+ * The library's C wrapper is
+ *
+ *     int match(code, subject, length, startOffset, matchData)
+ *         { return pcre2_match(code, subject, length, startOffset, 0, matchData, NULL); }
+ *
+ * and its `compile` always sets PCRE2_UTF. With options fixed at 0, every
+ * pcre2_match call checks that the subject is valid UTF-16 from the start
+ * offset to the END of the subject, so a global match — one call per match,
+ * each starting where the last one ended — costs the number of matches times
+ * the length of the line: quadratic. A 64 kB line of 13 000 words took twenty
+ * times as long as an 8 kB one. Mudlet (and pcre2_substitute itself) checks the
+ * subject once and passes PCRE2_NO_UTF_CHECK for the rest of the loop, which
+ * needs the options argument the wrapper doesn't pass through.
+ *
+ * The wrapper compiles to
+ *
+ *     local.get 0  local.get 1  local.get 2  local.get 3
+ *     i32.const 0                                ;; options
+ *     local.get 4
+ *     call $pcre2_match_16
+ *
+ * so the patch retypes `_match` to take a sixth i32 (the module already
+ * declares that exact signature, for pcre2_match_16 itself) and swaps
+ * `i32.const 0` for `local.get 5`. Both edits are the same size as what they
+ * replace, so no section or body length moves. A caller passing five arguments
+ * still gets options 0 — JS fills the missing one with `undefined` → 0 — and a
+ * caller passing six to the unpatched module has the sixth dropped, so either
+ * side can be old without breaking the other; only the speed differs.
+ *
+ * Returns a patched copy, or null when the bytes aren't the build this patch
+ * was written against (anything unexpected, so the caller falls back to the
+ * module as shipped rather than a guess). Already-patched input comes back
+ * unchanged, so it is safe to apply twice.
+ *
+ * UPGRADING pcre2-wasm-universal. This was derived against 1.0.0's
+ * dist/libpcre2.wasm (sha256 5ea911ab…0dc99e). The fallback keeps a new build
+ * correct, but at runtime it is silent: the speed-up is simply gone, and long
+ * lines go back to quadratic. So a bump that changes the wasm must re-derive
+ * the patch: disassemble the new binary (e.g. `wasm2wat`), find `_match`'s
+ * export and body, check it is still the pass-through above with options
+ * hard-coded to 0 and that a 6×i32 → i32 signature still exists, and adjust
+ * what `patch`/`bodyMatches` expect. If upstream grew a real options argument,
+ * drop this patch (and the transform in vitest.config.ts) instead.
+ *
+ * The bump can't slip through unnoticed: tests/triggers/pcreMatchAllLinear.test.ts
+ * ("recognises the installed pcre2-wasm-universal build" and "runs the wasm
+ * this suite patched") fails in `yarn test` with "pcre2 wasm patch did not
+ * apply; see vite-plugin/pcre2Wasm.ts" when the installed binary isn't
+ * recognised or the loaded module ignores PCRE2_NO_UTF_CHECK.
+ */
+export function patchLibpcre2Wasm(input) {
+    try {
+        return patch(input);
+    }
+    catch {
+        return null;
+    }
+}
+const SECTION_TYPE = 1;
+const SECTION_IMPORT = 2;
+const SECTION_FUNCTION = 3;
+const SECTION_EXPORT = 7;
+const SECTION_CODE = 10;
+const I32 = 0x7f;
+const LOCAL_GET = 0x20;
+const I32_CONST = 0x41;
+const CALL = 0x10;
+const END = 0x0b;
+function patch(input) {
+    const bytes = new Uint8Array(input);
+    if (bytes.length < 8 || bytes[0] !== 0 || bytes[1] !== 0x61 || bytes[2] !== 0x73 || bytes[3] !== 0x6d)
+        return null;
+    let pos = 8;
+    const readU32 = () => {
+        let result = 0;
+        let shift = 0;
+        for (;;) {
+            const b = bytes[pos++];
+            if (b === undefined)
+                throw new Error('truncated');
+            result |= (b & 0x7f) << shift;
+            if (!(b & 0x80))
+                return result >>> 0;
+            shift += 7;
+        }
+    };
+    const skipName = () => { const n = readU32(); pos += n; };
+    const readName = () => {
+        const n = readU32();
+        const s = new TextDecoder().decode(bytes.subarray(pos, pos + n));
+        pos += n;
+        return s;
+    };
+    /** param count of each i32-only signature returning one i32, else -1 */
+    let i32Sigs = [];
+    let importedFuncs = 0;
+    let functionSection = -1;
+    let codeSection = -1;
+    let matchFunc = -1;
+    while (pos < bytes.length) {
+        const id = bytes[pos++];
+        const size = readU32();
+        const start = pos;
+        const end = start + size;
+        if (id === SECTION_TYPE) {
+            const count = readU32();
+            i32Sigs = [];
+            for (let i = 0; i < count; i++) {
+                if (bytes[pos++] !== 0x60)
+                    throw new Error('type form');
+                const params = readU32();
+                let allI32 = true;
+                for (let p = 0; p < params; p++)
+                    if (bytes[pos++] !== I32)
+                        allI32 = false;
+                const results = readU32();
+                for (let r = 0; r < results; r++)
+                    if (bytes[pos++] !== I32)
+                        allI32 = false;
+                i32Sigs.push(allI32 && results === 1 ? params : -1);
+            }
+        }
+        else if (id === SECTION_IMPORT) {
+            const count = readU32();
+            for (let i = 0; i < count; i++) {
+                skipName();
+                skipName();
+                const kind = bytes[pos++];
+                if (kind === 0) {
+                    readU32();
+                    importedFuncs++;
+                }
+                else if (kind === 1) {
+                    pos++;
+                    const flags = readU32();
+                    readU32();
+                    if (flags & 1)
+                        readU32();
+                }
+                else if (kind === 2) {
+                    const flags = readU32();
+                    readU32();
+                    if (flags & 1)
+                        readU32();
+                }
+                else if (kind === 3) {
+                    pos += 2;
+                }
+                else
+                    throw new Error('import kind');
+            }
+        }
+        else if (id === SECTION_FUNCTION) {
+            functionSection = start;
+        }
+        else if (id === SECTION_EXPORT) {
+            const count = readU32();
+            for (let i = 0; i < count; i++) {
+                const name = readName();
+                const kind = bytes[pos++];
+                const index = readU32();
+                if (kind === 0 && name === '_match')
+                    matchFunc = index;
+            }
+        }
+        else if (id === SECTION_CODE) {
+            codeSection = start;
+        }
+        pos = end;
+    }
+    if (functionSection < 0 || codeSection < 0 || matchFunc < importedFuncs)
+        return null;
+    const local = matchFunc - importedFuncs;
+    // The function section entry naming `_match`'s type.
+    pos = functionSection;
+    const funcCount = readU32();
+    if (local >= funcCount)
+        return null;
+    for (let i = 0; i < local; i++)
+        readU32();
+    const typeAt = pos;
+    const typeIndex = readU32();
+    if (pos - typeAt !== 1)
+        return null;
+    const sixArgs = i32Sigs.indexOf(6);
+    if (sixArgs < 0 || sixArgs > 0x7f)
+        return null;
+    if (typeIndex === sixArgs) {
+        // Already retyped — accept only if the body reads its sixth argument.
+        return bodyMatches(bytes, codeSection, local, LOCAL_GET, 5) ? bytes : null;
+    }
+    if (i32Sigs[typeIndex] !== 5)
+        return null;
+    const optionsAt = bodyMatches(bytes, codeSection, local, I32_CONST, 0);
+    if (optionsAt === false)
+        return null;
+    bytes[typeAt] = sixArgs;
+    bytes[optionsAt] = LOCAL_GET;
+    bytes[optionsAt + 1] = 5;
+    return bytes;
+}
+/**
+ * Whether `_match`'s body is the four-argument pass-through, `op arg`, the
+ * fifth argument and a call — returning the offset of `op`, or false.
+ */
+function bodyMatches(bytes, codeSection, local, op, arg) {
+    let pos = codeSection;
+    const readU32 = () => {
+        let result = 0;
+        let shift = 0;
+        for (;;) {
+            const b = bytes[pos++];
+            result |= (b & 0x7f) << shift;
+            if (!(b & 0x80))
+                return result >>> 0;
+            shift += 7;
+        }
+    };
+    const count = readU32();
+    if (local >= count)
+        return false;
+    for (let i = 0; i < local; i++) {
+        const size = readU32();
+        pos += size;
+    }
+    const size = readU32();
+    const body = pos;
+    const expectHead = [0, LOCAL_GET, 0, LOCAL_GET, 1, LOCAL_GET, 2, LOCAL_GET, 3, op, arg, LOCAL_GET, 4, CALL];
+    for (let i = 0; i < expectHead.length; i++)
+        if (bytes[body + i] !== expectHead[i])
+            return false;
+    // The call's function index, then the end of the body.
+    pos = body + expectHead.length;
+    readU32();
+    if (bytes[pos] !== END || pos + 1 !== body + size)
+        return false;
+    return body + 9;
+}