nuxt-ai-ready 2.5.3 → 3.0.1

package/node_modules/mdream/node_modules/@emnapi/wasi-threads/README.md

@@ -1,203 +0,0 @@
-# @emnapi/wasi-threads
-
-This package makes [wasi-threads proposal](https://github.com/WebAssembly/wasi-threads) based WASI modules work in Node.js and browser.
-
-## Quick Start
-
-`index.html`
-
-```html
-<script src="./node_modules/@tybys/wasm-util/dist/wasm-util.js"></script>
-<script src="./node_modules/@emnapi/wasi-threads/dist/wasi-threads.js"></script>
-<script src="./index.js"></script>
-```
-
-If your application will block browser main thread (for example `pthread_join`), please run it in worker instead.
-
-```html
-<script>
-  // pthread_join (Atomics.wait) cannot be called in browser main thread
-  new Worker('./index.js')
-</script>
-```
-
-`index.js`
-
-```js
-const ENVIRONMENT_IS_NODE =
-  typeof process === 'object' && process !== null &&
-  typeof process.versions === 'object' && process.versions !== null &&
-  typeof process.versions.node === 'string';
-
-(function (main) {
-  if (ENVIRONMENT_IS_NODE) {
-    main(require)
-  } else {
-    if (typeof importScripts === 'function') {
-      importScripts('./node_modules/@tybys/wasm-util/dist/wasm-util.js')
-      importScripts('./node_modules/@emnapi/wasi-threads/dist/wasi-threads.js')
-    }
-    const nodeWasi = { WASI: globalThis.wasmUtil.WASI }
-    const nodeWorkerThreads = {
-      Worker: globalThis.Worker
-    }
-    const _require = function (request) {
-      if (request === 'node:wasi' || request === 'wasi') return nodeWasi
-      if (request === 'node:worker_threads' || request === 'worker_threads') return nodeWorkerThreads
-      if (request === '@emnapi/wasi-threads') return globalThis.wasiThreads
-      throw new Error('Can not find module: ' + request)
-    }
-    main(_require)
-  }
-})(async function (require) {
-  const { WASI } = require('wasi')
-  const { Worker } = require('worker_threads')
-  const { WASIThreads } = require('@emnapi/wasi-threads')
-
-  const wasi = new WASI({
-    version: 'preview1'
-  })
-  const wasiThreads = new WASIThreads({
-    wasi,
-
-    /**
-     * avoid Atomics.wait() deadlock during thread creation in browser
-     * see https://emscripten.org/docs/tools_reference/settings_reference.html#pthread-pool-size
-     */
-    reuseWorker: ENVIRONMENT_IS_NODE
-      ? false
-      : {
-          size: 4 /** greater than actual needs (2) */,
-          strict: true
-        },
-
-    /**
-     * Synchronous thread creation
-     * pthread_create will not return until thread worker actually starts
-     */
-    waitThreadStart: typeof window === 'undefined' ? 1000 : false,
-
-    onCreateWorker: () => {
-      return new Worker('./worker.js', {
-        execArgv: ['--experimental-wasi-unstable-preview1']
-      })
-    }
-  })
-  const memory = new WebAssembly.Memory({
-    initial: 16777216 / 65536,
-    maximum: 2147483648 / 65536,
-    shared: true
-  })
-  let input
-  const file = 'path/to/your/wasi-module.wasm'
-  try {
-    input = require('fs').readFileSync(require('path').join(__dirname, file))
-  } catch (err) {
-    const response = await fetch(file)
-    input = await response.arrayBuffer()
-  }
-  let { module, instance } = await WebAssembly.instantiate(input, {
-    env: { memory },
-    wasi_snapshot_preview1: wasi.wasiImport,
-    ...wasiThreads.getImportObject()
-  })
-
-  wasiThreads.setup(instance, module, memory)
-  await wasiThreads.preloadWorkers()
-
-  if (typeof instance.exports._start === 'function') {
-    return wasi.start(instance)
-  } else {
-    wasi.initialize(instance)
-    // instance.exports.exported_wasm_function()
-  }
-})
-```
-
-`worker.js`
-
-```js
-(function (main) {
-  const ENVIRONMENT_IS_NODE =
-    typeof process === 'object' && process !== null &&
-    typeof process.versions === 'object' && process.versions !== null &&
-    typeof process.versions.node === 'string'
-
-  if (ENVIRONMENT_IS_NODE) {
-    const _require = function (request) {
-      return require(request)
-    }
-
-    const _init = function () {
-      const nodeWorkerThreads = require('worker_threads')
-      const parentPort = nodeWorkerThreads.parentPort
-
-      parentPort.on('message', (data) => {
-        globalThis.onmessage({ data })
-      })
-
-      Object.assign(globalThis, {
-        self: globalThis,
-        require,
-        Worker: nodeWorkerThreads.Worker,
-        importScripts: function (f) {
-          (0, eval)(require('fs').readFileSync(f, 'utf8') + '//# sourceURL=' + f)
-        },
-        postMessage: function (msg) {
-          parentPort.postMessage(msg)
-        }
-      })
-    }
-
-    main(_require, _init)
-  } else {
-    importScripts('./node_modules/@tybys/wasm-util/dist/wasm-util.js')
-    importScripts('./node_modules/@emnapi/wasi-threads/dist/wasi-threads.js')
-
-    const nodeWasi = { WASI: globalThis.wasmUtil.WASI }
-    const _require = function (request) {
-      if (request === '@emnapi/wasi-threads') return globalThis.wasiThreads
-      if (request === 'node:wasi' || request === 'wasi') return nodeWasi
-      throw new Error('Can not find module: ' + request)
-    }
-    const _init = function () {}
-    main(_require, _init)
-  }
-})(function main (require, init) {
-  init()
-
-  const { WASI } = require('wasi')
-  const { ThreadMessageHandler, WASIThreads } = require('@emnapi/wasi-threads')
-
-  const handler = new ThreadMessageHandler({
-    async onLoad ({ wasmModule, wasmMemory }) {
-      const wasi = new WASI({
-        version: 'preview1'
-      })
-
-      const wasiThreads = new WASIThreads({
-        wasi,
-        childThread: true
-      })
-
-      const originalInstance = await WebAssembly.instantiate(wasmModule, {
-        env: {
-          memory: wasmMemory,
-        },
-        wasi_snapshot_preview1: wasi.wasiImport,
-        ...wasiThreads.getImportObject()
-      })
-
-      // must call `initialize` instead of `start` in child thread
-      const instance = wasiThreads.initialize(originalInstance, wasmModule, wasmMemory)
-
-      return { module: wasmModule, instance }
-    }
-  })
-
-  globalThis.onmessage = function (e) {
-    handler.handle(e)
-    // handle other messages
-  }
-})
-```

package/node_modules/mdream/node_modules/@emnapi/wasi-threads/dist/wasi-threads.d.ts

@@ -1,240 +0,0 @@
-import type { Worker as Worker_2 } from 'worker_threads';
-
-export declare interface BaseOptions {
-    wasi: WASIInstance;
-    version?: 'preview1';
-    wasm64?: boolean;
-}
-
-export declare interface ChildThreadOptions extends BaseOptions {
-    childThread: true;
-    postMessage?: (data: any) => void;
-}
-
-export declare interface CleanupThreadPayload {
-    tid: number;
-}
-
-export declare interface CommandInfo<T extends CommandType> {
-    type: T;
-    payload: CommandPayloadMap[T];
-}
-
-export declare interface CommandPayloadMap {
-    load: LoadPayload;
-    loaded: LoadedPayload;
-    start: StartPayload;
-    'cleanup-thread': CleanupThreadPayload;
-    'terminate-all-threads': TerminateAllThreadsPayload;
-    'spawn-thread': SpawnThreadPayload;
-    'thread-error': ThreadErrorPayload;
-}
-
-export declare type CommandType = keyof CommandPayloadMap;
-
-export declare function createInstanceProxy(instance: WebAssembly.Instance, memory?: WebAssembly.Memory | (() => WebAssembly.Memory)): WebAssembly.Instance;
-
-export declare function isSharedArrayBuffer(value: any): value is SharedArrayBuffer;
-
-export declare function isTrapError(e: Error): e is WebAssembly.RuntimeError;
-
-export declare interface LoadedPayload {
-}
-
-export declare interface LoadPayload {
-    wasmModule: WebAssembly.Module;
-    wasmMemory: WebAssembly.Memory;
-    sab?: Int32Array;
-}
-
-export declare interface MainThreadBaseOptions extends BaseOptions {
-    waitThreadStart?: boolean | number;
-}
-
-export declare type MainThreadOptions = MainThreadOptionsWithThreadManager | MainThreadOptionsCreateThreadManager;
-
-export declare interface MainThreadOptionsCreateThreadManager extends MainThreadBaseOptions, ThreadManagerOptionsMain {
-}
-
-export declare interface MainThreadOptionsWithThreadManager extends MainThreadBaseOptions {
-    threadManager?: ThreadManager | (() => ThreadManager);
-}
-
-export declare interface MessageEventData<T extends CommandType> {
-    __emnapi__: CommandInfo<T>;
-}
-
-export declare interface ReuseWorkerOptions {
-    size: number;
-    strict?: boolean;
-}
-
-export declare interface SerializedError {
-    name: string;
-    message: string;
-    stack?: string;
-    cause?: unknown;
-}
-
-export declare interface SpawnThreadPayload {
-    startArg: number;
-    errorOrTid: number;
-}
-
-export declare interface StartPayload {
-    tid: number;
-    arg: number;
-    sab?: Int32Array;
-}
-
-export declare interface StartResult {
-    exitCode: number;
-    instance: WebAssembly.Instance;
-}
-
-export declare interface TerminateAllThreadsPayload {
-}
-
-export declare interface ThreadErrorPayload {
-    error: SerializedError;
-    phase: ThreadFailurePhase;
-    tid?: number;
-}
-
-export declare type ThreadFailurePhase = 'load' | 'start' | 'async-work' | 'message' | 'messageerror' | 'exit';
-
-export declare class ThreadManager {
-    unusedWorkers: WorkerLike[];
-    pthreads: Record<number, WorkerLike>;
-    get nextWorkerID(): number;
-    wasmModule: WebAssembly.Module | null;
-    wasmMemory: WebAssembly.Memory | null;
-    private readonly messageEvents;
-    private readonly registeredWorkers;
-    private readonly expectedTerminations;
-    private readonly loadRejects;
-    private _fatalError;
-    private readonly _childThread;
-    private readonly _onCreateWorker;
-    private readonly _reuseWorker;
-    private readonly _beforeLoad?;
-    readonly printErr: (message: string) => void;
-    threadSpawn?: ((startArg: number, errorOrTid?: number) => number);
-    constructor(options: ThreadManagerOptions);
-    init(): void;
-    initMainThread(): void;
-    private preparePool;
-    shouldPreloadWorkers(): boolean;
-    loadWasmModuleToAllWorkers(): Promise<WorkerLike[]>;
-    preloadWorkers(): Promise<WorkerLike[]>;
-    setup(wasmModule: WebAssembly.Module, wasmMemory: WebAssembly.Memory): void;
-    private assertRunning;
-    private fail;
-    markId(worker: WorkerLike): number;
-    returnWorkerToPool(worker: WorkerLike): void;
-    loadWasmModuleToWorker(worker: WorkerLike, sab?: Int32Array): Promise<WorkerLike>;
-    allocateUnusedWorker(): WorkerLike;
-    private allocatePoolWorker;
-    private dropFailedLoad;
-    getNewWorker(sab?: Int32Array): WorkerLike | undefined;
-    private allocateAndLoadWorker;
-    cleanThread(worker: WorkerLike, tid: number, force?: boolean): void;
-    terminateWorker(worker: WorkerLike): void;
-    terminateAllThreads(): void;
-    private shutdownAllWorkers;
-    addMessageEventListener(worker: WorkerLike, onMessage: (e: WorkerMessageEvent) => void): () => void;
-    fireMessageEvent(worker: WorkerLike, e: WorkerMessageEvent): void;
-}
-
-export declare type ThreadManagerOptions = ThreadManagerOptionsMain | ThreadManagerOptionsChild;
-
-export declare interface ThreadManagerOptionsBase {
-    printErr?: (message: string) => void;
-    threadSpawn?: (startArg: number, errorOrTid?: number) => number;
-}
-
-export declare interface ThreadManagerOptionsChild extends ThreadManagerOptionsBase {
-    childThread: true;
-}
-
-export declare interface ThreadManagerOptionsMain extends ThreadManagerOptionsBase {
-    beforeLoad?: (worker: WorkerLike) => any;
-    reuseWorker?: boolean | number | ReuseWorkerOptions;
-    onCreateWorker: WorkerFactory;
-    childThread?: false;
-}
-
-export declare class ThreadMessageHandler {
-    protected instance: WebAssembly.Instance | undefined;
-    private messagesBeforeLoad;
-    protected postMessage: (message: any) => void;
-    protected onLoad?: (data: LoadPayload) => WebAssembly.WebAssemblyInstantiatedSource | PromiseLike<WebAssembly.WebAssemblyInstantiatedSource>;
-    protected onError: (error: Error, type: WorkerMessageType) => void;
-    constructor(options?: ThreadMessageHandlerOptions);
-    instantiate(data: LoadPayload): WebAssembly.WebAssemblyInstantiatedSource | PromiseLike<WebAssembly.WebAssemblyInstantiatedSource>;
-    handle(e: WorkerMessageEvent<MessageEventData<WorkerMessageType>>): void;
-    private _load;
-    private _start;
-    protected _loaded(err: Error | null, source: WebAssembly.WebAssemblyInstantiatedSource | null, payload: LoadPayload): void;
-    private _failQueuedStarts;
-    protected handleAfterLoad<E extends WorkerMessageEvent>(e: E, f: (e: E) => void): void;
-    protected beforeReportError(_error: Error, _type: WorkerMessageType | 'async-worker-init', _tid?: number): void;
-    protected reportError(value: unknown, type: WorkerMessageType | 'async-worker-init', tid?: number): void;
-}
-
-export declare interface ThreadMessageHandlerOptions {
-    onLoad?: (data: LoadPayload) => WebAssembly.WebAssemblyInstantiatedSource | PromiseLike<WebAssembly.WebAssemblyInstantiatedSource>;
-    onError?: (error: Error, type: WorkerMessageType) => void;
-    postMessage?: (message: any) => void;
-}
-
-export declare interface WASIInstance {
-    readonly wasiImport?: Record<string, any>;
-    initialize(instance: object): void;
-    start(instance: object): number;
-    getImportObject?(): any;
-}
-
-export declare class WASIThreads {
-    PThread: ThreadManager | undefined;
-    private wasmMemory;
-    private wasmInstance;
-    private readonly threadSpawn;
-    readonly childThread: boolean;
-    private readonly postMessage;
-    readonly wasi: WASIInstance;
-    constructor(options: WASIThreadsOptions);
-    getImportObject(): {
-        wasi: WASIThreadsImports;
-    };
-    setup(wasmInstance: WebAssembly.Instance, wasmModule: WebAssembly.Module, wasmMemory?: WebAssembly.Memory): void;
-    preloadWorkers(): Promise<WorkerLike[]>;
-    initialize(instance: WebAssembly.Instance, module: WebAssembly.Module, memory?: WebAssembly.Memory): WebAssembly.Instance;
-    start(instance: WebAssembly.Instance, module: WebAssembly.Module, memory?: WebAssembly.Memory): StartResult;
-    terminateAllThreads(): void;
-}
-
-export declare interface WASIThreadsImports {
-    'thread-spawn': (startArg: number, errorOrTid?: number) => number;
-}
-
-export declare type WASIThreadsOptions = MainThreadOptions | ChildThreadOptions;
-
-export declare type WorkerFactory = (ctx: {
-    type: string;
-    name: string;
-}) => WorkerLike;
-
-export declare type WorkerLike = (Worker | Worker_2) & {
-    whenLoaded?: Promise<WorkerLike>;
-    loaded?: boolean;
-    __emnapi_tid?: number;
-};
-
-export declare interface WorkerMessageEvent<T = any> {
-    data: T;
-}
-
-export declare type WorkerMessageType = 'load' | 'start';
-
-export { }