update workers env

Author: olehnikolaiev

node/EncryptMessage.mjs

@@ -1,18 +1,108 @@
 import ModuleFactory from './encrypt_web.js';
+import wasmAsset from './encrypt_web.wasm';
 
 let ModulePromise = null;
 
+function getRuntimeBaseUrl() {
+    if (typeof self !== 'undefined' && self.location && self.location.href) {
+        return self.location.href;
+    }
+    if (typeof document !== 'undefined' && document.baseURI) {
+        return document.baseURI;
+    }
+    return null;
+}
+
+function toAbsoluteAssetUrl(filename) {
+    if (typeof filename !== 'string' || filename.length === 0) {
+        throw new TypeError('filename must be a non-empty string');
+    }
+
+    const baseUrl = getRuntimeBaseUrl();
+    if (!baseUrl) {
+        return filename;
+    }
+
+    try {
+        return new URL(filename, baseUrl).href;
+    } catch {
+        return filename;
+    }
+}
+
+function getWasmModuleCandidate() {
+    if (typeof WebAssembly === 'undefined' || typeof WebAssembly.Module === 'undefined') {
+        return null;
+    }
+
+    if (wasmAsset instanceof WebAssembly.Module) {
+        return wasmAsset;
+    }
+
+    if (wasmAsset && wasmAsset.default instanceof WebAssembly.Module) {
+        return wasmAsset.default;
+    }
+
+    try {
+        if (wasmAsset instanceof Uint8Array || wasmAsset instanceof ArrayBuffer) {
+            return new WebAssembly.Module(wasmAsset);
+        }
+
+        if (wasmAsset && (wasmAsset.default instanceof Uint8Array || wasmAsset.default instanceof ArrayBuffer)) {
+            return new WebAssembly.Module(wasmAsset.default);
+        }
+    } catch {
+        // Fall through to URL-based loading below.
+    }
+
+    return null;
+}
+
+function getWasmUrlCandidate() {
+    if (typeof wasmAsset === 'string' && wasmAsset.length > 0) {
+        return wasmAsset;
+    }
+
+    if (wasmAsset && typeof wasmAsset.default === 'string' && wasmAsset.default.length > 0) {
+        return wasmAsset.default;
+    }
+
+    if (wasmAsset && typeof wasmAsset.href === 'string' && wasmAsset.href.length > 0) {
+        return wasmAsset.href;
+    }
+
+    return null;
+}
+
 function getModule() {
     if (!ModulePromise) {
-        const wasmUrl = new URL('encrypt_web.wasm', import.meta.url).href;
-        ModulePromise = ModuleFactory({
-            locateFile: (path) => {
-                if (path.endsWith('.wasm')) {
+        const moduleOptions = {};
+        const wasmModule = getWasmModuleCandidate();
+        const wasmUrl = getWasmUrlCandidate();
+
+        if (wasmModule) {
+            moduleOptions.instantiateWasm = (imports, receiveInstance) => {
+                const instance = new WebAssembly.Instance(wasmModule, imports);
+                receiveInstance(instance, wasmModule);
+                return instance.exports;
+            };
+        }
+
+        if (wasmUrl) {
+            moduleOptions.locateFile = (filename) => {
+                if (filename.endsWith('.wasm')) {
                     return wasmUrl;
                 }
-                return path;
-            }
-        });
+
+                return toAbsoluteAssetUrl(filename);
+            };
+        } else {
+            moduleOptions.locateFile = (filename) => {
+                return toAbsoluteAssetUrl(filename);
+            };
+        }
+
+        ModulePromise = ModuleFactory(moduleOptions);
     }
     return ModulePromise;
 }

node/EncryptMessageNode.mjs

@@ -2,17 +2,22 @@ import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
 const require = createRequire(import.meta.url);
 const ModuleFactory = require('./encrypt_node.js');
-
 let ModulePromise = null;
-
+function resolveModuleAssetPath(filename) {
+    if (typeof filename !== 'string' || filename.length === 0) {
+        throw new TypeError('filename must be a non-empty string');
+    }
+    const resolvedPath = fileURLToPath(new URL(filename, import.meta.url));
+    if (typeof resolvedPath !== 'string' || resolvedPath.length === 0) {
+        throw new Error('Failed to resolve module asset path');
+    }
+    return resolvedPath;
+}
 function getModule() {
     if (!ModulePromise) {
         ModulePromise = ModuleFactory({
             locateFile: (filename) => {
-                const resolvedUrl = new URL(filename, import.meta.url);
-                return resolvedUrl.protocol === 'file:'
-                    ? fileURLToPath(resolvedUrl)
-                    : resolvedUrl.href;
+                return resolveModuleAssetPath(filename);
             }
         });
     }