wat4wasm 1.0.0

package/lib/processors/data.js

@@ -0,0 +1,188 @@
+import helpers from "../helpers.js"
+
+export const DATA_BLOCK_NAME = "data";
+export const SIZE_BLOCK_NAME = "data.size";
+export const VIEW_BLOCK_NAME = "data.view";
+
+const GENERATE_DATA_VIEWER = (size, $name) => {
+    return `
+    (block ${$name}>
+        (result externref)
+
+        (global.set $wat4wasm (call $self.Array<>ext))
+        
+        (call $self.Reflect.set<ext.i32.i32>
+            (global.get $wat4wasm) (i32.const 0) (i32.const ${size})
+        )
+
+        (global.set $wat4wasm
+            (call $self.Reflect.construct<ext.ext>ext
+                (ref.extern $self.Uint8Array<ext>)
+                (global.get $wat4wasm)
+            )
+        )
+        
+        (if (i32.const ${size})
+            (then
+                (i32.const 0)
+                (i64.load (i32.const 0))
+
+                (block $copy
+                    (i32.store (i32.const 0) (i32.const ${size}))
+                    (loop $i--
+                        (if (i32.load (i32.const 0))
+                            (then   
+                                (i32.store
+                                    (i32.const 0)
+                                    (i32.sub (i32.load (i32.const 0)) (i32.const 1))
+                                )
+
+                                (memory.init ${$name} 
+                                    (i32.const 4) 
+                                    (i32.load (i32.const 0)) 
+                                    (i32.const 1)
+                                )
+
+                                (call $self.Reflect.set<ext.i32.i32>
+                                    (global.get $wat4wasm)
+                                    (i32.load (i32.const 0))
+                                    (i32.load8_u (i32.const 4))
+                                )
+
+                                (br $i--)
+                            )
+                        )
+                    )
+                )
+
+                (i64.store (; stack stack ;))
+            )
+        )
+
+        (global.get $wat4wasm)
+        (global.set $wat4wasm (null))
+    )
+    `;
+};
+
+export default function (wat, WAT4WASM) {
+
+    const maskSet = new helpers.MaskSet(wat);
+
+    const externgetter = new Map();
+    const segmentSizes = new Map();
+    const sizeRequests = new Set();
+    const viewRequests = new Set();
+
+    while (maskSet.hasBlock(VIEW_BLOCK_NAME)) {
+        const block = maskSet.lastBlockOf(VIEW_BLOCK_NAME);
+        viewRequests.add(block);
+        maskSet.mask(block);
+    }
+
+    while (maskSet.hasBlock(SIZE_BLOCK_NAME)) {
+        const block = maskSet.lastBlockOf(SIZE_BLOCK_NAME);
+        sizeRequests.add(block);
+        maskSet.mask(block);
+    }
+
+    while (maskSet.hasBlock(DATA_BLOCK_NAME)) {
+
+        const block = maskSet.lastBlockOf(DATA_BLOCK_NAME);
+        const content = helpers.findQuotedText(block);
+
+        maskSet.mask(block);
+        if (helpers.hasProtocol(content) === false) {
+            continue;
+        }
+
+        let {
+            protocol, fullpath, directory,
+            filename, basename, extension
+        } = helpers.parseProtoPath(content);
+
+        if (protocol === "wasm://") {
+
+            const module_wat = `wat4wasm-${basename}.wat`;
+            const wasm_output = `wat4wasm-${basename}.wasm`;
+            const wat4wasm_out = `wat4wasm-${basename}.wasm.wat`;
+
+            const params = process.argv
+                .filter(a => a.startsWith("--"))
+                .filter(a => !a.startsWith("--input="))
+                .filter(a => !a.startsWith("--output="))
+                ;
+
+            helpers.copyFile(fullpath, module_wat)
+
+            const wat4wasm = process.argv[1];
+            const nodejs = process.argv[0];
+            const argv = Array.of(
+                wat4wasm,
+                `--input=${module_wat}`,
+                `--output=${wasm_output}`,
+                `--no-unlink`
+            ).concat(params);
+
+            helpers.spawnSync(nodejs, argv);
+
+            const { data, size } = helpers.readFileAsHex(wasm_output);
+
+            segmentSizes.set(block.$name, size);
+            maskSet.update(block, block.replace(content, data));
+
+            helpers.unlinkFile(module_wat);
+            helpers.unlinkFile(wasm_output);
+            helpers.unlinkFile(wat4wasm_out);
+        }
+
+        else if (protocol === "file://") {
+            const { data, size } = helpers.readFileAsHex(fullpath);
+            segmentSizes.set(block.$name, size);
+            maskSet.update(block, block.replace(content, data));
+        }
+    }
+
+    sizeRequests.forEach(block => {
+        const size = segmentSizes.get(block.$name);
+        const code = `(i32.const ${size})`;
+
+        maskSet.update(block, code);
+    });
+
+    viewRequests.forEach(block => {
+        block.id = helpers.referenceId();
+        maskSet.update(block, block.id);
+    });
+
+    wat = maskSet.restore();
+
+    let oninit = String();
+    viewRequests.forEach(block => {
+        if (externgetter.has(block.$name) === false) {
+            const size = segmentSizes.get(block.$name);
+            const code = GENERATE_DATA_VIEWER(size, block.$name);
+
+            const growRequest = WAT4WASM_GROW_EXTERN_TABLE(wat);
+            block.tableSetter = growRequest.generateSetter(code);
+
+            wat = growRequest.modifiedRaw;
+            oninit = `${oninit}\n\n${block.tableSetter}\n\n`;
+
+            externgetter.set(
+                block.$name,
+                growRequest.getter.concat(` ;; ${block.$name}\n`)
+            );
+        }
+    });
+
+    viewRequests.forEach(block => {
+        wat = wat.replaceAll(
+            block.id, externgetter.get(block.$name)
+        );
+    });
+
+    wat = APPEND_ON_EXTERN_READY(wat, oninit);
+
+    return wat;
+}

