pikelet-wasm 0.7.0

package/pancake-errors.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const PANCAKE_ERROR_CODES = Object.freeze({
+    INVALID_ARGUMENT: 'INVALID_ARGUMENT',
+    DIMENSION_MISMATCH: 'DIMENSION_MISMATCH',
+    INVALID_VECTOR: 'INVALID_VECTOR',
+    INDEX_FULL: 'INDEX_FULL',
+    INDEX_DISPOSED: 'INDEX_DISPOSED',
+    COMPACTION_REQUIRED: 'COMPACTION_REQUIRED',
+    SNAPSHOT_INVALID: 'SNAPSHOT_INVALID',
+    SNAPSHOT_CONFIG_MISMATCH: 'SNAPSHOT_CONFIG_MISMATCH',
+    SNAPSHOT_CAPACITY_EXCEEDED: 'SNAPSHOT_CAPACITY_EXCEEDED',
+    WASM_LOAD_FAILED: 'WASM_LOAD_FAILED',
+    WASM_ALLOCATION_FAILED: 'WASM_ALLOCATION_FAILED',
+    FILE_IO_FAILED: 'FILE_IO_FAILED',
+    PARSE_FAILED: 'PARSE_FAILED',
+    INTERNAL_INVARIANT: 'INTERNAL_INVARIANT',
+    // Reserved for the deferred shared-runtime API.
+    INDEX_LIMIT: 'INDEX_LIMIT',
+});
+
+class PancakeError extends Error {
+    constructor(code, message, details, cause) {
+        super(message);
+        this.name = 'PancakeError';
+        this.code = code;
+        if (details !== undefined) this.details = details;
+        if (cause !== undefined) this.cause = cause;
+    }
+}
+
+function pancakeError(code, message, details, cause) {
+    return new PancakeError(code, message, details, cause);
+}
+
+module.exports = {
+    PancakeError,
+    PANCAKE_ERROR_CODES,
+    pancakeError,
+};

package/pancake-loader.js

@@ -0,0 +1,66 @@
+'use strict';
+
+function toCompileSource(source) {
+    if (source instanceof WebAssembly.Module) return source;
+    if (source instanceof ArrayBuffer) return source;
+    if (typeof SharedArrayBuffer !== 'undefined' && source instanceof SharedArrayBuffer) {
+        return source;
+    }
+    if (ArrayBuffer.isView(source)) {
+        return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+    }
+    throw new TypeError(`Unsupported WASM source type: ${typeof source}`);
+}
+
+function createCachedModuleLoader(loadSource) {
+    const sourcePromises = new Map();
+    const modulePromises = new Map();
+
+    function getSource(variant) {
+        let promise = sourcePromises.get(variant);
+        if (!promise) {
+            promise = Promise.resolve().then(() => loadSource(variant));
+            sourcePromises.set(variant, promise);
+        }
+        return promise;
+    }
+
+    function getModule(variant) {
+        let promise = modulePromises.get(variant);
+        if (!promise) {
+            promise = getSource(variant).then((source) => {
+                const compileSource = toCompileSource(source);
+                return compileSource instanceof WebAssembly.Module
+                    ? compileSource
+                    : WebAssembly.compile(compileSource);
+            });
+            modulePromises.set(variant, promise);
+        }
+        return promise;
+    }
+
+    async function supports(variant) {
+        const source = toCompileSource(await getSource(variant));
+        if (source instanceof WebAssembly.Module) return true;
+        try {
+            return WebAssembly.validate(source);
+        } catch {
+            return false;
+        }
+    }
+
+    async function instantiate(factory, variant) {
+        const compiled = await getModule(variant);
+        return factory({
+            instantiateWasm(imports, successCallback) {
+                const instance = new WebAssembly.Instance(compiled, imports);
+                successCallback(instance, compiled);
+                return instance.exports;
+            },
+        });
+    }
+
+    return Object.freeze({ getModule, instantiate, supports });
+}
+
+module.exports = { createCachedModuleLoader };