Fix package creation issue

.github/workflows/build-revive-wasm.yml

@@ -87,6 +87,7 @@ jobs:
           path: |
             ${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc.js
             ${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc.wasm
+            ${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc_packed.js
           retention-days: 1
 
   test-revive-wasm:

Makefile

@@ -30,6 +30,7 @@ install-npm:
 
 install-wasm: install-npm
 	cargo build --target wasm32-unknown-emscripten -p revive-solidity --release --no-default-features
+	npm run build:package
 
 install-llvm-builder:
 	cargo install --path crates/llvm-builder

js/build.js

@@ -0,0 +1,63 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const { minify } = require("terser");
+
+const RESOLC_WASM_TARGET_DIR = path.join(
+  __dirname,
+  "../target/wasm32-unknown-emscripten/release",
+);
+const RESOLC_WASM = path.join(RESOLC_WASM_TARGET_DIR, "resolc.wasm");
+const RESOLC_JS = path.join(RESOLC_WASM_TARGET_DIR, "resolc.js");
+const RESOLC_JS_PACKED = path.join(RESOLC_WASM_TARGET_DIR, "resolc_packed.js");
+
+const execShellCommand = (cmd) => {
+  return execSync(cmd, {
+    encoding: "utf-8",
+    maxBuffer: 1024 * 1024 * 100,
+  }).trim();
+};
+
+const wasmBase64 = execShellCommand(
+  `lz4c --no-frame-crc --best --favor-decSpeed "${RESOLC_WASM}" - | tail -c +8 | base64 -w 0`,
+);
+
+const wasmSize = fs.statSync(RESOLC_WASM).size;
+
+const miniLz4 = fs.readFileSync(
+  path.join(__dirname, "utils/mini-lz4.js"),
+  "utf-8",
+);
+const base64DecToArr = fs.readFileSync(
+  path.join(__dirname, "utils/base64DecToArr.js"),
+  "utf-8",
+);
+const resolcJs = fs.readFileSync(RESOLC_JS, "utf-8");
+
+const packedJsContent = `
+let moduleArgs = { wasmBinary: (function(source, uncompressedSize) {
+  ${miniLz4}
+  ${base64DecToArr}
+  return uncompress(base64DecToArr(source), uncompressedSize);
+})("${wasmBase64}", ${wasmSize}),
+};
+
+${resolcJs}
+
+createRevive = createRevive.bind(null, moduleArgs);
+`;
+
+minify(packedJsContent)
+  .then((minifiedJs) => {
+    if (minifiedJs.error) {
+      console.error("Error during minification:", minifiedJs.error);
+      process.exit(1);
+    }
+
+    fs.writeFileSync(RESOLC_JS_PACKED, minifiedJs.code, "utf-8");
+    console.log(`Combined script written to ${RESOLC_JS_PACKED}`);
+  })
+  .catch((err) => {
+    console.error("Minification failed:", err);
+    process.exit(1);
+  });

js/e2e/web.test.js

@@ -1,16 +1,16 @@
-const { test, expect } = require('@playwright/test');
-const fs = require('fs');
-const path = require('path');
+const { test, expect } = require("@playwright/test");
+const fs = require("fs");
+const path = require("path");
 
 function loadFixture(fixture) {
   const fixturePath = path.resolve(__dirname, `../fixtures/${fixture}`);
-  return  JSON.parse(fs.readFileSync(fixturePath, 'utf-8'));
+  return JSON.parse(fs.readFileSync(fixturePath, "utf-8"));
 }
 
 async function runWorker(page, input) {
   return await page.evaluate((input) => {
     return new Promise((resolve, reject) => {
-      const worker = new Worker('worker.js');
+      const worker = new Worker("worker.js");
       worker.postMessage(JSON.stringify(input));
 
       worker.onmessage = (event) => {
@@ -26,62 +26,80 @@ async function runWorker(page, input) {
   }, input);
 }
 
-test('should successfully compile valid Solidity code in browser', async ({ page }) => {
+test("should successfully compile valid Solidity code in browser", async ({
+  page,
+}) => {
   await page.goto("http://127.0.0.1:8080");
   await page.setContent("");
-  const standardInput = loadFixture('storage.json')
+  const standardInput = loadFixture("storage.json");
   const result = await runWorker(page, standardInput);
 
-  expect(typeof result).toBe('string');
+  expect(typeof result).toBe("string");
   let output = JSON.parse(result);
-  expect(output).toHaveProperty('contracts');
-  expect(output.contracts['fixtures/storage.sol']).toHaveProperty('Storage');
-  expect(output.contracts['fixtures/storage.sol'].Storage).toHaveProperty('abi');
-  expect(output.contracts['fixtures/storage.sol'].Storage).toHaveProperty('evm');
-  expect(output.contracts['fixtures/storage.sol'].Storage.evm).toHaveProperty('bytecode');
+  expect(output).toHaveProperty("contracts");
+  expect(output.contracts["fixtures/storage.sol"]).toHaveProperty("Storage");
+  expect(output.contracts["fixtures/storage.sol"].Storage).toHaveProperty(
+    "abi",
+  );
+  expect(output.contracts["fixtures/storage.sol"].Storage).toHaveProperty(
+    "evm",
+  );
+  expect(output.contracts["fixtures/storage.sol"].Storage.evm).toHaveProperty(
+    "bytecode",
+  );
 });
 
-test('should successfully compile large valid Solidity code in browser', async ({ page }) => {
+test("should successfully compile large valid Solidity code in browser", async ({
+  page,
+}) => {
   await page.goto("http://127.0.0.1:8080");
   await page.setContent("");
-  const standardInput = loadFixture('token.json')
+  const standardInput = loadFixture("token.json");
   const result = await runWorker(page, standardInput);
 
-  expect(typeof result).toBe('string');
+  expect(typeof result).toBe("string");
   let output = JSON.parse(result);
-  expect(output).toHaveProperty('contracts');
-  expect(output.contracts['fixtures/token.sol']).toHaveProperty('MyToken');
-  expect(output.contracts['fixtures/token.sol'].MyToken).toHaveProperty('abi');
-  expect(output.contracts['fixtures/token.sol'].MyToken).toHaveProperty('evm');
-  expect(output.contracts['fixtures/token.sol'].MyToken.evm).toHaveProperty('bytecode');
+  expect(output).toHaveProperty("contracts");
+  expect(output.contracts["fixtures/token.sol"]).toHaveProperty("MyToken");
+  expect(output.contracts["fixtures/token.sol"].MyToken).toHaveProperty("abi");
+  expect(output.contracts["fixtures/token.sol"].MyToken).toHaveProperty("evm");
+  expect(output.contracts["fixtures/token.sol"].MyToken.evm).toHaveProperty(
+    "bytecode",
+  );
 });
 
-test('should throw an error for invalid Solidity code in browser', async ({ page }) => {
+test("should throw an error for invalid Solidity code in browser", async ({
+  page,
+}) => {
   await page.goto("http://127.0.0.1:8080");
   await page.setContent("");
-  const standardInput = loadFixture('invalid_contract_content.json')
+  const standardInput = loadFixture("invalid_contract_content.json");
   const result = await runWorker(page, standardInput);
 
-  expect(typeof result).toBe('string');
+  expect(typeof result).toBe("string");
   let output = JSON.parse(result);
-  expect(output).toHaveProperty('errors');
+  expect(output).toHaveProperty("errors");
   expect(Array.isArray(output.errors)).toBeTruthy(); // Check if it's an array
   expect(output.errors.length).toBeGreaterThan(0);
-  expect(output.errors[0]).toHaveProperty('type');
-  expect(output.errors[0].type).toContain('ParserError');
+  expect(output.errors[0]).toHaveProperty("type");
+  expect(output.errors[0].type).toContain("ParserError");
 });
 
-test('should return not found error for missing imports in browser', async ({page}) => {
+test("should return not found error for missing imports in browser", async ({
+  page,
+}) => {
   await page.goto("http://127.0.0.1:8080");
   await page.setContent("");
-  const standardInput = loadFixture('missing_import.json')
+  const standardInput = loadFixture("missing_import.json");
   const result = await runWorker(page, standardInput);
 
-  expect(typeof result).toBe('string');
+  expect(typeof result).toBe("string");
   let output = JSON.parse(result);
-  expect(output).toHaveProperty('errors');
+  expect(output).toHaveProperty("errors");
   expect(Array.isArray(output.errors)).toBeTruthy(); // Check if it's an array
   expect(output.errors.length).toBeGreaterThan(0);
-  expect(output.errors[0]).toHaveProperty('message');
-  expect(output.errors[0].message).toContain('Source "nonexistent/console.sol" not found');
+  expect(output.errors[0]).toHaveProperty("message");
+  expect(output.errors[0].message).toContain(
+    'Source "nonexistent/console.sol" not found',
+  );
 });

js/embed/pre.js

@@ -1,54 +1,57 @@
-var Module = {
-    stdinData: null,
-    stdinDataPosition: 0,
-    stdoutData: [],
-    stderrData: [],
+Module.stdinData = null;
+Module.stdinDataPosition = 0;
+Module.stdoutData = [];
+Module.stderrData = [];
 
-    // Function to read and return all collected stdout data as a string
-    readFromStdout: function() {
-        if (!this.stdoutData.length) return "";
-        const decoder = new TextDecoder('utf-8');
-        const data = decoder.decode(new Uint8Array(this.stdoutData));
-        this.stdoutData = [];
-        return data;
-    },
-
-    // Function to read and return all collected stderr data as a string
-    readFromStderr: function() {
-        if (!this.stderrData.length) return "";
-        const decoder = new TextDecoder('utf-8');
-        const data = decoder.decode(new Uint8Array(this.stderrData));
-        this.stderrData = [];
-        return data;
-    },
-
-    // Function to set input data for stdin
-    writeToStdin: function(data) {
-        const encoder = new TextEncoder();
-        this.stdinData = encoder.encode(data);
-        this.stdinDataPosition = 0;
-    },
-
-    // `preRun` is called before the program starts running
-    preRun: function() {
-        // Define a custom stdin function
-        function customStdin() {
-            if (!Module.stdinData || Module.stdinDataPosition >= Module.stdinData.length) {
-                return null; // End of input (EOF)
-            }
-            return Module.stdinData[Module.stdinDataPosition++];
-        }
-
-        // Define a custom stdout function
-        function customStdout(char) {
-            Module.stdoutData.push(char);
-        }
-
-        // Define a custom stderr function
-        function customStderr(char) {
-            Module.stderrData.push(char);
-        }
-
-        FS.init(customStdin, customStdout, customStderr);
-    },
+// Method to read all collected stdout data
+Module.readFromStdout = function () {
+  if (!Module.stdoutData.length) return "";
+  const decoder = new TextDecoder("utf-8");
+  const data = decoder.decode(new Uint8Array(Module.stdoutData));
+  Module.stdoutData = [];
+  return data;
 };
+
+// Method to read all collected stderr data
+Module.readFromStderr = function () {
+  if (!Module.stderrData.length) return "";
+  const decoder = new TextDecoder("utf-8");
+  const data = decoder.decode(new Uint8Array(Module.stderrData));
+  Module.stderrData = [];
+  return data;
+};
+
+// Method to write data to stdin
+Module.writeToStdin = function (data) {
+  const encoder = new TextEncoder();
+  Module.stdinData = encoder.encode(data);
+  Module.stdinDataPosition = 0;
+};
+
+// Override the `preRun` method to customize file system initialization
+Module.preRun = Module.preRun || [];
+Module.preRun.push(function () {
+  // Custom stdin function
+  function customStdin() {
+    if (
+      !Module.stdinData ||
+      Module.stdinDataPosition >= Module.stdinData.length
+    ) {
+      return null; // End of input (EOF)
+    }
+    return Module.stdinData[Module.stdinDataPosition++];
+  }
+
+  // Custom stdout function
+  function customStdout(char) {
+    Module.stdoutData.push(char);
+  }
+
+  // Custom stderr function
+  function customStderr(char) {
+    Module.stderrData.push(char);
+  }
+
+  // Initialize the FS (File System) with custom handlers
+  FS.init(customStdin, customStdout, customStderr);
+});

js/embed/soljson_interface.js

@@ -1,29 +1,34 @@
 mergeInto(LibraryManager.library, {
-    soljson_compile: function(inputPtr, inputLen) {
-        const inputJson = UTF8ToString(inputPtr, inputLen);
-        const output = Module.soljson.cwrap('solidity_compile', 'string', ['string'])(inputJson);
-        return stringToNewUTF8(output);
-    },
-    soljson_version: function() {
-        const version = Module.soljson.cwrap("solidity_version", "string", [])();
-        return stringToNewUTF8(version);
-    },
-    resolc_compile: function(inputPtr, inputLen) {
-        const inputJson = UTF8ToString(inputPtr, inputLen);
-        var revive = createRevive();
-        revive.writeToStdin(inputJson);
+  soljson_compile: function (inputPtr, inputLen) {
+    const inputJson = UTF8ToString(inputPtr, inputLen);
+    const output = Module.soljson.cwrap("solidity_compile", "string", [
+      "string",
+    ])(inputJson);
+    return stringToNewUTF8(output);
+  },
+  soljson_version: function () {
+    const version = Module.soljson.cwrap("solidity_version", "string", [])();
+    return stringToNewUTF8(version);
+  },
+  resolc_compile: function (inputPtr, inputLen) {
+    const inputJson = UTF8ToString(inputPtr, inputLen);
+    var revive = createRevive();
+    revive.writeToStdin(inputJson);
 
-        // Call main on the new instance
-        const result = revive.callMain(['--recursive-process']);
+    // Call main on the new instance
+    const result = revive.callMain(["--recursive-process"]);
 
-        if (result) {
-            const stderrString = revive.readFromStderr();
-            const error = JSON.stringify({ type: 'error', message: stderrString || "Unknown error" });
-            return stringToNewUTF8(error);
-        } else {
-            const stdoutString = revive.readFromStdout();
-            const json = JSON.stringify({ type: 'success', data: stdoutString });
-            return stringToNewUTF8(json);
-        }
-    },
+    if (result) {
+      const stderrString = revive.readFromStderr();
+      const error = JSON.stringify({
+        type: "error",
+        message: stderrString || "Unknown error",
+      });
+      return stringToNewUTF8(error);
+    } else {
+      const stdoutString = revive.readFromStdout();
+      const json = JSON.stringify({ type: "success", data: stdoutString });
+      return stringToNewUTF8(json);
+    }
+  },
 });

js/examples/node/revive.js

@@ -1,9 +1,9 @@
-const soljson = require('solc/soljson');
-const createRevive = require('./resolc.js');
+const soljson = require("solc/soljson");
+const createRevive = require("./resolc.js");
 
 async function compile(standardJsonInput) {
   if (!standardJsonInput) {
-    throw new Error('Input JSON for the Solidity compiler is required.');
+    throw new Error("Input JSON for the Solidity compiler is required.");
   }
 
   // Initialize the compiler
@@ -14,7 +14,7 @@ async function compile(standardJsonInput) {
   compiler.writeToStdin(JSON.stringify(standardJsonInput));
 
   // Run the compiler
-  compiler.callMain(['--standard-json']);
+  compiler.callMain(["--standard-json"]);
 
   // Collect output
   const stdout = compiler.readFromStdout();

js/examples/node/run_revive.js

@@ -1,10 +1,10 @@
-const { compile } = require('./revive.js');
+const { compile } = require("./revive.js");
 
 const compilerStandardJsonInput = {
-    language: 'Solidity',
-    sources: {
-      'MyContract.sol': {
-        content: `
+  language: "Solidity",
+  sources: {
+    "MyContract.sol": {
+      content: `
           // SPDX-License-Identifier: UNLICENSED
           pragma solidity ^0.8.0;
           contract MyContract {
@@ -13,26 +13,26 @@ const compilerStandardJsonInput = {
             }
           }
         `,
+    },
+  },
+  settings: {
+    optimizer: {
+      enabled: true,
+      runs: 200,
+    },
+    outputSelection: {
+      "*": {
+        "*": ["abi"],
       },
     },
-    settings: {
-      optimizer: {
-        enabled: true,
-        runs: 200,
-      },
-      outputSelection: {
-        '*': {
-          '*': ['abi'],
-        },
-      },
-    },
-  };
+  },
+};
 
 async function runCompiler() {
-  let output = await compile(compilerStandardJsonInput)
+  let output = await compile(compilerStandardJsonInput);
   console.log("Output: " + output);
 }
 
-runCompiler().catch(err => {
-  console.error('Error:', err);
+runCompiler().catch((err) => {
+  console.error("Error:", err);
 });

js/examples/web/index.html

@@ -1,51 +1,53 @@
-<!DOCTYPE html>
+<!doctype html>
 <html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Web Worker Example</title>
+    <style>
+      /* Ensure the pre tag wraps long lines */
+      pre {
+        white-space: pre-wrap; /* Wrap long lines */
+        word-wrap: break-word; /* Break long words */
+        max-width: 100%; /* Optional: Ensures it doesn't overflow container */
+        overflow-wrap: break-word; /* Another method for wrapping */
+      }
+    </style>
+  </head>
 
-    <head>
-        <meta charset="utf-8" />
-        <title>Web Worker Example</title>
-        <style>
-            /* Ensure the pre tag wraps long lines */
-            pre {
-                white-space: pre-wrap;     /* Wrap long lines */
-                word-wrap: break-word;     /* Break long words */
-                max-width: 100%;           /* Optional: Ensures it doesn't overflow container */
-                overflow-wrap: break-word; /* Another method for wrapping */
-            }
-        </style>
-    </head>
-
-    <body>
-        <h1>Revive Compilation Output</h1>
-        <pre id="output"></pre>
-        <script>
-            var outputElement = document.getElementById('output');
-            var worker = new Worker('./worker.js');
-            const standardJsonInput = {
-                language: 'Solidity',
-                sources: {
-                    contract: {
-                        content: 'contract MyContract { function f() public { } }',
-                    }
-                },
-                settings: {
-                    optimizer: {
-                        enabled: true,
-                        runs: 200,
-                    },
-                    outputSelection: {
-                        '*': {
-                            '*': ['abi'],
-                        }
-                    }
-                }
-            };
-            worker.addEventListener('message', function (e) {
-                outputElement.textContent = e.data.output;
-            }, false);
-
-            worker.postMessage(JSON.stringify(standardJsonInput));
-        </script>
-    </body>
+  <body>
+    <h1>Revive Compilation Output</h1>
+    <pre id="output"></pre>
+    <script>
+      var outputElement = document.getElementById("output");
+      var worker = new Worker("./worker.js");
+      const standardJsonInput = {
+        language: "Solidity",
+        sources: {
+          contract: {
+            content: "contract MyContract { function f() public { } }",
+          },
+        },
+        settings: {
+          optimizer: {
+            enabled: true,
+            runs: 200,
+          },
+          outputSelection: {
+            "*": {
+              "*": ["abi"],
+            },
+          },
+        },
+      };
+      worker.addEventListener(
+        "message",
+        function (e) {
+          outputElement.textContent = e.data.output;
+        },
+        false,
+      );
 
+      worker.postMessage(JSON.stringify(standardJsonInput));
+    </script>
+  </body>
 </html>

js/examples/web/worker.js

@@ -1,18 +1,16 @@
-
-importScripts('./soljson.js');
-importScripts('./resolc.js');
+importScripts("./soljson.js");
+importScripts("./resolc.js");
 
 // Handle messages from the main thread
 onmessage = async function (e) {
-    const m = createRevive();
+  const m = createRevive();
+  m.soljson = Module;
 
-    m.soljson = Module;
+  // Set input data for stdin
+  m.writeToStdin(e.data);
 
-    // Set input data for stdin
-    m.writeToStdin(e.data);
+  // Compile the Solidity source code
+  m.callMain(["--standard-json"]);
 
-    // Compile the Solidity source code
-    m.callMain(['--standard-json']);
-
-  postMessage({output: m.readFromStdout() || m.readFromStderr()});
+  postMessage({ output: m.readFromStdout() || m.readFromStderr() });
 };

js/fixtures/invalid_contract_content.json

@@ -1,22 +1,19 @@
 {
-    "language": "Solidity",
-    "sources": {
-      "fixtures/storage.sol": {
-        "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.0;\nimport \"nonexistent/console.sol\";\ncontract MyContract {  function greet() public pure returns (string memory) { return \"Hello\" // Missing semicolon }}"
-      }
+  "language": "Solidity",
+  "sources": {
+    "fixtures/storage.sol": {
+      "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.0;\nimport \"nonexistent/console.sol\";\ncontract MyContract {  function greet() public pure returns (string memory) { return \"Hello\" // Missing semicolon }}"
+    }
+  },
+  "settings": {
+    "optimizer": {
+      "enabled": true,
+      "runs": 200
     },
-    "settings": {
-      "optimizer": {
-        "enabled": true,
-        "runs": 200
-      },
-      "outputSelection": {
-        "*": {
-          "*": [
-            "abi"
-          ]
-        }
+    "outputSelection": {
+      "*": {
+        "*": ["abi"]
       }
     }
   }
-  
+}

js/fixtures/missing_import.json

@@ -1,22 +1,19 @@
 {
-    "language": "Solidity",
-    "sources": {
-      "fixtures/storage.sol": {
-        "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.0;\nimport \"nonexistent/console.sol\";\ncontract MyContract { function f() public { } }"
-      }
+  "language": "Solidity",
+  "sources": {
+    "fixtures/storage.sol": {
+      "content": "// SPDX-License-Identifier: UNLICENSED\npragma solidity ^0.8.0;\nimport \"nonexistent/console.sol\";\ncontract MyContract { function f() public { } }"
+    }
+  },
+  "settings": {
+    "optimizer": {
+      "enabled": true,
+      "runs": 200
     },
-    "settings": {
-      "optimizer": {
-        "enabled": true,
-        "runs": 200
-      },
-      "outputSelection": {
-        "*": {
-          "*": [
-            "abi"
-          ]
-        }
+    "outputSelection": {
+      "*": {
+        "*": ["abi"]
       }
     }
   }
-  
+}

js/fixtures/storage.json

@@ -1,22 +1,19 @@
 {
-    "language": "Solidity",
-    "sources": {
-      "fixtures/storage.sol": {
-        "content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.8.2 <0.9.0;\ncontract Storage {\n uint256 number;\n function store(uint256 num) public { number = num; }\n function retrieve() public view returns (uint256){ return number; }\n}"
-      }
+  "language": "Solidity",
+  "sources": {
+    "fixtures/storage.sol": {
+      "content": "// SPDX-License-Identifier: GPL-3.0\npragma solidity >=0.8.2 <0.9.0;\ncontract Storage {\n uint256 number;\n function store(uint256 num) public { number = num; }\n function retrieve() public view returns (uint256){ return number; }\n}"
+    }
+  },
+  "settings": {
+    "optimizer": {
+      "enabled": true,
+      "runs": 200
     },
-    "settings": {
-      "optimizer": {
-        "enabled": true,
-        "runs": 200
-      },
-      "outputSelection": {
-        "*": {
-          "*": [
-            "abi"
-          ]
-        }
+    "outputSelection": {
+      "*": {
+        "*": ["abi"]
       }
     }
   }
-  
+}

js/package.json

@@ -10,12 +10,16 @@
     "example:node": "node ./examples/node/run_revive.js",
     "test:node": "mocha --timeout 60000 ./tests",
     "test:bun": "bun test --timeout 60000 node.test",
-    "test:all": "npm run test:node && npm run test:bun"
+    "test:all": "npm run test:node && npm run test:bun",
+    "format": "prettier --write .",
+    "build:package": "node ./build.js"
   },
   "devDependencies": {
     "@playwright/test": "^1.49.1",
     "chai": "^5.1.2",
     "http-server": "^14.1.1",
-    "mocha": "^11.0.1"
+    "mocha": "^11.0.1",
+    "prettier": "^3.4.2",
+    "terser": "^5.37.0"
   }
 }

js/playwright.config.js

@@ -1,10 +1,10 @@
-const { defineConfig, devices } = require('@playwright/test');
+const { defineConfig, devices } = require("@playwright/test");
 
 /**
  * @see https://playwright.dev/docs/test-configuration
  */
 module.exports = defineConfig({
-  testDir: './e2e',
+  testDir: "./e2e",
   /* Run tests in files in parallel */
   fullyParallel: true,
   /* Fail the build on CI if you accidentally left test.only in the source code. */
@@ -14,39 +14,38 @@ module.exports = defineConfig({
   /* Opt out of parallel tests on CI. */
   workers: process.env.CI ? 1 : undefined,
   /* Reporter to use. See https://playwright.dev/docs/test-reporters */
-  reporter: 'list',
+  reporter: "list",
   /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
   use: {
     /* Base URL to use in actions like `await page.goto('/')`. */
-    baseURL: 'http://127.0.0.1:8080',
+    baseURL: "http://127.0.0.1:8080",
 
     /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
-    trace: 'on-first-retry',
+    trace: "on-first-retry",
   },
   timeout: 480000,
   /* Configure projects for major browsers */
   projects: [
     {
-      name: 'chromium',
-      use: { ...devices['Desktop Chrome'] },
+      name: "chromium",
+      use: { ...devices["Desktop Chrome"] },
     },
 
     {
-      name: 'firefox',
-      use: { ...devices['Desktop Firefox'] },
+      name: "firefox",
+      use: { ...devices["Desktop Firefox"] },
     },
 
     {
-      name: 'webkit',
-      use: { ...devices['Desktop Safari'] },
-    }
+      name: "webkit",
+      use: { ...devices["Desktop Safari"] },
+    },
   ],
 
   /* Run your local dev server before starting the tests */
   webServer: {
-    command: 'npm run example:web',
-    url: 'http://127.0.0.1:8080',
+    command: "npm run example:web",
+    url: "http://127.0.0.1:8080",
     reuseExistingServer: !process.env.CI,
   },
 });
-

js/tests/node.test.mjs

@@ -1,70 +1,88 @@
-import { expect } from 'chai';
-import { compile } from '../examples/node/revive.js';
-import { fileURLToPath } from 'url';
-import path from 'path';
-import fs from 'fs';
+import { expect } from "chai";
+import { compile } from "../examples/node/revive.js";
+import { fileURLToPath } from "url";
+import path from "path";
+import fs from "fs";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 function loadFixture(fixture) {
   const fixturePath = path.resolve(__dirname, `../fixtures/${fixture}`);
-  return  JSON.parse(fs.readFileSync(fixturePath, 'utf-8'));
+  return JSON.parse(fs.readFileSync(fixturePath, "utf-8"));
 }
 
-describe('Compile Function Tests', function () {
-  it('should successfully compile valid Solidity code', async function () {
-    const standardInput = loadFixture('storage.json')
+describe("Compile Function Tests", function () {
+  it("should successfully compile valid Solidity code", async function () {
+    const standardInput = loadFixture("storage.json");
 
     const result = await compile(standardInput);
-    expect(result).to.be.a('string');
+    expect(result).to.be.a("string");
     const output = JSON.parse(result);
-    expect(output).to.have.property('contracts');
-    expect(output.contracts['fixtures/storage.sol']).to.have.property('Storage');
-    expect(output.contracts['fixtures/storage.sol'].Storage).to.have.property('abi');
-    expect(output.contracts['fixtures/storage.sol'].Storage).to.have.property('evm');
-    expect(output.contracts['fixtures/storage.sol'].Storage.evm).to.have.property('bytecode');
+    expect(output).to.have.property("contracts");
+    expect(output.contracts["fixtures/storage.sol"]).to.have.property(
+      "Storage",
+    );
+    expect(output.contracts["fixtures/storage.sol"].Storage).to.have.property(
+      "abi",
+    );
+    expect(output.contracts["fixtures/storage.sol"].Storage).to.have.property(
+      "evm",
+    );
+    expect(
+      output.contracts["fixtures/storage.sol"].Storage.evm,
+    ).to.have.property("bytecode");
   });
 
-  if (typeof globalThis.Bun == 'undefined') {
+  if (typeof globalThis.Bun == "undefined") {
     // Running this test with Bun on a Linux host causes:
     // RuntimeError: Out of bounds memory access (evaluating 'getWasmTableEntry(index)(a1, a2, a3, a4, a5)')
     // Once this issue is resolved, the test will be re-enabled.
-    it('should successfully compile large Solidity code', async function () {
-      const standardInput = loadFixture('token.json')
+    it("should successfully compile large Solidity code", async function () {
+      const standardInput = loadFixture("token.json");
 
       const result = await compile(standardInput);
-      expect(result).to.be.a('string');
+      expect(result).to.be.a("string");
       const output = JSON.parse(result);
-      expect(output).to.have.property('contracts');
-      expect(output.contracts['fixtures/token.sol']).to.have.property('MyToken');
-      expect(output.contracts['fixtures/token.sol'].MyToken).to.have.property('abi');
-      expect(output.contracts['fixtures/token.sol'].MyToken).to.have.property('evm');
-      expect(output.contracts['fixtures/token.sol'].MyToken.evm).to.have.property('bytecode');
+      expect(output).to.have.property("contracts");
+      expect(output.contracts["fixtures/token.sol"]).to.have.property(
+        "MyToken",
+      );
+      expect(output.contracts["fixtures/token.sol"].MyToken).to.have.property(
+        "abi",
+      );
+      expect(output.contracts["fixtures/token.sol"].MyToken).to.have.property(
+        "evm",
+      );
+      expect(
+        output.contracts["fixtures/token.sol"].MyToken.evm,
+      ).to.have.property("bytecode");
     });
   }
 
-  it('should throw an error for invalid Solidity code', async function () {
-    const standardInput = loadFixture('invalid_contract_content.json')
+  it("should throw an error for invalid Solidity code", async function () {
+    const standardInput = loadFixture("invalid_contract_content.json");
 
     const result = await compile(standardInput);
-    expect(result).to.be.a('string');
+    expect(result).to.be.a("string");
     const output = JSON.parse(result);
-    expect(output).to.have.property('errors');
-    expect(output.errors).to.be.an('array');
+    expect(output).to.have.property("errors");
+    expect(output.errors).to.be.an("array");
     expect(output.errors.length).to.be.greaterThan(0);
     expect(output.errors[0].type).to.exist;
     expect(output.errors[0].type).to.contain("ParserError");
   });
 
-  it('should return not found error for missing imports', async function () {
-    const standardInput = loadFixture('missing_import.json')
+  it("should return not found error for missing imports", async function () {
+    const standardInput = loadFixture("missing_import.json");
 
     const result = await compile(standardInput);
     const output = JSON.parse(result);
-    expect(output).to.have.property('errors');
-    expect(output.errors).to.be.an('array');
+    expect(output).to.have.property("errors");
+    expect(output.errors).to.be.an("array");
     expect(output.errors.length).to.be.greaterThan(0);
     expect(output.errors[0].message).to.exist;
-    expect(output.errors[0].message).to.include('Source "nonexistent/console.sol" not found');
+    expect(output.errors[0].message).to.include(
+      'Source "nonexistent/console.sol" not found',
+    );
   });
 });

js/utils/base64DecToArr.js

@@ -0,0 +1,46 @@
+function base64DecToArr (sBase64) {
+/*\
+|*|
+|*|  Base64 / binary data / UTF-8 strings utilities
+|*|
+|*|  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Base64_encoding_and_decoding
+|*|
+\*/
+
+/* Array of bytes to Base64 string decoding */
+
+function b64ToUint6 (nChr) {
+
+  return nChr > 64 && nChr < 91 ?
+      nChr - 65
+    : nChr > 96 && nChr < 123 ?
+      nChr - 71
+    : nChr > 47 && nChr < 58 ?
+      nChr + 4
+    : nChr === 43 ?
+      62
+    : nChr === 47 ?
+      63
+    :
+      0;
+
+}
+
+  var
+    nInLen = sBase64.length,
+    nOutLen = nInLen * 3 + 1 >> 2, taBytes = new Uint8Array(nOutLen);
+
+  for (var nMod3, nMod4, nUint24 = 0, nOutIdx = 0, nInIdx = 0; nInIdx < nInLen; nInIdx++) {
+    nMod4 = nInIdx & 3;
+    nUint24 |= b64ToUint6(sBase64.charCodeAt(nInIdx)) << 6 * (3 - nMod4);
+    if (nMod4 === 3 || nInLen - nInIdx === 1) {
+      for (nMod3 = 0; nMod3 < 3 && nOutIdx < nOutLen; nMod3++, nOutIdx++) {
+        taBytes[nOutIdx] = nUint24 >>> (16 >>> nMod3 & 24) & 255;
+      }
+      nUint24 = 0;
+
+    }
+  }
+
+  return taBytes;
+}

js/utils/mini-lz4.js

@@ -0,0 +1,118 @@
+function uncompress(source, uncompressedSize) {
+/*
+Source https://github.com/ethereum/solidity/blob/develop/scripts/ci/mini-lz4.js
+====
+based off https://github.com/emscripten-core/emscripten/blob/main/third_party/mini-lz4.js
+The license only applies to the body of this function (``uncompress``).
+====
+MiniLZ4: Minimal LZ4 block decoding and encoding.
+
+based off of node-lz4, https://github.com/pierrec/node-lz4
+
+====
+Copyright (c) 2012 Pierre Curto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+====
+
+changes have the same license
+*/
+/**
+ * Decode a block. Assumptions: input contains all sequences of a
+ * chunk, output is large enough to receive the decoded data.
+ * If the output buffer is too small, an error will be thrown.
+ * If the returned value is negative, an error occurred at the returned offset.
+ *
+ * @param {ArrayBufferView} input input data
+ * @param {ArrayBufferView} output output data
+ * @param {number=} sIdx
+ * @param {number=} eIdx
+ * @return {number} number of decoded bytes
+ * @private
+ */
+function uncompressBlock (input, output, sIdx, eIdx) {
+	sIdx = sIdx || 0
+	eIdx = eIdx || (input.length - sIdx)
+	// Process each sequence in the incoming data
+	for (var i = sIdx, n = eIdx, j = 0; i < n;) {
+		var token = input[i++]
+
+		// Literals
+		var literals_length = (token >> 4)
+		if (literals_length > 0) {
+			// length of literals
+			var l = literals_length + 240
+			while (l === 255) {
+				l = input[i++]
+				literals_length += l
+			}
+
+			// Copy the literals
+			var end = i + literals_length
+			while (i < end) output[j++] = input[i++]
+
+			// End of buffer?
+			if (i === n) return j
+		}
+
+		// Match copy
+		// 2 bytes offset (little endian)
+		var offset = input[i++] | (input[i++] << 8)
+
+		// XXX 0 is an invalid offset value
+		if (offset === 0) return j
+		if (offset > j) return -(i-2)
+
+		// length of match copy
+		var match_length = (token & 0xf)
+		var l = match_length + 240
+		while (l === 255) {
+			l = input[i++]
+			match_length += l
+		}
+		// Copy the match
+		var pos = j - offset // position of the match copy in the current output
+		var end = j + match_length + 4 // minmatch = 4
+		while (j < end) output[j++] = output[pos++]
+	}
+
+	return j
+}
+var result = new ArrayBuffer(uncompressedSize);
+var sourceIndex = 0;
+var destIndex = 0;
+var blockSize;
+while((blockSize = (source[sourceIndex] | (source[sourceIndex + 1] << 8) | (source[sourceIndex + 2] << 16) | (source[sourceIndex + 3] << 24))) > 0)
+{
+	sourceIndex += 4;
+	if (blockSize & 0x80000000)
+	{
+		blockSize &= 0x7FFFFFFFF;
+		for (var i = 0; i < blockSize; i++) {
+			result[destIndex++] = source[sourceIndex++];
+		}
+	}
+	else
+	{
+		destIndex += uncompressBlock(source, new Uint8Array(result, destIndex, uncompressedSize - destIndex), sourceIndex, sourceIndex + blockSize);
+		sourceIndex += blockSize;
+	}
+}
+return new Uint8Array(result, 0, uncompressedSize);
+}

package.json

@@ -3,7 +3,8 @@
     "private": true,
     "scripts": {
         "test:cli": "npm run test -w crates/solidity/src/tests/cli-tests",
-        "test:wasm": "npm run test:all -w js"
+        "test:wasm": "npm run test:all -w js",
+        "build:package": "npm run build:package -w js"
     },
     "workspaces": [
         "crates/solidity/src/tests/cli-tests",