package/lib/processors/import.js

@@ -0,0 +1,178 @@
+import helpers from "../helpers.js"
+
+export const IMPORT_BLOCK_NAME = "import";
+
+const RAWBLOCK_IMPORT_CODE = (pathName, rawBlock) => `(import "${pathName.split(".").at(-2) || 'self'}" "${pathName.split(".").at(-1)}"  \t${rawBlock})`.replaceAll(" )", ")");
+const FUNCTION_IMPORT_CODE = ($name) => {
+    const namesig = $name.match(/\$(.[^<]*)<(.[^>]*)?>(.[^\s]*)?/).slice(1);
+    const [pathName, inputs = "", outputs = ""] = namesig;
+
+    const tagName = `func`;
+    const longType = t => ({ ext: 'externref', fun: 'funcref' })[t] || t;
+    const paramBlock = `(param${`.${inputs}`.split('.').map(longType).join(' ')})`;
+    const resultBlock = `(result${`.${outputs}`.split('.').map(longType).join(' ')})`;
+
+    return RAWBLOCK_IMPORT_CODE(pathName, `(${tagName} ${$name} ${paramBlock} ${resultBlock})`);
+}
+
+const GLOBAL_IMPORT_CODE = ($name) => {
+    const namesig = $name.match(/\$(.[^<]*)(?:\<(.[^>]*)\>)?/)?.slice(1) || [];
+    const [pathName = "self", type = "ext"] = namesig;
+
+    const tagName = "global";
+    const typeName = type.replace(`ext`, `externref`);
+
+    return RAWBLOCK_IMPORT_CODE(pathName, `(${tagName} ${$name} ${typeName})`);
+}
+
+const GLOBAL_DEFINE_CODE = ($name) => {
+    const [pathName = "self", type = "ext"] = helpers.nameSignatureofGlobal($name);
+
+    const tagName = "global";
+    const mutValue = t => `(mut ${({ ext: 'externref', fun: 'funcref' })[t] || t})`;
+    const nilValue = t => `(${({ ext: 'ref.null extern', fun: 'ref.null func' })[t] || `${t}.const 0`})`;
+
+    return `(${tagName} ${$name} ${mutValue(type)} ${nilValue(type)})`;
+}
+
+export const PATH_WALKER_CODE = ($name) => {
+
+    let descriptorKey;
+    [$name, descriptorKey = "value"] = $name.split("/")
+    const nameparts = $name.split("<").at(0).split("$").pop().split(".");
+    const stepType = new Array(nameparts.length - 1).fill("ext");
+    const type = $name.split(">").at(0).split("<").pop() || "ext";
+
+    let pathWalker = `(global.get $${nameparts[0]})`;
+    let currentKey;
+
+    stepType.push(type);
+    stepType.reverse().pop();
+    nameparts.reverse().pop();
+
+    let stepCount = nameparts.length;
+    if (descriptorKey !== "value") {
+        stepCount = stepCount - 1;
+    }
+
+    while (stepCount--) {
+        currentKey = nameparts.pop();
+        pathWalker = String(`
+        (call $self.Reflect.get<ext.ext>${stepType.pop()}
+            ${pathWalker} 
+            (text "${currentKey}") ;; ${currentKey}
+        )`).trim();
+    }
+
+    if (descriptorKey !== "value") {
+        currentKey = nameparts.pop();
+        pathWalker = String(`
+        (call $self.Reflect.get<ext.ext>ext
+            (call $self.Reflect.getOwnPropertyDescriptor<ext.ext>ext
+                ${pathWalker} 
+                (text "${currentKey}") ;; ${currentKey}
+            )
+            (text "${descriptorKey}") ;; ${descriptorKey}
+        )`).trim();
+    }
+
+    return String(`
+    ${pathWalker}
+    `);
+}
+
+export default function (wat, WAT4WASM) {
+
+    const maskSet = new helpers.MaskSet(wat);
+    const selfSet = new Set();
+    const imports = new Array();
+    const globals = new Array();
+    const oninits = new Array();
+
+    while (maskSet.hasBlock(IMPORT_BLOCK_NAME)) {
+        const wrapper = maskSet.lastBlockOf(IMPORT_BLOCK_NAME);
+        const $name = helpers.parseFirstBlock(wrapper).$name;
+
+        if ($name && $name.startsWith("$self")) {
+            if (selfSet.has($name) === false) {
+                selfSet.add($name);
+            }
+        }
+
+        maskSet.mask(wrapper);
+    }
+
+    while (maskSet.hasBlock("global.get")) {
+        const global = maskSet.lastBlockOf("global.get");
+        const $name = global.$name;
+
+        maskSet.mask(global);
+        maskSet.update(global, `(global.get ${$name})`);
+
+        if ($name && $name.startsWith("$self")) {
+            if (selfSet.has($name) === false) {
+                selfSet.add($name);
+
+                const [pathName = "self", type = "ext"
+                ] = helpers.nameSignatureofGlobal($name);
+
+                const nameparts = pathName.split(".");
+
+                /**
+                 * previous logic is based on direct import for
+                 * short paths but this is unnecessary.. just set
+                 * global value in the start function to gathering
+                 * more simple import segment. 
+                 */
+                //if (nameparts.length <= 3) {
+                if (["$self", "$self.String.fromCharCode"].includes($name)) {
+                    imports.push(GLOBAL_IMPORT_CODE($name));
+                }
+                else if (globals.includes($name) === false) {
+                    globals.push(GLOBAL_DEFINE_CODE($name));
+                    const walker = PATH_WALKER_CODE($name, global.descriptorKey);
+                    const setter = `(global.set ${$name} ${walker})`;
+                    oninits.push({ setter, name: $name.substring(1), type: 'global' });
+                }
+            }
+        }
+    }
+
+    while (maskSet.hasBlock("call")) {
+        const caller = maskSet.lastBlockOf("call");
+        const $name = caller.$name;
+
+        if ($name && $name.startsWith("$self")) {
+            if (selfSet.has($name) === false) {
+                selfSet.add($name);
+                imports.push(FUNCTION_IMPORT_CODE($name));
+            }
+        }
+
+        maskSet.mask(caller);
+    }
+
+    wat = maskSet.restore();
+
+    imports.forEach(code => {
+        if (wat.includes(code) === false) {
+            wat = helpers.prepend(wat, code);
+        }
+    });
+
+    globals.forEach(code => {
+        if (wat.includes(code) === false) {
+            wat = helpers.append(wat, code);
+        }
+    });
+
+    oninits.forEach(init => {
+        const header = `block $${init.type}/${init.name}`;
+        if (wat.includes(header) === false) {
+            const code = String(`(${header}\n${init.setter}\n)`);
+            wat = APPEND_ON_TEXT_READY(wat, code);
+        }
+    });
+
+    return wat;
+}

