nuxt-ai-ready 2.5.2 → 3.0.0

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

@@ -1,317 +0,0 @@
-// @ts-check
-
-/**
- * @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
-}
-
-/**
- * @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 = RESPONSE_HEADER_SIZE + RESPONSE_PAYLOAD_SIZE
-
-/**
- * @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 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(
-            ([_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
-      })
-      const view = new TextEncoder().encode(json)
-      return view
-    }
-    case 9: {
-      return new TextEncoder().encode(String(value))
-    }
-    case -1:
-    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 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')
-}
-
-/**
- * @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
-export 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 {typeof import('memfs')} memfs
- */
-export 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
-        }
-      },
-    },
-  )

package/node_modules/mdream/node_modules/@napi-rs/wasm-runtime/package.json

@@ -1,67 +0,0 @@
-{
-  "name": "@napi-rs/wasm-runtime",
-  "version": "1.2.4",
-  "type": "module",
-  "description": "Runtime and polyfill for wasm targets",
-  "engines": {
-    "node": "^20.19.0 || ^22.13.0 || >=23.5.0"
-  },
-  "homepage": "https://napi.rs/",
-  "author": {
-    "name": "LongYinan",
-    "url": "https://github.com/Brooooooklyn"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/napi-rs/napi-rs.git",
-    "directory": "wasm-runtime"
-  },
-  "license": "MIT",
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
-    "access": "public"
-  },
-  "files": [
-    "runtime.cjs",
-    "runtime.js",
-    "fs-proxy.js",
-    "dist/*.cjs",
-    "dist/*.js"
-  ],
-  "devDependencies": {
-    "@emnapi/core": "^2.0.0-alpha.4",
-    "buffer": "^6.0.3",
-    "events": "^3.3.0",
-    "memfs": "^4.64.0",
-    "node-inspect-extracted": "^3.3.2",
-    "path-browserify": "^1.0.1",
-    "process": "^0.11.10",
-    "readable-stream": "^4.7.0",
-    "rolldown": "^1.2.1",
-    "tslib": "^2.8.1"
-  },
-  "dependencies": {
-    "@tybys/wasm-util": "^0.10.3"
-  },
-  "peerDependencies": {
-    "@emnapi/core": "^1.7.1 || ^2.0.0-alpha.4",
-    "@emnapi/runtime": "^1.7.1 || ^2.0.0-alpha.4"
-  },
-  "scripts": {
-    "build": "rolldown -c",
-    "test": "yarn run build && node --test"
-  },
-  "funding": {
-    "type": "github",
-    "url": "https://github.com/sponsors/Brooooooklyn"
-  },
-  "exports": {
-    ".": {
-      "import": "./runtime.js",
-      "require": "./runtime.cjs"
-    },
-    "./fs": {
-      "import": "./dist/fs.js"
-    }
-  }
-}

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

@@ -1,39 +0,0 @@
-const {
-  MessageHandler,
-  instantiateNapiModuleSync,
-  instantiateNapiModule,
-} = require('@emnapi/core')
-// Single-threaded (non-shared-memory) WASI builds link an emnapi archive
-// without the C async-work and threadsafe-function implementations (they are
-// unconditional `napi_generic_failure` stubs without threads), so the
-// generated loaders provide the JavaScript implementations through these
-// plugins instead. Raw `instantiateNapiModule(Sync)` callers instantiating a
-// single-threaded napi-rs wasm must pass them too:
-// `plugins: [emnapiAsyncWorkPlugin, emnapiTSFNPlugin]` — without them
-// instantiation fails with a LinkError naming the missing import. Threaded
-// (shared-memory) builds link the C implementations and need no plugins;
-// this mirrors the upstream @emnapi/core v2 plugin split (v1 bundled these
-// implementations in the core runtime). The plugins are bundled into this
-// package so loading the runtime with @emnapi/core v1 does not resolve the
-// v2-only `@emnapi/core/plugins` package export.
-const {
-  emnapiAsyncWorkPlugin,
-  emnapiTSFNPlugin,
-} = require('./dist/emnapi-plugins.cjs')
-const { createContext, getDefaultContext } = require('@emnapi/runtime')
-const { WASI } = require('@tybys/wasm-util')
-
-const { createFsProxy, createOnMessage } = require('./dist/fs-proxy.cjs')
-
-module.exports = {
-  MessageHandler,
-  createContext,
-  emnapiAsyncWorkPlugin,
-  emnapiTSFNPlugin,
-  instantiateNapiModule,
-  instantiateNapiModuleSync,
-  getDefaultContext,
-  WASI,
-  createFsProxy,
-  createOnMessage,
-}

