wat4wasm 1.1.4 → 1.1.6

package/examples/04-ref.func/module-output.wat

@@ -4,21 +4,30 @@
 
 
 
+
+
   (func $unreferenced_by_user)
 
 
 
 
 
-  (elem $wat4wasm declare func $unreferenced_by_user)
+  (elem $wat4wasm declare func $inline $unreferenced_by_user)
+
+
+
 
 
 
 
+  (memory $wat4wasm 1)
 
 
+  (func $inline
+    (local $a i32)
+    (local.set $a (i32.const 2))
+  )
 
 
 
-  (start $wat4wasm)
 )

package/examples/04-ref.func/module.wat

@@ -4,5 +4,12 @@
         (drop)
     )
 
+    (func $test_inline
+        (func $inline
+            (local $a i32)
+            (local.set $a (i32.const 2))
+        )
+    )
+
     (func $unreferenced_by_user)
 )

package/examples/shell-usages.sh

@@ -1,36 +1,29 @@
 cd 01-text
 wat4wasm --input=module.wat --output=module-output.wat
-rm wat4wasm
 cd ..
 
 cd 02-include
 wat4wasm --input=module.wat --output=module-output.wat
-rm wat4wasm
 cd ..
 
 cd 03-ref.extern
 wat4wasm --input=module.wat --output=module-output.wat
-rm wat4wasm
 cd ..
 
 cd 04-ref.func
 wat4wasm --input=module.wat --output=module-output.wat
-rm wat4wasm
 cd ..
 
 cd 05-global.get
 wat4wasm --input=module.wat --output=module-output.wat
-rm wat4wasm
 cd ..
 
 cd 06-async
 wat4wasm --input=module.wat --output=module-output.wat
-rm wat4wasm
 cd ..
 
 cd 07-data
 wat4wasm --input=module.wat --output=module-output.wat --wat2wasm=wat2wasm
-rm wat4wasm
 cd ..
 
 cd 08-reflectors

package/lib/helpers.js

@@ -217,7 +217,7 @@ const helpers = {
         return keyword;
     },
 
-    fixBlockKeyword(keyword, filter = {}) {
+    fixBlockKeyword(keyword = "", filter = {}) {
         if (keyword.split(/\s/).length > 1) {
             throw new Error(`Given keyword is wrong: ${keyword}`)
         }
@@ -499,6 +499,7 @@ const helpers = {
                     after: this.input.substring(this.end)
                 }
             },
+            mask: function (block) { return this.block = block.removedRaw(); },
             maskedRaw: function () { return this.replacedRaw(this.uuid); },
             removedRaw: function () { return this.replacedRaw(""); },
             replacedRaw: function (str) {
@@ -528,26 +529,54 @@ const helpers = {
                     return blockName;
                 }
             },
+            parentBlock: {
+                value: function () {
+                    const lastBlockBefore = helpers.lastBlockBefore(this.toString(), this.begin);
+                    if (lastBlockBefore) {
+                        if (lastBlockBefore.end > this.end) {
+                            return lastBlockBefore;
+                        }
+                        return lastBlockBefore.parentBlock();
+                    }
+                }
+            },
             generateId: { value: function () { return helpers.generateId(this.toString()) } },
             name: { get: function () { return `${this.$name}`.substring(1); } },
             rawContent: { get: function () { return helpers.rawContent(this.toString()) } },
             blockContent: { get: function () { return helpers.blockContent(this.toString()) } },
             hasAnyBlock: { get: function () { return helpers.hasAnyBlock(this.toString()) } },
-            indexOf: { value: function () { return this.block.indexOf(...arguments) } },
-            includes: { value: function () { return this.block.includes(...arguments) } },
-            lastIndexOf: { value: function () { return this.block.lastIndexOf(...arguments) } },
-            split: { value: function () { return this.block.split(...arguments) } },
-            at: { value: function () { return this.block.at(...arguments) } },
-            length: { get: function () { return this.block.length } },
+            indexOf: { value: function () { return this.toString().indexOf(...arguments) } },
+            includes: { value: function () { return this.toString().includes(...arguments) } },
+            lastIndexOf: { value: function () { return this.toString().lastIndexOf(...arguments) } },
+            split: { value: function () { return this.toString().split(...arguments) } },
+            at: { value: function () { return this.toString().at(...arguments) } },
+            length: { get: function () { return this.toString().length } },
             charCodeAt: { value: function () { return this.block.charCodeAt(...arguments) } },
-            concat: { value: function () { return this.block.concat(...arguments) } },
-            startsWith: { value: function () { return this.block.startsWith(...arguments) } },
-            endsWith: { value: function () { return this.block.endsWith(...arguments) } },
-            substring: { value: function () { return this.block.substring(...arguments) } },
-            replace: { value: function () { return this.block.replace(...arguments) } },
-            replaceAll: { value: function () { return this.block.replaceAll(...arguments) } },
-            lastBlockOf: { value: function () { return helpers.lastBlockOf(this.block, ...arguments) } },
-            [Symbol.toPrimitive]: { value: function () { return this.block; } },
+            children: {
+                get: function () {
+                    const blocks = new Array();
+                    let firstBlock, code = this.toString().substring(1, this.length - 1);
+
+                    while (code.includes("(")) {
+                        firstBlock = helpers.parseBlockAt(
+                            code, code.indexOf("(")
+                        ).toString();
+
+                        blocks.push(firstBlock);
+                        code = code.replace(firstBlock, "");
+                    }
+
+                    return blocks;
+                }
+            },
+            concat: { value: function () { return this.toString().concat(...arguments) } },
+            startsWith: { value: function () { return this.toString().startsWith(...arguments) } },
+            endsWith: { value: function () { return this.toString().endsWith(...arguments) } },
+            substring: { value: function () { return this.toString().substring(...arguments) } },
+            replace: { value: function () { return this.toString().replace(...arguments) } },
+            replaceAll: { value: function () { return this.toString().replaceAll(...arguments) } },
+            lastBlockOf: { value: function () { return helpers.lastBlockOf(this.toString(), ...arguments) } },
+            [Symbol.toPrimitive]: { value: function () { return this.toString(); } },
         })
     },
 