package/lib/processors/include.js

@@ -0,0 +1,17 @@
+import helpers from "../helpers.js"
+
+export const INCLUDE_BLOCK_NAME = "include";
+
+export default function (wat, WAT4WASM) {
+
+    while (helpers.hasBlock(wat, INCLUDE_BLOCK_NAME)) {
+        const block = helpers.lastBlockOf(wat, INCLUDE_BLOCK_NAME);
+        const path = helpers.findQuotedText(block);
+
+        wat = block.replacedRaw(
+            helpers.readFileAsText(path)
+        );
+    }
+
+    return wat;
+}

package/lib/processors/new.js

@@ -0,0 +1,21 @@
+import helpers from "../helpers.js"
+
+export const NEW_BLOCK_NAME = "new";
+
+export default function (wat) {
+
+    while (helpers.hasBlock(wat, NEW_BLOCK_NAME)) {
+
+        const block = helpers.lastBlockOf(wat, NEW_BLOCK_NAME);
+        const $name = block.$name;
+        const param = $name.split(">").at(0).split("<").at(1) || "";
+
+        const $constructor = `(ref.extern $self.${$name.substring(1)}<ext>)`;
+        const $arguments = block.replace(`(new ${$name}`, `(array $of<${param}>ext`);
+        const $reflect = `(reflect $construct<ext.ext>ext\n${$constructor}\n${$arguments}\n)`;
+
+        wat = block.replacedRaw($reflect);
+    }
+
+    return wat;
+}