package/node_modules/mdream/node_modules/@napi-rs/wasm-runtime/runtime.js

@@ -1,36 +0,0 @@
-import * as emnapiCore from '@emnapi/core'
-import * as emnapiRuntime from '@emnapi/runtime'
-
-import {
-  emnapiAsyncWorkPlugin,
-  emnapiTSFNPlugin,
-} from './dist/emnapi-plugins.js'
-
-const { instantiateNapiModuleSync, instantiateNapiModule, MessageHandler } =
-  emnapiCore
-const { createContext, getDefaultContext } = emnapiRuntime
-
-// Single-threaded (non-shared-memory) WASI builds link an emnapi archive
-// without the C async-work and threadsafe-function implementations (they are
-// unconditional `napi_generic_failure` stubs without threads), so the
-// generated loaders provide the JavaScript implementations through these
-// plugins instead. Raw `instantiateNapiModule(Sync)` callers instantiating a
-// single-threaded napi-rs wasm must pass them too:
-// `plugins: [emnapiAsyncWorkPlugin, emnapiTSFNPlugin]` — without them
-// instantiation fails with a LinkError naming the missing import. Threaded
-// (shared-memory) builds link the C implementations and need no plugins;
-// this mirrors the upstream @emnapi/core v2 plugin split (v1 bundled these
-// implementations in the core runtime). The plugins are bundled into this
-// package so loading the runtime with @emnapi/core v1 does not resolve the
-// v2-only `@emnapi/core/plugins` package export.
-export {
-  MessageHandler,
-  createContext,
-  emnapiAsyncWorkPlugin,
-  emnapiTSFNPlugin,
-  getDefaultContext,
-  instantiateNapiModule,
-  instantiateNapiModuleSync,
-}
-export * from '@tybys/wasm-util'
-export { createOnMessage, createFsProxy } from './fs-proxy.js'

package/node_modules/mdream/node_modules/@tybys/wasm-util/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022-present Toyobayashi
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/node_modules/mdream/node_modules/@tybys/wasm-util/README.md