@@ -591,6 +620,10 @@ const helpers = {
     parseFirstBlock(raw) {
         raw = raw.toString();
         return this.parseBlockAt(raw, raw.indexOf("(", 1));
+    },
+
+    lastBlockBefore(raw, begin) {
+        return this.parseBlockAt(raw, raw.lastIndexOf("(", raw.substring(0, begin)));
     }
 };
 

package/lib/processors/data.js

@@ -1,12 +1,8 @@
 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}>
+    (block ${$name}
         (result externref)
 
         (global.set $wat4wasm (call $self.Array<>ext))
@@ -65,6 +61,178 @@ const GENERATE_DATA_VIEWER = (size, $name) => {
     `;
 };
 
+const GENERATE_TEXT_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 ;))
+            )
+        )
+
+        
+        (local.set $arguments (call $self.Array<>ext))
+        
+        (call $self.Reflect.set<ext.i32.ext>
+          (local.get $arguments)
+          (i32.const 0)
+          (global.get $wat4wasm)
+        )
+
+        (call $self.Reflect.apply<ext.ext.ext>ext
+            (local.get $textDecoder.decode)
+            (local.get $textDecoder)
+            (local.get $arguments) 
+        )
+            
+        (global.set $wat4wasm (null))
+    )
+    `;
+};
+
+const GENERATE_HREF_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 ;))
+            )
+        )
+
+        
+        (local.set $arguments (call $self.Array<>ext))
+        
+        (call $self.Reflect.set<ext.i32.ext>
+          (local.get $arguments)
+          (i32.const 0)
+          (global.get $wat4wasm)
+        )
+
+        (call $self.Reflect.set<ext.i32.ext>
+            (local.get $arguments)
+            (i32.const 0)
+            (call $self.Reflect.apply<ext.ext.ext>ext
+                (local.get $textDecoder.decode)
+                (local.get $textDecoder)
+                (local.get $arguments) 
+            )
+        )
+
+        (call $self.Reflect.set<ext.i32.ext>
+            (local.get $arguments)
+            (i32.const 0)
+            (call $self.Reflect.construct<ext.ext>ext
+                (call $self.Reflect.get<ext.ext>ext (self) (string "Blob"))
+                (local.get $arguments) 
+            )
+        )
+
+        (call $self.Reflect.apply<ext.ext.ext>ext
+            (call $self.Reflect.get<ext.ext>ext 
+                (call $self.Reflect.get<ext.ext>ext (self) (string "URL"))
+                (string "createObjectURL")
+            )
+            (null)
+            (local.get $arguments) 
+        )
+            
+        (global.set $wat4wasm (null))
+    )
+    `;
+};
+
 export default function (wat, WAT4WASM) {
 
     const maskSet = new helpers.MaskSet(wat);
@@ -73,22 +241,36 @@ export default function (wat, WAT4WASM) {
     const segmentSizes = new Map();
     const sizeRequests = new Set();
     const viewRequests = new Set();
+    const textRequests = new Set();
+    const hrefRequests = new Set();
+
+    while (maskSet.hasBlock("data.text")) {
+        const block = maskSet.lastBlockOf("data.text");
+        textRequests.add(block);
+        maskSet.mask(block);
+    }
 
-    while (maskSet.hasBlock(VIEW_BLOCK_NAME)) {
-        const block = maskSet.lastBlockOf(VIEW_BLOCK_NAME);
+    while (maskSet.hasBlock("data.href")) {
+        const block = maskSet.lastBlockOf("data.href");
+        hrefRequests.add(block);
+        maskSet.mask(block);
+    }
+
+    while (maskSet.hasBlock("data.view")) {
+        const block = maskSet.lastBlockOf("data.view");
         viewRequests.add(block);
         maskSet.mask(block);
     }
 
-    while (maskSet.hasBlock(SIZE_BLOCK_NAME)) {
-        const block = maskSet.lastBlockOf(SIZE_BLOCK_NAME);
+    while (maskSet.hasBlock("data.size")) {
+        const block = maskSet.lastBlockOf("data.size");
         sizeRequests.add(block);
         maskSet.mask(block);
     }
 
-    while (maskSet.hasBlock(DATA_BLOCK_NAME)) {
+    while (maskSet.hasBlock("data")) {
 
-        const block = maskSet.lastBlockOf(DATA_BLOCK_NAME);
+        const block = maskSet.lastBlockOf("data");
         const content = helpers.findQuotedText(block);
 
         maskSet.mask(block);
@@ -155,9 +337,20 @@ export default function (wat, WAT4WASM) {
         maskSet.update(block, block.id);
     });
 
+    textRequests.forEach(block => {
+        block.id = helpers.referenceId();
+        maskSet.update(block, block.id);
+    });
+
+    hrefRequests.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);
@@ -176,12 +369,60 @@ export default function (wat, WAT4WASM) {
         }
     });
 
+    textRequests.forEach(block => {
+        if (externgetter.has(block.$name) === false) {
+            const size = segmentSizes.get(block.$name);
+            const code = GENERATE_TEXT_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`)
+            );
+        }
+    });
+
+    hrefRequests.forEach(block => {
+        if (externgetter.has(block.$name) === false) {
+            const size = segmentSizes.get(block.$name);
+            const code = GENERATE_HREF_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)
         );
     });
 
