@tailwindcss/oxide-wasm32-wasi 0.0.0-insiders.231cddd

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

@@ -0,0 +1,209 @@
+// @ts-check
+
+/**
+ * @param {unknown} value
+ */
+const getType = (value) => {
+  if (value === undefined) return 0
+  if (value === null) return 1
+  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 {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 6: {
+      const [entry] = Object.entries(memfs).filter(([_, v]) => v === value.constructor)[0] ?? []
+      if (entry) {
+        Object.defineProperty(value, '__constructor__', {
+          configurable: true,
+          writable: true,
+          enumerable: true,
+          value: entry
+        })
+      }
+
+      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: {
+      const view = new BigInt64Array(1)
+      view[0] = value
+      return new Uint8Array(view.buffer)
+    }
+    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(payload[0])
+  if (type === 3) return new Float64Array(payload.buffer, payload.byteOffset, 1)[0]
+  if (type === 4) return new TextDecoder().decode(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
+    })
+    if (obj.__constructor__) {
+      const ctor = obj.__constructor__
+      delete obj.__constructor__
+      Object.setPrototypeOf(obj, memfs[ctor].prototype)
+    }
+    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 new BigInt64Array(payload.buffer, payload.byteOffset, 1)[0]
+  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
+module.exports.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) -1(unsupported)
+     * 9..16                   payload_size(uint32_t)  <= 1024
+     * 16..16 + payload_size   payload_content
+     */
+    const { sab, type, payload } = e.data.__fs__
+    const fn = fs[type]
+    try {
+      const ret = fn.apply(fs, payload)
+      Atomics.store(sab, 0, 0)
+      const t = getType(ret)
+      Atomics.store(sab, 1, t)
+      const v = encodeValue(fs, ret, t)
+      Atomics.store(sab, 2, v.length)
+      new Uint8Array(sab.buffer).set(v, 16)
+
+    } catch (/** @type {any} */ err) {
+      Atomics.store(sab, 0, 1)
+      const t = getType(err)
+      Atomics.store(sab, 1, t)
+      const v = encodeValue(fs, err, t)
+      Atomics.store(sab, 2, v.length)
+      new Uint8Array(sab.buffer).set(v, 16)
+    } finally {
+      Atomics.notify(sab, 0)
+    }
+  }
+}
+
+/**
+ * @param {typeof import('memfs')} memfs
+ */
+module.exports.createFsProxy = (memfs) => new Proxy({}, {
+  get (_target, p, _receiver) {
+    /**
+     * @param {any[]} args
+     */
+    return function (...args) {
+      const sab = new SharedArrayBuffer(16 + 10240)
+      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, 16, size)
+      const value = decodeValue(memfs, content, type)
+      if (status === 1) {
+        throw value
+      }
+      return value
+    }
+  }
+})

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

@@ -0,0 +1,61 @@
+{
+  "name": "@napi-rs/wasm-runtime",
+  "version": "0.2.9",
+  "type": "module",
+  "description": "Runtime and polyfill for wasm targets",
+  "author": {
+    "name": "LongYinan",
+    "url": "https://github.com/Brooooooklyn"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/napi-rs/napi-rs.git",
+    "directory": "wasi-runtime"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "files": [
+    "runtime.cjs",
+    "fs-proxy.cjs",
+    "dist/*.js"
+  ],
+  "devDependencies": {
+    "@rollup/plugin-alias": "^5.1.1",
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-inject": "^5.0.5",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-replace": "^6.0.2",
+    "buffer": "^6.0.3",
+    "memfs": "^4.17.0",
+    "node-inspect-extracted": "^3.0.2",
+    "path-browserify": "^1.0.1",
+    "process": "^0.11.10",
+    "readable-stream": "^4.7.0",
+    "rollup": "^4.38.0",
+    "rollup-plugin-polyfill-node": "^0.13.0",
+    "tslib": "^2.8.1"
+  },
+  "dependencies": {
+    "@emnapi/core": "^1.4.0",
+    "@emnapi/runtime": "^1.4.0",
+    "@tybys/wasm-util": "^0.9.0"
+  },
+  "scripts": {
+    "build": "rollup -c rollup.config.js",
+    "test": "node --test"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/runtime.js",
+      "require": "./runtime.cjs"
+    },
+    "./fs": {
+      "import": "./dist/fs.js"
+    }
+  },
+  "gitHead": "84209fc82931e8c6ef93e61e4a0e1d1a0ffaf511"
+}

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

@@ -0,0 +1,15 @@
+const { MessageHandler, instantiateNapiModuleSync, instantiateNapiModule } = require('@emnapi/core')
+const { getDefaultContext } = require('@emnapi/runtime')
+const { WASI } = require('@tybys/wasm-util')
+
+const { createFsProxy, createOnMessage } = require('./fs-proxy.cjs')
+
+module.exports = {
+  MessageHandler,
+  instantiateNapiModule,
+  instantiateNapiModuleSync,
+  getDefaultContext,
+  WASI,
+  createFsProxy,
+  createOnMessage,
+}

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

@@ -0,0 +1,193 @@
+# @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/@tybys/wasm-util/dist/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// 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"
+    }
+  ]
+}