package/lib/processors/ref_extern.js

@@ -0,0 +1,64 @@
+import helpers from "../helpers.js"
+import { PATH_WALKER_CODE } from "./import.js";
+
+export const REF_EXTERN_BLOCK_NAME = "ref.extern";
+
+const FIXNAME_SELF_PATH = ($name, descriptorKey) => {
+
+    if ($name.startsWith("$self") === false) {
+        $name = `$self.${$name.substring(1)}`;
+    }
+
+    if ($name.endsWith(">") === false) {
+        if (descriptorKey === "value") {
+            $name = `${$name}<ext>`;
+        }
+    }
+
+    return $name;
+};
+
+export default function (wat, WAT4WASM) {
+
+    const externs = new Map();
+    const getters = new Map();
+    const maskSet = new helpers.MaskSet(wat);
+
+    while (maskSet.hasBlock(REF_EXTERN_BLOCK_NAME)) {
+        const block = maskSet.lastBlockOf(REF_EXTERN_BLOCK_NAME);
+        const $name = FIXNAME_SELF_PATH(block.$name, block.descriptorKey);
+
+        if (externs.has($name) === false) {
+            externs.set($name, block.descriptorKey);
+        }
+
+        maskSet.mask(block);
+    }
+
+    wat = maskSet.restore();
+
+    let oninit = String();
+    externs.forEach((dKey, $name) => {
+        const pathWalker = PATH_WALKER_CODE($name);
+        const growExtern = WAT4WASM_GROW_EXTERN_TABLE(wat);
+
+        const __getter__ = growExtern.getter.concat(` ;; ${$name}\n`);
+        const __setter__ = growExtern.generateSetter(pathWalker);
+
+        wat = growExtern.modifiedRaw;
+        oninit = `${oninit}\n\n(block ${$name}\n${__setter__})\n`;
+        getters.set($name, __getter__);
+    });
+
+    while (helpers.hasBlock(wat, REF_EXTERN_BLOCK_NAME)) {
+        const block = helpers.lastBlockOf(wat, REF_EXTERN_BLOCK_NAME);
+        const $name = FIXNAME_SELF_PATH(block.$name, block.descriptorKey);
+        wat = block.replacedRaw(getters.get($name));
+    }
+
+    if (oninit.trim()) {
+        wat = APPEND_ON_TEXT_READY(wat, oninit);
+    }
+
+    return wat;
+}

package/lib/processors/ref_func.js