+    textRequests.forEach(block => {
+        wat = wat.replaceAll(
+            block.id, externgetter.get(block.$name)
+        );
+    });
+
+    hrefRequests.forEach(block => {
+        wat = wat.replaceAll(
+            block.id, externgetter.get(block.$name)
+        );
+    });
+
     wat = APPEND_ON_EXTERN_READY(wat, oninit);
 
     return wat;

package/lib/processors/ref_func.js

@@ -4,6 +4,31 @@ export const REF_FUNC_BLOCK_NAME = "ref.func";
 
 export default function (wat, WAT4WASM) {
 
+    const inlineFunctions = new Array();
+
+    helpers
+        .parseBlockAt(wat.toString(), 0)
+        .children
+        .filter(b => b.startsWith("(func"))
+        .filter(b => b.substring(1).includes("(func"))
+        .map(b => b.substring(5, b.length - 1).trim())
+        .forEach(content => {
+            const maskSet = new helpers.MaskSet(content);
+            while (maskSet.hasBlock("func")) {
+                const inl = maskSet.lastBlockOf("func");
+                inlineFunctions.push(helpers.parseBlockAt(inl.toString(), 0));
+                maskSet.mask(inl);
+            }
+        })
+        ;
+
+    if (inlineFunctions.length) {
+        inlineFunctions.forEach(func => {
+            wat = wat.replace(func.toString(), `(ref.func ${func.$name})`)
+        });
+        wat = helpers.append(wat, inlineFunctions.map(func => `\n\t${func}\n`).join("\n"));
+    }
+
     const maskSetElem = new helpers.MaskSet(wat);
     const elemSegments = new Array();
     const needReference = new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wat4wasm",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "",
   "homepage": "https://github.com/central-network/wat4wasm#readme",
   "bugs": {

package/wat4wasm

@@ -483,7 +483,7 @@ function wat4beauty(watContent, alignIndentsWith = "\t", exportPadStart = 90) {
         }
         return keyword;
     },
-    fixBlockKeyword(keyword, filter = {}) {
+    fixBlockKeyword(keyword = "", filter = {}) {
         if (keyword.split(/\s/).length > 1) {
             throw new Error(`Given keyword is wrong: ${keyword}`)
         }
@@ -704,6 +704,7 @@ function wat4beauty(watContent, alignIndentsWith = "\t", exportPadStart = 90) {
                     after: this.input.substring(this.end)
                 }
             },
+            mask: function (block) { return this.block = block.removedRaw(); },
             maskedRaw: function () { return this.replacedRaw(this.uuid); },
             removedRaw: function () { return this.replacedRaw(""); },
             replacedRaw: function (str) {
@@ -731,26 +732,51 @@ function wat4beauty(watContent, alignIndentsWith = "\t", exportPadStart = 90) {
                     return blockName;
                 }
             },
+            parentBlock: {
+                value: function () {
+                    const lastBlockBefore = helpers.lastBlockBefore(this.toString(), this.begin);
+                    if (lastBlockBefore) {
+                        if (lastBlockBefore.end > this.end) {
+                            return lastBlockBefore;
+                        }
+                        return lastBlockBefore.parentBlock();
+                    }
+                }
+            },
             generateId: { value: function () { return helpers.generateId(this.toString()) } },
             name: { get: function () { return `${this.$name}`.substring(1); } },
             rawContent: { get: function () { return helpers.rawContent(this.toString()) } },
             blockContent: { get: function () { return helpers.blockContent(this.toString()) } },
             hasAnyBlock: { get: function () { return helpers.hasAnyBlock(this.toString()) } },
-            indexOf: { value: function () { return this.block.indexOf(...arguments) } },
-            includes: { value: function () { return this.block.includes(...arguments) } },
-            lastIndexOf: { value: function () { return this.block.lastIndexOf(...arguments) } },
-            split: { value: function () { return this.block.split(...arguments) } },
-            at: { value: function () { return this.block.at(...arguments) } },
-            length: { get: function () { return this.block.length } },
+            indexOf: { value: function () { return this.toString().indexOf(...arguments) } },
+            includes: { value: function () { return this.toString().includes(...arguments) } },
+            lastIndexOf: { value: function () { return this.toString().lastIndexOf(...arguments) } },
+            split: { value: function () { return this.toString().split(...arguments) } },
+            at: { value: function () { return this.toString().at(...arguments) } },
+            length: { get: function () { return this.toString().length } },
             charCodeAt: { value: function () { return this.block.charCodeAt(...arguments) } },
-            concat: { value: function () { return this.block.concat(...arguments) } },
-            startsWith: { value: function () { return this.block.startsWith(...arguments) } },
-            endsWith: { value: function () { return this.block.endsWith(...arguments) } },
-            substring: { value: function () { return this.block.substring(...arguments) } },
-            replace: { value: function () { return this.block.replace(...arguments) } },
-            replaceAll: { value: function () { return this.block.replaceAll(...arguments) } },
-            lastBlockOf: { value: function () { return helpers.lastBlockOf(this.block, ...arguments) } },
-            [Symbol.toPrimitive]: { value: function () { return this.block; } },
+            children: {
+                get: function () {
+                    const blocks = new Array();
+                    let firstBlock, code = this.toString().substring(1, this.length - 1);
+                    while (code.includes("(")) {
+                        firstBlock = helpers.parseBlockAt(
+                            code, code.indexOf("(")
+                        ).toString();
+                        blocks.push(firstBlock);
+                        code = code.replace(firstBlock, "");
+                    }
+                    return blocks;
+                }
+            },
+            concat: { value: function () { return this.toString().concat(...arguments) } },
+            startsWith: { value: function () { return this.toString().startsWith(...arguments) } },
+            endsWith: { value: function () { return this.toString().endsWith(...arguments) } },
+            substring: { value: function () { return this.toString().substring(...arguments) } },
+            replace: { value: function () { return this.toString().replace(...arguments) } },
+            replaceAll: { value: function () { return this.toString().replaceAll(...arguments) } },
+            lastBlockOf: { value: function () { return helpers.lastBlockOf(this.toString(), ...arguments) } },
+            [Symbol.toPrimitive]: { value: function () { return this.toString(); } },
         })
     },
     lastBlockOf(raw, keyword, filter) {
@@ -782,6 +808,9 @@ function wat4beauty(watContent, alignIndentsWith = "\t", exportPadStart = 90) {
     parseFirstBlock(raw) {
         raw = raw.toString();
         return this.parseBlockAt(raw, raw.indexOf("(", 1));
+    },
+    lastBlockBefore(raw, begin) {
+        return this.parseBlockAt(raw, raw.lastIndexOf("(", raw.substring(0, begin)));
     }
 };
 
@@ -823,12 +852,9 @@ function ASYNC (wat, WAT4WASM) {
     return wat;
 }
 
-const DATA_BLOCK_NAME = "data";
-const SIZE_BLOCK_NAME = "data.size";
-const VIEW_BLOCK_NAME = "data.view";
 const GENERATE_DATA_VIEWER = (size, $name) => {
     return `
-    (block ${$name}>
+    (block ${$name}
         (result externref)
         (global.set $wat4wasm (call $self.Array<>ext))
         
@@ -878,24 +904,186 @@ const GENERATE_DATA_VIEWER = (size, $name) => {
     )
     `;
 };
+const GENERATE_TEXT_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 ;))
+            )
+        )
+        
+        (local.set $arguments (call $self.Array<>ext))
+        
+        (call $self.Reflect.set<ext.i32.ext>
+          (local.get $arguments)
+          (i32.const 0)
+          (global.get $wat4wasm)
+        )
+        (call $self.Reflect.apply<ext.ext.ext>ext
+            (local.get $textDecoder.decode)
+            (local.get $textDecoder)
+            (local.get $arguments) 
+        )
+            
+        (global.set $wat4wasm (null))
+    )
+    `;
+};
+const GENERATE_HREF_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 ;))
+            )
+        )
+        
+        (local.set $arguments (call $self.Array<>ext))
+        
+        (call $self.Reflect.set<ext.i32.ext>
+          (local.get $arguments)
+          (i32.const 0)
+          (global.get $wat4wasm)
+        )
+        (call $self.Reflect.set<ext.i32.ext>
+            (local.get $arguments)
+            (i32.const 0)
+            (call $self.Reflect.apply<ext.ext.ext>ext
+                (local.get $textDecoder.decode)
+                (local.get $textDecoder)
+                (local.get $arguments) 
+            )
+        )
+        (call $self.Reflect.set<ext.i32.ext>
+            (local.get $arguments)
+            (i32.const 0)
+            (call $self.Reflect.construct<ext.ext>ext
+                (call $self.Reflect.get<ext.ext>ext (self) (string "Blob"))
+                (local.get $arguments) 
+            )
+        )
+        (call $self.Reflect.apply<ext.ext.ext>ext
+            (call $self.Reflect.get<ext.ext>ext 
+                (call $self.Reflect.get<ext.ext>ext (self) (string "URL"))
+                (string "createObjectURL")
+            )
+            (null)
+            (local.get $arguments) 
+        )
+            
+        (global.set $wat4wasm (null))
+    )
+    `;
+};
 function DATA (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);
