@tailwindcss/oxide-wasm32-wasi 0.0.0-insiders.fc4afc2 → 0.0.0-insiders.fc63ce7

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

@@ -1,193 +0,0 @@
-// @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)})`
-        }
-        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 {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]
-    const args = payload ? payload.map((value) => {
-      if (value instanceof Uint8Array) {
-        // buffer polyfill bug
-        // @ts-expect-error
-        value._isBuffer = true
-      }
-      return value
-    }) : payload
-    try {
-      const ret = fn.apply(fs, args)
-      const t = getType(ret)
-      const v = encodeValue(fs, ret, t)
-      Atomics.store(sab, 0, 0)
-      Atomics.store(sab, 1, t)
-      Atomics.store(sab, 2, v.length)
-      new Uint8Array(sab.buffer).set(v, 16)
-
-    } catch (/** @type {any} */ err) {
-      Atomics.store(sab, 0, 1)
-      Atomics.store(sab, 1, 6)
-      const payloadContent = new TextEncoder().encode(JSON.stringify({
-        ...err,
-        message: err.message,
-        stack: err.stack
-      }))
-      Atomics.store(sab, 2, payloadContent.length)
-      new Uint8Array(sab.buffer).set(payloadContent, 16)
-    } finally {
-      Atomics.notify(sab, 0)
-    }
-  }
-}
-
-/**
- * @param {import('memfs').IFs} memfs
- */
-module.exports.createFsProxy = (memfs) => new Proxy({}, {
-  get (_target, p, _receiver) {
-    /**
-     * @param {any[]} args
-     */
-    return function (...args) {
-      const sab = new SharedArrayBuffer(16 + 1024)
-      const i32arr = new Int32Array(sab)
-      Atomics.store(i32arr, 0, 21)
-
-      // @ts-expect-error
-      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)
-      if (status === 1) {
-        const errobj = JSON.parse(new TextDecoder().decode(content.slice()))
-        const err = new Error(errobj.message)
-        Object.defineProperty(err, 'stack', {
-          configurable: true,
-          enumerable: false,
-          writable: true,
-          value: errobj.stack
-        })
-        for (const [k, v] of Object.entries(errobj)) {
-          if (k === 'message' || k === 'stack') continue
-          // @ts-expect-error
-          err[k] = v
-        }
-        throw err
-      }
-      if (type === 0) return undefined
-      if (type === 1) return null
-      if (type === 2) return Boolean(content[0])
-      if (type === 3) return new Float64Array(sab, 16, 1)[0]
-      if (type === 4) return new TextDecoder().decode(content.slice())
-      if (type === 6) {
-        const obj = JSON.parse(new TextDecoder().decode(content.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__
-          // @ts-expect-error
-          Object.setPrototypeOf(obj, memfs[ctor].prototype)
-        }
-        return obj
-      }
-      if (type === 9) return new BigInt64Array(sab, 16, 1)[0]
-      throw new Error('unsupported data')
-    }
-  }
-})