nuxt-ai-ready 2.5.0 → 2.5.2

package/node_modules/mdream/node_modules/@napi-rs/wasm-runtime/dist/fs-proxy.cjs

@@ -0,0 +1,237 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region fs-proxy.js
+/**
+* @param {unknown} value
+*/
+const getType = (value) => {
+	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}
+*/
+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 RESPONSE_HEADER_SIZE = 16;
+const RESPONSE_PAYLOAD_SIZE = 10240;
+const RESPONSE_BUFFER_SIZE = 10256;
+/**
+* @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);
+};
+/**
+* @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 /* @__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(([_key, 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}
+*/
+const decodeValue = (memfs, payload, type) => {
+	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}
+*/
+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;
+	};
+} });
+//#endregion
+exports.createFsProxy = createFsProxy;
+exports.createOnMessage = createOnMessage;