@napi-rs/wasm-runtime
Advanced tools
@napi-rs/wasm-runtime - npm Package Compare versions
+216
-300
@@ -1,321 +0,237 @@ | ||
| 'use strict'; | ||
| // @ts-check | ||
| Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); | ||
| //#region fs-proxy.js | ||
| /** | ||
| * @param {unknown} value | ||
| */ | ||
| * @param {unknown} value | ||
| */ | ||
| const getType = (value) => { | ||
| if (value === undefined) return 0 | ||
| if (value === null) return 1 | ||
| if (isBuffer(value)) return 10 | ||
| const t = typeof value; | ||
| if (t === 'boolean') return 2 | ||
| if (t === 'number') return 3 | ||
| if (t === 'string') return 4 | ||
| if (t === 'object') return 6 | ||
| if (t === 'bigint') return 9 | ||
| return -1 | ||
| if (value === void 0) return 0; | ||
| if (value === null) return 1; | ||
| if (isBuffer(value)) return 10; | ||
| const t = typeof value; | ||
| if (t === "boolean") return 2; | ||
| if (t === "number") return 3; | ||
| if (t === "string") return 4; | ||
| if (t === "object") return 6; | ||
| if (t === "bigint") return 9; | ||
| return -1; | ||
| }; | ||
| /** | ||
| * @param {unknown} value | ||
| * @returns {value is Uint8Array} | ||
| */ | ||
| * @param {unknown} value | ||
| * @returns {value is Uint8Array} | ||
| */ | ||
| const isBuffer = (value) => { | ||
| const BufferCtor = globalThis.Buffer; | ||
| if (typeof BufferCtor?.isBuffer === 'function') { | ||
| return BufferCtor.isBuffer(value) | ||
| } | ||
| return value instanceof Uint8Array && value.constructor?.name === 'Buffer' | ||
| const BufferCtor = globalThis.Buffer; | ||
| if (typeof BufferCtor?.isBuffer === "function") return BufferCtor.isBuffer(value); | ||
| return value instanceof Uint8Array && value.constructor?.name === "Buffer"; | ||
| }; | ||
| const RESPONSE_HEADER_SIZE = 16; | ||
| const RESPONSE_PAYLOAD_SIZE = 10240; | ||
| const RESPONSE_BUFFER_SIZE = RESPONSE_HEADER_SIZE + RESPONSE_PAYLOAD_SIZE; | ||
| const RESPONSE_BUFFER_SIZE = 10256; | ||
| /** | ||
| * @param {Int32Array} sab | ||
| * @param {Uint8Array} payload | ||
| */ | ||
| * @param {Int32Array} sab | ||
| * @param {Uint8Array} payload | ||
| */ | ||
| const writeResponsePayload = (sab, payload) => { | ||
| if (payload.length > RESPONSE_PAYLOAD_SIZE) { | ||
| throw new RangeError('payload overflow') | ||
| } | ||
| new Uint8Array(sab.buffer).set(payload, RESPONSE_HEADER_SIZE); | ||
| if (payload.length > RESPONSE_PAYLOAD_SIZE) throw new RangeError("payload overflow"); | ||
| new Uint8Array(sab.buffer).set(payload, RESPONSE_HEADER_SIZE); | ||
| }; | ||
| /** | ||
| * @param {import('memfs').IFs} memfs | ||
| * @param {any} value | ||
| * @param {ReturnType<typeof getType>} type | ||
| * @returns {Uint8Array} | ||
| */ | ||
| * @param {import('memfs').IFs} memfs | ||
| * @param {any} value | ||
| * @param {ReturnType<typeof getType>} type | ||
| * @returns {Uint8Array} | ||
| */ | ||
| const encodeValue = (memfs, value, type) => { | ||
| switch (type) { | ||
| case 0: | ||
| case 1: | ||
| return new Uint8Array(0) | ||
| case 2: { | ||
| const view = new Int32Array(1); | ||
| view[0] = value ? 1 : 0; | ||
| return new Uint8Array(view.buffer) | ||
| } | ||
| case 3: { | ||
| const view = new Float64Array(1); | ||
| view[0] = value; | ||
| return new Uint8Array(view.buffer) | ||
| } | ||
| case 4: { | ||
| const view = new TextEncoder().encode(value); | ||
| return view | ||
| } | ||
| case 10: | ||
| return new Uint8Array(value) | ||
| case 6: { | ||
| function storeConstructor(obj, memfs, processed = new WeakSet()) { | ||
| if (!obj || typeof obj !== 'object') { | ||
| return | ||
| } | ||
| if (processed.has(obj)) { | ||
| return | ||
| } | ||
| processed.add(obj); | ||
| const [entry] = | ||
| Object.entries(memfs).filter(([_, v]) => v === obj.constructor)[0] ?? | ||
| []; | ||
| if (entry) { | ||
| Object.defineProperty(obj, '__constructor__', { | ||
| configurable: true, | ||
| writable: true, | ||
| enumerable: true, | ||
| value: entry, | ||
| }); | ||
| } | ||
| for (const value of Object.values(obj)) { | ||
| storeConstructor(value, memfs, processed); | ||
| } | ||
| } | ||
| storeConstructor(value, memfs); | ||
| const json = JSON.stringify(value, (_, value) => { | ||
| if (typeof value === 'bigint') { | ||
| return `BigInt(${String(value)})` | ||
| } | ||
| if (value instanceof Error) { | ||
| return { | ||
| ...value, | ||
| message: value.message, | ||
| stack: value.stack, | ||
| __error__: value.constructor.name, | ||
| } | ||
| } | ||
| return value | ||
| }); | ||
| const view = new TextEncoder().encode(json); | ||
| return view | ||
| } | ||
| case 9: { | ||
| return new TextEncoder().encode(String(value)) | ||
| } | ||
| case -1: | ||
| default: | ||
| throw new Error('unsupported data') | ||
| } | ||
| switch (type) { | ||
| case 0: | ||
| case 1: return /* @__PURE__ */ new Uint8Array(0); | ||
| case 2: { | ||
| const view = /* @__PURE__ */ new Int32Array(1); | ||
| view[0] = value ? 1 : 0; | ||
| return new Uint8Array(view.buffer); | ||
| } | ||
| case 3: { | ||
| const view = /* @__PURE__ */ new Float64Array(1); | ||
| view[0] = value; | ||
| return new Uint8Array(view.buffer); | ||
| } | ||
| case 4: return new TextEncoder().encode(value); | ||
| case 10: return new Uint8Array(value); | ||
| case 6: { | ||
| function storeConstructor(obj, memfs, processed = /* @__PURE__ */ new WeakSet()) { | ||
| if (!obj || typeof obj !== "object") return; | ||
| if (processed.has(obj)) return; | ||
| processed.add(obj); | ||
| const [entry] = Object.entries(memfs).filter(([_, v]) => v === obj.constructor)[0] ?? []; | ||
| if (entry) Object.defineProperty(obj, "__constructor__", { | ||
| configurable: true, | ||
| writable: true, | ||
| enumerable: true, | ||
| value: entry | ||
| }); | ||
| for (const value of Object.values(obj)) storeConstructor(value, memfs, processed); | ||
| } | ||
| storeConstructor(value, memfs); | ||
| const json = JSON.stringify(value, (_, value) => { | ||
| if (typeof value === "bigint") return `BigInt(${String(value)})`; | ||
| if (value instanceof Error) return { | ||
| ...value, | ||
| message: value.message, | ||
| stack: value.stack, | ||
| __error__: value.constructor.name | ||
| }; | ||
| return value; | ||
| }); | ||
| return new TextEncoder().encode(json); | ||
| } | ||
| case 9: return new TextEncoder().encode(String(value)); | ||
| default: throw new Error("unsupported data"); | ||
| } | ||
| }; | ||
| /** | ||
| * @param {typeof import('memfs')} memfs | ||
| * @param {Uint8Array} payload | ||
| * @param {number} type | ||
| * @returns {any} | ||
| */ | ||
| * @param {typeof import('memfs')} memfs | ||
| * @param {Uint8Array} payload | ||
| * @param {number} type | ||
| * @returns {any} | ||
| */ | ||
| const decodeValue = (memfs, payload, type) => { | ||
| if (type === 0) return undefined | ||
| if (type === 1) return null | ||
| if (type === 2) | ||
| return Boolean(new Int32Array(payload.buffer, payload.byteOffset, 1)[0]) | ||
| if (type === 3) | ||
| return new Float64Array(payload.buffer, payload.byteOffset, 1)[0] | ||
| if (type === 4) return new TextDecoder().decode(payload.slice()) | ||
| if (type === 10) { | ||
| const BufferCtor = globalThis.Buffer; | ||
| if (typeof BufferCtor?.from === 'function') { | ||
| return BufferCtor.from(payload) | ||
| } | ||
| return payload.slice() | ||
| } | ||
| if (type === 6) { | ||
| const obj = JSON.parse( | ||
| new TextDecoder().decode(payload.slice()), | ||
| (_key, value) => { | ||
| if (typeof value === 'string') { | ||
| const matched = value.match(/^BigInt\((-?\d+)\)$/); | ||
| if (matched && matched[1]) { | ||
| return BigInt(matched[1]) | ||
| } | ||
| } | ||
| return value | ||
| }, | ||
| ); | ||
| function loadConstructor(obj, memfs, processed = new WeakSet()) { | ||
| if (!obj || typeof obj !== 'object') { | ||
| return | ||
| } | ||
| if (processed.has(obj)) { | ||
| return | ||
| } | ||
| processed.add(obj); | ||
| if (obj.__constructor__) { | ||
| const ctor = obj.__constructor__; | ||
| delete obj.__constructor__; | ||
| Object.setPrototypeOf(obj, memfs[ctor].prototype); | ||
| } | ||
| for (const value of Object.values(obj)) { | ||
| loadConstructor(value, memfs, processed); | ||
| } | ||
| } | ||
| loadConstructor(obj, memfs); | ||
| if (obj.__error__) { | ||
| const name = obj.__error__; | ||
| const ErrorConstructor = globalThis[name] || Error; | ||
| delete obj.__error__; | ||
| const err = new ErrorConstructor(obj.message); | ||
| Object.defineProperty(err, 'stack', { | ||
| configurable: true, | ||
| enumerable: false, | ||
| writable: true, | ||
| value: err.stack, | ||
| }); | ||
| Object.defineProperty(err, Symbol.toStringTag, { | ||
| configurable: true, | ||
| enumerable: false, | ||
| writable: true, | ||
| value: name, | ||
| }); | ||
| for (const [k, v] of Object.entries(obj)) { | ||
| if (k === 'message' || k === 'stack') continue | ||
| err[k] = v; | ||
| } | ||
| return err | ||
| } | ||
| return obj | ||
| } | ||
| if (type === 9) { | ||
| return BigInt(new TextDecoder().decode(payload.slice())) | ||
| } | ||
| throw new Error('unsupported data') | ||
| if (type === 0) return void 0; | ||
| if (type === 1) return null; | ||
| if (type === 2) return Boolean(new Int32Array(payload.buffer, payload.byteOffset, 1)[0]); | ||
| if (type === 3) return new Float64Array(payload.buffer, payload.byteOffset, 1)[0]; | ||
| if (type === 4) return new TextDecoder().decode(payload.slice()); | ||
| if (type === 10) { | ||
| const BufferCtor = globalThis.Buffer; | ||
| if (typeof BufferCtor?.from === "function") return BufferCtor.from(payload); | ||
| return payload.slice(); | ||
| } | ||
| if (type === 6) { | ||
| const obj = JSON.parse(new TextDecoder().decode(payload.slice()), (_key, value) => { | ||
| if (typeof value === "string") { | ||
| const matched = value.match(/^BigInt\((-?\d+)\)$/); | ||
| if (matched && matched[1]) return BigInt(matched[1]); | ||
| } | ||
| return value; | ||
| }); | ||
| function loadConstructor(obj, memfs, processed = /* @__PURE__ */ new WeakSet()) { | ||
| if (!obj || typeof obj !== "object") return; | ||
| if (processed.has(obj)) return; | ||
| processed.add(obj); | ||
| if (obj.__constructor__) { | ||
| const ctor = obj.__constructor__; | ||
| delete obj.__constructor__; | ||
| Object.setPrototypeOf(obj, memfs[ctor].prototype); | ||
| } | ||
| for (const value of Object.values(obj)) loadConstructor(value, memfs, processed); | ||
| } | ||
| loadConstructor(obj, memfs); | ||
| if (obj.__error__) { | ||
| const name = obj.__error__; | ||
| const ErrorConstructor = globalThis[name] || Error; | ||
| delete obj.__error__; | ||
| const err = new ErrorConstructor(obj.message); | ||
| Object.defineProperty(err, "stack", { | ||
| configurable: true, | ||
| enumerable: false, | ||
| writable: true, | ||
| value: err.stack | ||
| }); | ||
| Object.defineProperty(err, Symbol.toStringTag, { | ||
| configurable: true, | ||
| enumerable: false, | ||
| writable: true, | ||
| value: name | ||
| }); | ||
| for (const [k, v] of Object.entries(obj)) { | ||
| if (k === "message" || k === "stack") continue; | ||
| err[k] = v; | ||
| } | ||
| return err; | ||
| } | ||
| return obj; | ||
| } | ||
| if (type === 9) return BigInt(new TextDecoder().decode(payload.slice())); | ||
| throw new Error("unsupported data"); | ||
| }; | ||
| /** | ||
| * @param {import('memfs').IFs} fs | ||
| * @returns {(e: { data: { __fs__: { sab: Int32Array, type: keyof import('memfs').IFs, payload: any[] } } }) => void} | ||
| */ | ||
| // oxlint-disable-next-line no-unused-vars -- fixed in an upcoming release | ||
| const createOnMessage = (fs) => | ||
| function onMessage(e) { | ||
| if (e.data.__fs__) { | ||
| /** | ||
| * 0..4 status(int32_t): 21(waiting) 0(success) 1(error) | ||
| * 5..8 type(napi_valuetype): 0(undefined) 1(null) 2(boolean) 3(number) 4(string) 6(jsonstring) 9(bigint) 10(buffer) -1(unsupported) | ||
| * 9..16 payload_size(uint32_t) <= 10240 | ||
| * 16..16 + payload_size payload_content | ||
| */ | ||
| const { sab, type, payload } = e.data.__fs__; | ||
| const fn = fs[type]; | ||
| try { | ||
| const ret = fn.apply(fs, payload); | ||
| const t = getType(ret); | ||
| Atomics.store(sab, 1, t); | ||
| const v = encodeValue(fs, ret, t); | ||
| Atomics.store(sab, 2, v.length); | ||
| writeResponsePayload(sab, v); | ||
| Atomics.store(sab, 0, 0); // success | ||
| } catch (/** @type {any} */ err) { | ||
| let t = getType(err); | ||
| let v; | ||
| try { | ||
| if (t === -1) { | ||
| throw new Error('unsupported data') | ||
| } | ||
| v = encodeValue(fs, err, t); | ||
| } catch { | ||
| const fallback = (() => { | ||
| try { | ||
| return String(err) | ||
| } catch { | ||
| return 'Unserializable thrown value' | ||
| } | ||
| })(); | ||
| t = getType(fallback); | ||
| v = encodeValue(fs, fallback, t); | ||
| } | ||
| if (v.length > RESPONSE_PAYLOAD_SIZE) { | ||
| const overflowErr = new RangeError('payload overflow'); | ||
| t = getType(overflowErr); | ||
| v = encodeValue(fs, overflowErr, t); | ||
| } | ||
| Atomics.store(sab, 1, t); | ||
| Atomics.store(sab, 2, v.length); | ||
| writeResponsePayload(sab, v); | ||
| Atomics.store(sab, 0, 1); // error | ||
| } finally { | ||
| Atomics.notify(sab, 0); | ||
| } | ||
| } | ||
| }; | ||
| * @param {import('memfs').IFs} fs | ||
| * @returns {(e: { data: { __fs__: { sab: Int32Array, type: keyof import('memfs').IFs, payload: any[] } } }) => void} | ||
| */ | ||
| const createOnMessage = (fs) => function onMessage(e) { | ||
| if (e.data.__fs__) { | ||
| /** | ||
| * 0..4 status(int32_t): 21(waiting) 0(success) 1(error) | ||
| * 5..8 type(napi_valuetype): 0(undefined) 1(null) 2(boolean) 3(number) 4(string) 6(jsonstring) 9(bigint) 10(buffer) -1(unsupported) | ||
| * 9..16 payload_size(uint32_t) <= 10240 | ||
| * 16..16 + payload_size payload_content | ||
| */ | ||
| const { sab, type, payload } = e.data.__fs__; | ||
| const fn = fs[type]; | ||
| try { | ||
| const ret = fn.apply(fs, payload); | ||
| const t = getType(ret); | ||
| Atomics.store(sab, 1, t); | ||
| const v = encodeValue(fs, ret, t); | ||
| Atomics.store(sab, 2, v.length); | ||
| writeResponsePayload(sab, v); | ||
| Atomics.store(sab, 0, 0); | ||
| } catch (err) { | ||
| let t = getType(err); | ||
| let v; | ||
| try { | ||
| if (t === -1) throw new Error("unsupported data"); | ||
| v = encodeValue(fs, err, t); | ||
| } catch { | ||
| const fallback = (() => { | ||
| try { | ||
| return String(err); | ||
| } catch { | ||
| return "Unserializable thrown value"; | ||
| } | ||
| })(); | ||
| t = getType(fallback); | ||
| v = encodeValue(fs, fallback, t); | ||
| } | ||
| if (v.length > RESPONSE_PAYLOAD_SIZE) { | ||
| const overflowErr = /* @__PURE__ */ new RangeError("payload overflow"); | ||
| t = getType(overflowErr); | ||
| v = encodeValue(fs, overflowErr, t); | ||
| } | ||
| Atomics.store(sab, 1, t); | ||
| Atomics.store(sab, 2, v.length); | ||
| writeResponsePayload(sab, v); | ||
| Atomics.store(sab, 0, 1); | ||
| } finally { | ||
| Atomics.notify(sab, 0); | ||
| } | ||
| } | ||
| }; | ||
| /** | ||
| * @param {typeof import('memfs')} memfs | ||
| */ | ||
| const createFsProxy = (memfs) => | ||
| new Proxy( | ||
| {}, | ||
| { | ||
| get(_target, p, _receiver) { | ||
| /** | ||
| * @param {any[]} args | ||
| */ | ||
| return function (...args) { | ||
| const sab = new SharedArrayBuffer(RESPONSE_BUFFER_SIZE); | ||
| const i32arr = new Int32Array(sab); | ||
| Atomics.store(i32arr, 0, 21); | ||
| postMessage({ | ||
| __fs__: { | ||
| sab: i32arr, | ||
| type: p, | ||
| payload: args, | ||
| }, | ||
| }); | ||
| Atomics.wait(i32arr, 0, 21); | ||
| const status = Atomics.load(i32arr, 0); | ||
| const type = Atomics.load(i32arr, 1); | ||
| const size = Atomics.load(i32arr, 2); | ||
| const content = new Uint8Array(sab, RESPONSE_HEADER_SIZE, size); | ||
| const value = decodeValue(memfs, content, type); | ||
| if (status === 1) { | ||
| throw value | ||
| } | ||
| return value | ||
| } | ||
| }, | ||
| }, | ||
| ); | ||
| * @param {typeof import('memfs')} memfs | ||
| */ | ||
| const createFsProxy = (memfs) => new Proxy({}, { get(_target, p, _receiver) { | ||
| /** | ||
| * @param {any[]} args | ||
| */ | ||
| return function(...args) { | ||
| const sab = new SharedArrayBuffer(RESPONSE_BUFFER_SIZE); | ||
| const i32arr = new Int32Array(sab); | ||
| Atomics.store(i32arr, 0, 21); | ||
| postMessage({ __fs__: { | ||
| sab: i32arr, | ||
| type: p, | ||
| payload: args | ||
| } }); | ||
| Atomics.wait(i32arr, 0, 21); | ||
| const status = Atomics.load(i32arr, 0); | ||
| const type = Atomics.load(i32arr, 1); | ||
| const size = Atomics.load(i32arr, 2); | ||
| const content = new Uint8Array(sab, RESPONSE_HEADER_SIZE, size); | ||
| const value = decodeValue(memfs, content, type); | ||
| if (status === 1) throw value; | ||
| return value; | ||
| }; | ||
| } }); | ||
| //#endregion | ||
| exports.createFsProxy = createFsProxy; | ||
| exports.createOnMessage = createOnMessage; |
+6
-13
| { | ||
| "name": "@napi-rs/wasm-runtime", | ||
| "version": "1.2.2", | ||
| "version": "1.2.3", | ||
| "type": "module", | ||
@@ -32,9 +32,3 @@ "description": "Runtime and polyfill for wasm targets", | ||
| "devDependencies": { | ||
| "@emnapi/core": "2.0.0-alpha.3", | ||
| "@rollup/plugin-alias": "^6.0.0", | ||
| "@rollup/plugin-commonjs": "^29.0.3", | ||
| "@rollup/plugin-inject": "^5.0.5", | ||
| "@rollup/plugin-json": "^6.1.0", | ||
| "@rollup/plugin-node-resolve": "^16.0.3", | ||
| "@rollup/plugin-replace": "^6.0.3", | ||
| "@emnapi/core": "^2.0.0-alpha.4", | ||
| "buffer": "^6.0.3", | ||
@@ -47,4 +41,3 @@ "events": "^3.3.0", | ||
| "readable-stream": "^4.7.0", | ||
| "rollup": "^4.61.1", | ||
| "rollup-plugin-polyfill-node": "^0.13.0", | ||
| "rolldown": "^1.2.1", | ||
| "tslib": "^2.8.1" | ||
@@ -56,7 +49,7 @@ }, | ||
| "peerDependencies": { | ||
| "@emnapi/core": "^1.7.1 || ^2.0.0-alpha.3", | ||
| "@emnapi/runtime": "^1.7.1 || ^2.0.0-alpha.3" | ||
| "@emnapi/core": "^1.7.1 || ^2.0.0-alpha.4", | ||
| "@emnapi/runtime": "^1.7.1 || ^2.0.0-alpha.4" | ||
| }, | ||
| "scripts": { | ||
| "build": "rollup -c rollup.config.js", | ||
| "build": "rolldown -c", | ||
| "test": "yarn run build && node --test" | ||
@@ -63,0 +56,0 @@ }, |
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Sorry, the diff of this file is too big to display
Fixed alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
AI-detected potential code anomaly
Supply chain riskAI has identified unusual behaviors that may pose a security risk.
Improved metrics
- Dev dependency count
10
-41.18%- Number of low supply chain risk alerts
1
-50%- Number of medium supply chain risk alerts
2
-33.33%Worsened metrics
- Total package byte prevSize
777079
-24.6%- Lines of code
21736
-22.27%No dependency changes