@@ -0,0 +1,44 @@
+import helpers from "../helpers.js"
+
+export const REF_FUNC_BLOCK_NAME = "ref.func";
+
+export default function (wat, WAT4WASM) {
+
+    const maskSetElem = new helpers.MaskSet(wat);
+    const elemSegments = new Array();
+    const needReference = new Set();
+
+    while (maskSetElem.hasBlock("elem")) {
+        const block = maskSetElem.lastBlockOf("elem");
+        const $name = block.$name;
+        if (WAT4WASM.WAT4WASM_$NAME !== $name) {
+            elemSegments.push(block.toString());
+        }
+        maskSetElem.mask(block);
+    }
+
+    const maskSetRef = new helpers.MaskSet(wat);
+
+    while (maskSetRef.hasBlock(REF_FUNC_BLOCK_NAME)) {
+        const block = maskSetRef.lastBlockOf(REF_FUNC_BLOCK_NAME);
+        const $name = block.$name
+
+        if (WAT4WASM.WAT4WASM_$NAME !== $name) {
+            if (elemSegments.some(seg => seg.includes($name)) === false) {
+                if (needReference.has($name) === false) {
+                    needReference.add($name);
+                }
+            }
+        }
+
+        maskSetRef.mask(block);
+    }
+
+    wat = maskSetRef.restore();
+
+    needReference.forEach($name => {
+        wat = WAT4WASM_REFERENCE_FUNC_ELEMENT(wat, $name);
+    });
+
+    return wat;
+}

package/lib/processors/replace_all.js