+    const textRequests = new Set();
+    const hrefRequests = new Set();
+    while (maskSet.hasBlock("data.text")) {
+        const block = maskSet.lastBlockOf("data.text");
+        textRequests.add(block);
+        maskSet.mask(block);
+    }
+    while (maskSet.hasBlock("data.href")) {
+        const block = maskSet.lastBlockOf("data.href");
+        hrefRequests.add(block);
+        maskSet.mask(block);
+    }
+    while (maskSet.hasBlock("data.view")) {
+        const block = maskSet.lastBlockOf("data.view");
         viewRequests.add(block);
         maskSet.mask(block);
     }
-    while (maskSet.hasBlock(SIZE_BLOCK_NAME)) {
-        const block = maskSet.lastBlockOf(SIZE_BLOCK_NAME);
+    while (maskSet.hasBlock("data.size")) {
+        const block = maskSet.lastBlockOf("data.size");
         sizeRequests.add(block);
         maskSet.mask(block);
     }
-    while (maskSet.hasBlock(DATA_BLOCK_NAME)) {
-        const block = maskSet.lastBlockOf(DATA_BLOCK_NAME);
+    while (maskSet.hasBlock("data")) {
+        const block = maskSet.lastBlockOf("data");
         const content = helpers.findQuotedText(block);
         maskSet.mask(block);
         if (helpers.hasProtocol(content) === false) {
@@ -946,6 +1134,14 @@ function DATA (wat, WAT4WASM) {
         block.id = helpers.referenceId();
         maskSet.update(block, block.id);
     });
+    textRequests.forEach(block => {
+        block.id = helpers.referenceId();
+        maskSet.update(block, block.id);
+    });
+    hrefRequests.forEach(block => {
+        block.id = helpers.referenceId();
+        maskSet.update(block, block.id);
+    });
     wat = maskSet.restore();
     let oninit = String();
     viewRequests.forEach(block => {
@@ -962,11 +1158,49 @@ function DATA (wat, WAT4WASM) {
             );
         }
     });
+    textRequests.forEach(block => {
+        if (externgetter.has(block.$name) === false) {
+            const size = segmentSizes.get(block.$name);
+            const code = GENERATE_TEXT_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`)
+            );
+        }
+    });
+    hrefRequests.forEach(block => {
+        if (externgetter.has(block.$name) === false) {
+            const size = segmentSizes.get(block.$name);
+            const code = GENERATE_HREF_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)
         );
     });
+    textRequests.forEach(block => {
+        wat = wat.replaceAll(
+            block.id, externgetter.get(block.$name)
+        );
+    });
+    hrefRequests.forEach(block => {
+        wat = wat.replaceAll(
+            block.id, externgetter.get(block.$name)
+        );
+    });
     wat = APPEND_ON_EXTERN_READY(wat, oninit);
     return wat;
 }
@@ -1186,6 +1420,28 @@ function REF_EXTERN (wat, WAT4WASM) {
 
 const REF_FUNC_BLOCK_NAME = "ref.func";
 function REF_FUNC (wat, WAT4WASM) {
+    const inlineFunctions = new Array();
+    helpers
+        .parseBlockAt(wat.toString(), 0)
+        .children
+        .filter(b => b.startsWith("(func"))
+        .filter(b => b.substring(1).includes("(func"))
+        .map(b => b.substring(5, b.length - 1).trim())
+        .forEach(content => {
+            const maskSet = new helpers.MaskSet(content);
+            while (maskSet.hasBlock("func")) {
+                const inl = maskSet.lastBlockOf("func");
+                inlineFunctions.push(helpers.parseBlockAt(inl.toString(), 0));
+                maskSet.mask(inl);
+            }
+        })
+        ;
+    if (inlineFunctions.length) {
+        inlineFunctions.forEach(func => {
+            wat = wat.replace(func.toString(), `(ref.func ${func.$name})`)
+        });
+        wat = helpers.append(wat, inlineFunctions.map(func => `\n\t${func}\n`).join("\n"));
+    }
     const maskSetElem = new helpers.MaskSet(wat);
     const elemSegments = new Array();
     const needReference = new Set();