@@ -1,193 +0,0 @@
-# @tybys/wasm-util
-
-WebAssembly related utils for browser environment
-
-**The output code is ES2019**
-
-## Features
-
-All example code below need to be bundled by ES module bundlers like `webpack` / `rollup`, or specify import map in browser native ES module runtime.
-
-### WASI polyfill for browser
-
-The API is similar to the `require('wasi').WASI` in Node.js.
-
-You can use `memfs-browser` to provide filesystem capability.
-
-- Example: [https://github.com/toyobayashi/wasi-wabt](https://github.com/toyobayashi/wasi-wabt)
-- Demo: [https://toyobayashi.github.io/wasi-wabt/](https://toyobayashi.github.io/wasi-wabt/)
-
-```js
-import { load, WASI } from '@tybys/wasm-util'
-import { Volume, createFsFromVolume } from 'memfs-browser'
-
-const fs = createFsFromVolume(Volume.fromJSON({
-  '/home/wasi': null
-}))
-
-const wasi = new WASI({
-  args: ['chrome', 'file.wasm'],
-  env: {
-    NODE_ENV: 'development',
-    WASI_SDK_PATH: '/opt/wasi-sdk'
-  },
-  preopens: {
-    '/': '/'
-  },
-  fs,
-
-  // redirect stdout / stderr
-
-  // print (text) { console.log(text) },
-  // printErr (text) { console.error(text) }
-})
-
-const imports = {
-  wasi_snapshot_preview1: wasi.wasiImport
-}
-
-const { module, instance } = await load('/path/to/file.wasm', imports)
-wasi.start(instance)
-// wasi.initialize(instance)
-```
-
-Implemented syscalls: [wasi_snapshot_preview1](#wasi_snapshot_preview1)
-
-### `load` / `loadSync`
-
-`loadSync` has 4KB wasm size limit in browser.
-
-```js
-// bundler
-import { load, loadSync } from '@tybys/wasm-util'
-
-const imports = { /* ... */ }
-
-// using path
-const { module, instance } = await load('/path/to/file.wasm', imports)
-const { module, instance } = loadSync('/path/to/file.wasm', imports)
-
-// using URL
-const { module, instance } = await load(new URL('./file.wasm', import.meta.url), imports)
-const { module, instance } = loadSync(new URL('./file.wasm', import.meta.url), imports)
-
-// using Uint8Array
-const buffer = new Uint8Array([
-  0x00, 0x61, 0x73, 0x6d,
-  0x01, 0x00, 0x00, 0x00
-])
-const { module, instance } = await load(buffer, imports)
-const { module, instance } = loadSync(buffer, imports)
-
-// auto asyncify
-const {
-  module,
-  instance: asyncifiedInstance
-} = await load(buffer, imports, { /* asyncify options */})
-asyncifiedInstance.exports.fn() // => return Promise
-```
-
-### Extend Memory instance
-
-```js
-import { Memory, extendMemory } from '@tybys/wasm-util'
-
-const memory = new WebAssembly.Memory({ initial: 256 })
-// const memory = instance.exports.memory
-
-extendMemory(memory)
-console.log(memory instanceof Memory)
-console.log(memory instanceof WebAssembly.Memory)
-// expose memory view getters like Emscripten
-const { HEAPU8, HEAPU32, view } = memory
-```
-
-### Asyncify wrap
-
-Build the C code using `clang`, `wasm-ld` and `wasm-opt`
-
-```c
-void async_sleep(int ms);
-
-int main() {
-  async_sleep(200);
-  return 0;
-}
-```
-
-```js
-import { Asyncify } from '@tybys/wasm-util'
-
-const asyncify = new Asyncify()
-
-const imports = {
-  env: {
-    async_sleep: asyncify.wrapImportFunction(function (ms) {
-      return new Promise((resolve) => {
-        setTimeout(resolve, ms)
-      })
-    })
-  }
-}
-
-// async_sleep(200)
-const bytes = await (await fetch('/asyncfied_by_wasm-opt.wasm')).arrayBuffer()
-const { instance } = await WebAssembly.instantiate(bytes, imports)
-const asyncifiedInstance = asyncify.init(instance.exports.memory, instance, {
-  wrapExports: ['_start']
-})
-
-const p = asyncifedInstance._start()
-console.log(typeof p.then === 'function')
-const now = Date.now()
-await p
-console.log(Date.now() - now >= 200)
-```
-
-### wasi_snapshot_preview1
-
-- [x] args_get
-- [x] args_sizes_get
-- [x] environ_get
-- [x] environ_sizes_get
-- [x] clock_res_get
-- [x] clock_time_get
-- [ ] ~~fd_advise~~
-- [x] fd_allocate
-- [x] fd_close
-- [x] fd_datasync
-- [x] fd_fdstat_get
-- [ ] ~~fd_fdstat_set_flags~~
-- [x] fd_fdstat_set_rights
-- [x] fd_filestat_get
-- [x] fd_filestat_set_size
-- [x] fd_filestat_set_times
-- [x] fd_pread
-- [x] fd_prestat_get
-- [x] fd_prestat_dir_name
-- [x] fd_pwrite
-- [x] fd_read
-- [x] fd_readdir
-- [x] fd_renumber
-- [x] fd_seek
-- [x] fd_sync
-- [x] fd_tell
-- [x] fd_write
-- [x] path_create_directory
-- [x] path_filestat_get
-- [x] path_filestat_set_times
-- [x] path_link
-- [x] path_open
-- [x] path_readlink
-- [x] path_remove_directory
-- [x] path_rename
-- [x] path_symlink
-- [x] path_unlink_file
-- [x] poll_oneoff (timer only)
-- [x] proc_exit
-- [ ] ~~proc_raise~~
-- [x] sched_yield
-- [x] random_get
-- [ ] ~~sock_recv~~
-- [ ] ~~sock_send~~
-- [ ] ~~sock_shutdown~~

package/node_modules/mdream/node_modules/@tybys/wasm-util/dist/tsdoc-metadata.json

@@ -1,11 +0,0 @@
-// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
-// It should be published with your NPM package.  It should not be tracked by Git.
-{
-  "tsdocVersion": "0.12",
-  "toolPackages": [
-    {
-      "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.34.4"
-    }
-  ]
-}