@@ -0,0 +1,56 @@
+
+export default function (wat) {
+    return wat
+        .replaceAll("(self)", "(global.get $self)")
+        .replaceAll("(null)", "(ref.null extern)")
+        .replaceAll("(func)", "(ref.null func)")
+        .replaceAll("(this)", "(local.get 0)")
+        .replaceAll("(array)", "(call $self.Array<>ext)")
+        .replaceAll("(NaN)", "(ref.extern $self.NaN<ext>)")
+        .replaceAll("(nan)", "(f32.const nan)")
+        .replaceAll("(true)", "(i32.const 1)")
+        .replaceAll("(false)", "(i32.const 0)")
+        .replaceAll("(undefined)", "(ref.extern $self.undefined<ext>)")
+        .replaceAll("(object)", "(call $self.Object<>ext)")
+        .replaceAll("(string)", "(call $self.String<>ext)")
+        .replaceAll("(console $", "(call $self.console.")
+        .replaceAll("(reflect $", "(call $self.Reflect.")
+        .replaceAll("(bigint $", "(call $self.BigInt.")
+        .replaceAll("(number $", "(call $self.Number.")
+        .replaceAll("(math $", "(call $self.Math.")
+        .replaceAll("(string $", "(call $self.String.")
+        .replaceAll("(object $", "(call $self.Object.")
+        .replaceAll("(array $", "(call $self.Array.")
+        .replaceAll("(grow $", "(table.grow $")
+        .replaceAll("(url $", "(call $self.URL.")
+        .replaceAll("(self $", "(ref.extern $self.")
+        .replaceAll(" mut ext)", " (mut externref) (null))")
+        .replaceAll(" mut fun)", " (mut funcref) (func))")
+        .replaceAll(" mut vec)", " (mut v128) (v128.const i32x4 0 0 0 0))")
+        .replaceAll(" fun)", " funcref)")
+        .replaceAll(" ext)", " externref)")
+        .replaceAll(" != null)", ") (ref.is_null) (i32.eqz)")
+        .replaceAll(" == null)", ") (ref.is_null)")
+        .replaceAll(" == 0)", ") (i32.eqz)")
+        .replaceAll(" != 0)", ") (i32.const 0) (i32.ne)")
+        .replaceAll(" == 1)", ") (i32.const 1) (i32.eq)")
+        .replaceAll(" != 1)", ") (i32.const 1) (i32.ne)")
+        .replaceAll(" == true)", ") (i32.const 1) (i32.eq)")
+        .replaceAll(" == false)", ") (i32.eqz)")
+        .replaceAll(" == nan)", ") (f32.const nan) (f32.eq)")
+        .replaceAll(" != nan)", ") (f32.const nan) (f32.ne)")
+        .replaceAll(" != NaN)", ") (NaN) (object $is<ext.ext>i32) (i32.eqz)")
+        .replaceAll(" == NaN)", ") (NaN) (object $is<ext.ext>i32)")
+        .replaceAll(" != undefined)", ") (undefined) (object $is<ext.ext>i32) (i32.eqz)")
+        .replaceAll(" == undefined)", ") (undefined) (object $is<ext.ext>i32)")
+        .replaceAll(/ mut\s+(i32|f32|i64|f64)\)/g, ` (mut $1) ($1.const 0))`)
+        .replaceAll(/\<[A-Z](.[^>]*)\>/g, "externref")
+        .replaceAll(/\(l(get|set|tee)(\s)/g, `(local.$1$2`)
+        .replaceAll(/\(g(get|set)(\s)/g, `(global.$1$2`)
+        .replaceAll(/\(t(get|set)(\s)/g, `(table.$1$2`)
+        .replaceAll(/(i32|f32|i64|f64|fun|ext)\((\+|\-|)\s*([0-9\.]+)\)/g, `($1.const $2$3)`)
+        .replaceAll(/\((.*)\.(set|tee)\s+([\+|\-])+\s+(\$.*)\s*\)/g, "($1.$2 $4 (i32.add ($1.get $4) (i32.const $31)))")
+        .replaceAll(/\(apply(?:\.*)(i32|f32|i64|f64|fun|ext|)(\s*)/g, `(call $self.Reflect.apply<ext.ext.ext>$1 $2`)
+        .replaceAll(/\(main(\s+)(\$.[^\s]*)(\s)/g, `(start$1$2)\n\n(func$1$2$3`)
+        ;
+}

package/lib/processors/start.js

@@ -0,0 +1,42 @@
+import helpers from "../helpers.js"
+
+export const START_BLOCK_NAME = "start";
+
+export default function (wat, WAT4WASM) {
+    let startCalls = [];
+    let removedWat = wat;
+
+    while (helpers.hasBlock(removedWat, START_BLOCK_NAME)) {
+        let block = helpers.lastBlockOf(removedWat, START_BLOCK_NAME);
+        removedWat = block.removedRaw();
+
+        if (block.includes(WAT4WASM.WAT4WASM_$NAME) === false) {
+            startCalls.push(block);
+        }
+    }
+
+    if (startCalls.length > 0) {
+        wat = removedWat;
+
+        let $wat4func = helpers.lastBlockOf(wat, "func", { $name: WAT4WASM.WAT4WASM_$NAME });
+        let funcblock = $wat4func.toString();
+
+        const appends = startCalls.filter(start => {
+            let $name = `${start.$name}`;
+            let $call = `(call ${$name})`;
+
+            if (helpers.hasBlock(funcblock, "call", { $name }) === false) {
+                funcblock = helpers.append(funcblock, $call);
+                return true;
+            }
+        });
+
+        if (appends.length) {
+            wat = $wat4func.replacedRaw(funcblock);
+        }
+
+        wat = helpers.append(wat, WAT4WASM.WAT4WASM_START);
+    }
+
+    return wat;
+}

package/lib/processors/string.js

@@ -0,0 +1,57 @@
+import helpers from "../helpers.js"
+
+export const STRING_BLOCK_NAME = "string";
+
+export default function (wat) {
+
+    while (helpers.hasBlock(wat, STRING_BLOCK_NAME)) {
+
+        let oldBlock = helpers.lastBlockOf(wat, STRING_BLOCK_NAME);
+        const string = helpers.findQuotedText(oldBlock);
+        const ccodes = helpers.encodeString(string);
+
+        if (ccodes.length === 0) {
+            wat = oldBlock.replacedRaw(`
+                (reflect $apply<ext.ext.ext>ext
+                    (global.get $self.String.fromCharCode) 
+                    (self)
+                    (self)
+                )
+            `);
+        }
+        else if (ccodes.length === 1) {
+            wat = oldBlock.replacedRaw(`
+                (reflect $apply<ext.ext.ext>ext
+                    (global.get $self.String.fromCharCode)
+                    (self)
+                    (array $of<i32>ext (i32.const ${string.charCodeAt(0)})) ;; "${string}"
+                )
+            `);
+        }
+        else {
+            wat = oldBlock.replacedRaw(`
+                (block (; "${helpers.abstract(string)}" ;)
+                    (result externref)
+                    (global.set $wat4wasm (call $self.Array<>ext))
+                    
+                    ${ccodes
+                    .map((c, i) => `(global.get $wat4wasm) (i32.const ${i}) (i32.const ${c})`)
+                    .map((args) => `(call $self.Reflect.set<ext.i32.i32> ${args})`)
+                    .join("\n")}
+    
+                    (call $self.Reflect.apply<ext.ext.ext>ext
+                        (global.get $self.String.fromCharCode) 
+                        (ref.null extern) 
+                        (global.get $wat4wasm)
+                    ) 
+                    ;; stacked
+    
+                    (global.set $wat4wasm (null)) 
+                    ;; cleared
+                )
+            `);
+        }
+    }
+
+    return wat;
+}