@pnpm/exe 12.8.2 → 12.9.0

package/dist/wasm/host/terminal-session.mjs

@@ -0,0 +1,114 @@
+import { emitKeypressEvents } from 'node:readline'
+import { PassThrough } from 'node:stream'
+
+import { claimTerminalInput } from './terminal-input.mjs'
+
+export async function openTerminal (resources, { input = process.stdin, output = selectOutput(), maxQueuedKeys = 128 } = {}) {
+  if (!input.isTTY || !output?.isTTY || typeof input.setRawMode !== 'function') {
+    throw Object.assign(new Error('Interactive terminal input is unavailable'), { code: 'ENOTTY' })
+  }
+  const release = claimTerminalInput(input)
+  let session
+  try {
+    session = createSession(input, output, { release, maxQueuedKeys })
+    return { handle: resources.add(session), rows: output.rows ?? null, columns: output.columns ?? null }
+  } catch (error) {
+    await session?.close()
+    release()
+    throw error
+  }
+}
+
+export function writeTerminal (session, text) {
+  if (typeof text !== 'string' || text.length > 65536) throw new TypeError('Invalid terminal output')
+  return new Promise((resolve, reject) => {
+    session.output.write(text, error => error ? reject(error) : resolve(null))
+  })
+}
+
+function createSession (input, output, { release, maxQueuedKeys }) {
+  const keys = new PassThrough()
+  const state = { queue: [], pending: null, error: null, closed: false, maxQueuedKeys }
+  const wasRaw = Boolean(input.isRaw)
+  const wasFlowing = input.readableFlowing === true
+  const onData = chunk => keys.write(chunk)
+  const onError = error => fail(state, error)
+  const onEnd = () => fail(state, Object.assign(new Error('Terminal input closed'), { code: 'EINTR' }))
+  emitKeypressEvents(keys)
+  keys.on('keypress', (character, key) => receiveKey(state, decodeKey(character, key)))
+  input.setRawMode(true)
+  input.on('data', onData).on('error', onError).on('end', onEnd)
+  output.on('error', onError)
+  input.resume()
+  return {
+    kind: 'terminal', output,
+    read: signal => readKey(state, signal),
+    async close () {
+      if (state.closed) return
+      state.closed = true
+      fail(state, new Error('Terminal session closed'))
+      input.off('data', onData).off('error', onError).off('end', onEnd)
+      keys.destroy()
+      try {
+        try {
+          input.setRawMode(wasRaw)
+        } finally {
+          if (!wasFlowing) input.pause()
+          release()
+        }
+        await writeTerminal({ output }, '\x1b[?25h')
+      } finally {
+        output.off('error', onError)
+      }
+    },
+  }
+}
+
+function readKey (state, signal) {
+  signal?.throwIfAborted()
+  if (state.error) return Promise.reject(state.error)
+  if (state.pending) throw new Error('A terminal key read is already pending')
+  if (state.queue.length) return Promise.resolve(state.queue.shift())
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      state.pending = null
+      reject(signal.reason)
+    }
+    state.pending = {
+      resolve: key => { signal?.removeEventListener('abort', abort); resolve(key) },
+      reject: error => { signal?.removeEventListener('abort', abort); reject(error) },
+    }
+    signal?.addEventListener('abort', abort, { once: true })
+  })
+}
+
+function receiveKey (state, key) {
+  if (state.closed || state.error) return
+  if (state.pending) {
+    const pending = state.pending
+    state.pending = null
+    pending.resolve(key)
+  } else if (state.queue.length < state.maxQueuedKeys) state.queue.push(key)
+  else fail(state, new Error(`Terminal input queue exceeded ${state.maxQueuedKeys} keys`))
+}
+
+function fail (state, error) {
+  state.error ??= error
+  state.queue.length = 0
+  state.pending?.reject(state.error)
+  state.pending = null
+}
+
+function decodeKey (character, key) {
+  if (key.ctrl && key.name === 'c') return { name: 'ctrl-c' }
+  if (key.ctrl && key.name === 'd') return { name: 'eof' }
+  if (['escape', 'backspace', 'delete', 'left', 'right', 'home', 'end'].includes(key.name)) return { name: key.name }
+  if (key.name === 'tab') return { name: key.shift ? 'backtab' : 'tab' }
+  if (['return', 'enter'].includes(key.name)) return { name: 'enter' }
+  if (['up', 'down'].includes(key.name)) return { name: key.name }
+  return { name: 'other', ...(!key.ctrl && !key.meta && character ? { character } : {}) }
+}
+
+function selectOutput () {
+  return process.stdout.isTTY ? process.stdout : process.stderr
+}

package/dist/wasm/host/terminal.mjs

@@ -0,0 +1,61 @@
+import { createInterface } from 'node:readline'
+
+import { claimTerminalInput } from './terminal-input.mjs'
+
+export async function prompt (options, { signal, input = process.stdin, output = process.stderr } = {}) {
+  if (typeof options.message !== 'string') throw new TypeError('Terminal prompt message must be a string')
+  signal?.throwIfAborted()
+  const release = claimTerminalInput(input)
+  let terminal
+  let abort
+  let keypress
+  try {
+    terminal = createInterface({ input, output, terminal: Boolean(input.isTTY && output.isTTY) })
+    return await new Promise((resolve, reject) => {
+      abort = () => reject(signal.reason)
+      signal?.addEventListener('abort', abort, { once: true })
+      terminal.once('SIGINT', () => resolve({ cancelled: true }))
+      keypress = (_text, key) => {
+        if (options.cancelOnEscape && key?.name === 'escape') resolve({ cancelled: true })
+      }
+      input.on('keypress', keypress)
+      terminal.once('close', () => resolve({ value: null }))
+      terminal.once('error', reject)
+      terminal.question(`${options.message}: `, value => resolve({ value }))
+    })
+  } finally {
+    signal?.removeEventListener('abort', abort)
+    if (keypress) input.off('keypress', keypress)
+    terminal?.close()
+    release()
+  }
+}
+
+export async function confirm (options, context = {}) {
+  const input = context.input ?? process.stdin
+  const output = context.output ?? process.stderr
+  if (!input.isTTY || !output.isTTY) throw Object.assign(new Error('Confirmation requires an interactive terminal'), { code: 'ENOTTY' })
+  if (options.default != null && typeof options.default !== 'boolean') throw new TypeError('Confirmation default must be a boolean')
+  const suffix = options.default == null ? '(y/n)' : options.default ? '(Y/n)' : '(y/N)'
+  while (true) {
+    // eslint-disable-next-line no-await-in-loop -- each answer determines whether another prompt is needed
+    const answer = await prompt({ message: `${options.message} ${suffix}`, cancelOnEscape: true }, { ...context, input, output })
+    if (answer.cancelled || answer.value == null) throw Object.assign(new Error('Confirmation cancelled'), { code: 'EINTR' })
+    const value = answer.value.trim().toLowerCase()
+    if (value === 'y' || value === 'yes') return true
+    if (value === 'n' || value === 'no') return false
+    if (value === '' && options.default != null) return options.default
+  }
+}
+
+export async function input (options, context = {}) {
+  if (!(context.input ?? process.stdin).isTTY || !(context.output ?? process.stderr).isTTY) {
+    throw Object.assign(new Error('Input requires an interactive terminal'), { code: 'ENOTTY' })
+  }
+  while (true) {
+    // eslint-disable-next-line no-await-in-loop -- empty input must be retried when the caller requires a value
+    const answer = await prompt({ message: options.message, cancelOnEscape: true }, context)
+    if (answer.cancelled || answer.value == null) throw Object.assign(new Error('Input cancelled'), { code: 'EINTR' })
+    if (options.allowEmpty || answer.value !== '') return answer.value
+  }
+}

package/dist/wasm/host/thread-spawn.mjs

@@ -0,0 +1,21 @@
+import { waitForReply } from './wait-for-reply.mjs'
+
+// Keep the upstream supervisor's spawn protocol while making the child wait interruptible.
+export function createThreadSpawn (memory, postMessage, options) {
+  return (startArg, errorOrTid) => {
+    const ownsResult = errorOrTid === undefined
+    const exports = options.instance().exports
+    if (ownsResult) errorOrTid = exports.malloc(8) >>> 0
+    if (ownsResult && !errorOrTid) return -48
+    const result = new Int32Array(memory.buffer, errorOrTid, 2)
+    Atomics.store(result, 0, 0)
+    Atomics.store(result, 1, 0)
+    postMessage({ __emnapi__: { type: 'spawn-thread', payload: { startArg, errorOrTid } } })
+    waitForReply(result, 1, options.checkCancelled)
+    const failed = Atomics.load(result, 0)
+    const thread = Atomics.load(result, 1)
+    if (!ownsResult) return failed
+    exports.free(errorOrTid)
+    return failed ? -thread : thread
+  }
+}

package/dist/wasm/host/upload.mjs

@@ -0,0 +1,21 @@
+export function createUpload (resources) {
+  let controller
+  const stream = new TransformStream({ start (value) { controller = value } }, { highWaterMark: 1 }, { highWaterMark: 1 })
+  const writer = stream.writable.getWriter()
+  return { handle: resources.add({
+    kind: 'upload',
+    readable: stream.readable,
+    writer,
+    close: () => controller.error(new Error('HTTP upload cancelled')),
+  }) }
+}
+
+export async function writeUpload (upload, bytes) {
+  if (Array.isArray(bytes) && bytes.every(byte => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
+    bytes = Uint8Array.from(bytes)
+  }
+  if (!(bytes instanceof Uint8Array) || bytes.length > 65536) {
+    throw new TypeError('HTTP upload chunks must contain at most 65536 bytes')
+  }
+  await upload.writer.write(bytes)
+}

package/dist/wasm/host/wait-for-reply.mjs

@@ -0,0 +1,7 @@
+// WebContainers cannot interrupt a worker parked in an indefinite Atomics.wait.
+export function waitForReply (state, index, checkCancelled) {
+  while (Atomics.load(state, index) === 0) {
+    checkCancelled?.()
+    Atomics.wait(state, index, 0, 100)
+  }
+}

package/dist/wasm/host/wasi-errno.mjs

@@ -0,0 +1,81 @@
+// WASI preview1 errno numbers, shared by filesystem extensions and syscall RPC.
+export const errno = {
+  E2BIG: 1,
+  EACCES: 2,
+  EADDRINUSE: 3,
+  EADDRNOTAVAIL: 4,
+  EAFNOSUPPORT: 5,
+  EAGAIN: 6,
+  EALREADY: 7,
+  EBADF: 8,
+  EBADMSG: 9,
+  EBUSY: 10,
+  ECANCELED: 11,
+  ECHILD: 12,
+  ECONNABORTED: 13,
+  ECONNREFUSED: 14,
+  ECONNRESET: 15,
+  EDEADLK: 16,
+  EDESTADDRREQ: 17,
+  EDOM: 18,
+  EDQUOT: 19,
+  EEXIST: 20,
+  EFAULT: 21,
+  EFBIG: 22,
+  EHOSTUNREACH: 23,
+  EIDRM: 24,
+  EILSEQ: 25,
+  EINPROGRESS: 26,
+  EINTR: 27,
+  EINVAL: 28,
+  EIO: 29,
+  EISCONN: 30,
+  EISDIR: 31,
+  ELOOP: 32,
+  EMFILE: 33,
+  EMLINK: 34,
+  EMSGSIZE: 35,
+  EMULTIHOP: 36,
+  ENAMETOOLONG: 37,
+  ENETDOWN: 38,
+  ENETRESET: 39,
+  ENETUNREACH: 40,
+  ENFILE: 41,
+  ENOBUFS: 42,
+  ENODEV: 43,
+  ENOENT: 44,
+  ENOEXEC: 45,
+  ENOLCK: 46,
+  ENOLINK: 47,
+  ENOMEM: 48,
+  ENOMSG: 49,
+  ENOPROTOOPT: 50,
+  ENOSPC: 51,
+  ENOSYS: 52,
+  ENOTCONN: 53,
+  ENOTDIR: 54,
+  ENOTEMPTY: 55,
+  ENOTRECOVERABLE: 56,
+  ENOTSOCK: 57,
+  ENOTSUP: 58,
+  ENOTTY: 59,
+  ENXIO: 60,
+  EOVERFLOW: 61,
+  EOWNERDEAD: 62,
+  EPERM: 63,
+  EPIPE: 64,
+  EPROTO: 65,
+  EPROTONOSUPPORT: 66,
+  EPROTOTYPE: 67,
+  ERANGE: 68,
+  EROFS: 69,
+  ESPIPE: 70,
+  ESRCH: 71,
+  ESTALE: 72,
+  ETIMEDOUT: 73,
+  ETXTBSY: 74,
+  EXDEV: 75,
+  ENOTCAPABLE: 76,
+  EOPNOTSUPP: 58,
+  EWOULDBLOCK: 6,
+}

package/dist/wasm/host/wasi-imports.mjs

@@ -0,0 +1,58 @@
+import { waitForReply } from './wait-for-reply.mjs'
+
+import { errno } from './wasi-errno.mjs'
+
+const { WebAssembly } = globalThis
+
+export class GuestExit extends Error {
+  constructor (code) {
+    super(`WASI guest exited with status ${code}`)
+    this.code = code
+  }
+}
+
+export function createWasiImports (module, postMessage, namespace = 'wasi_snapshot_preview1', checkCancelled) {
+  const buffer = new SharedArrayBuffer(8)
+  const state = new Int32Array(buffer)
+  return Object.fromEntries(WebAssembly.Module.imports(module)
+    .filter(entry => entry.module === namespace)
+    .map(({ name }) => [name, (...args) => {
+      if (namespace === 'wasi_snapshot_preview1' && name === 'proc_exit') {
+        postMessage({ pnpmMainExit: args[0] })
+        throw new GuestExit(args[0])
+      }
+      Atomics.store(state, 0, 0)
+      postMessage({ pnpmWasiRpc: { namespace, name, args, buffer } })
+      waitForReply(state, 0, checkCancelled)
+      return Atomics.load(state, 1)
+    }]))
+}
+
+export function attachWasi (worker, imports) {
+  worker.on('message', message => {
+    if (!message.pnpmWasiRpc) return
+    const { namespace, name, args, buffer } = message.pnpmWasiRpc
+    const state = new Int32Array(buffer)
+    Atomics.store(state, 1, 29)
+    function complete (result, error) {
+      try {
+        if (!error) Atomics.store(state, 1, result)
+        else {
+          const code = namespace === 'wasi_snapshot_preview1' && errno[error?.code]
+          if (typeof code === 'number') Atomics.store(state, 1, code)
+          else worker.emit('error', error)
+        }
+      } finally {
+        Atomics.store(state, 0, 1)
+        Atomics.notify(state, 0)
+      }
+    }
+    try {
+      const result = imports[namespace][name](...args)
+      if (typeof result?.then === 'function') result.then(value => complete(value), error => complete(undefined, error))
+      else complete(result)
+    } catch (error) {
+      complete(undefined, error)
+    }
+  })
+}

package/dist/wasm/node_modules/.bin/js-yaml

@@ -0,0 +1,91 @@
+#!/bin/sh
+# Resolve $0 through symlinks so basedir is the shim's real directory.
+# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim.
+#
+# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed,
+# uname, and printf go through `command -p`, which searches the system default
+# path instead. A dependency's bin cannot stand in for one of them and take over
+# the shim before it reaches its target. Directories come from `${link%/*}`,
+# which needs no helper at all.
+#
+# Where no default path is compiled in, as on Nix, `command -p` searches PATH
+# instead, so the helpers run with node_modules and relative entries dropped from
+# PATH.
+caller_path_set=${PATH+set}
+caller_path=${PATH-}
+helper_path=
+rest=$caller_path:
+while [ -n "$rest" ]; do
+  dir=${rest%%:*}
+  rest=${rest#*:}
+  case "$dir" in
+    */node_modules/*|*/node_modules) ;;
+    /*) helper_path=${helper_path:+$helper_path:}$dir ;;
+  esac
+done
+# An empty PATH searches the current directory.
+PATH=${helper_path:-/}
+link="$0"
+# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup
+# and stands for a file in the current directory.
+case "$link" in
+  */*|*\\*) ;;
+  *) link="./$link" ;;
+esac
+hops=0
+while [ -L "$link" ] && [ "$hops" -lt 40 ]; do
+  hops=$((hops+1))
+  target=$(command -p readlink "$link")
+  case "$target" in
+    /*) link="$target" ;;
+    *)  link="${link%/*}/$target" ;;
+  esac
+done
+basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g')
+basedir="${basedir%/*}"
+basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $?
+basedir="$basedir_abs"
+basedir_win="$basedir"
+exe=""
+msys=""
+
+case `command -p uname -a` in
+  *CYGWIN*|*MINGW*|*MSYS*)
+    if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then
+      basedir_win="$converted"
+    elif command -v cygpath > /dev/null 2>&1; then
+      basedir_win=`cygpath -w "$basedir"`
+    fi
+    exe=".exe"
+    msys="true"
+  ;;
+  *WSL2*)
+    if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then
+      basedir_win="$converted"
+      exe=".exe"
+    elif command -v wslpath > /dev/null 2>&1; then
+      basedir_win="$(wslpath -w "$basedir" 2> /dev/null)"
+      if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then
+        basedir_win="$basedir"
+      else
+        exe=".exe"
+      fi
+    fi
+  ;;
+esac
+if [ -n "$caller_path_set" ]; then PATH=$caller_path; else unset PATH; fi
+
+if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then
+  exec "$basedir/node.exe"  "$basedir_win/../js-yaml/bin/js-yaml.js" "$@"
+elif [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir_abs/../js-yaml/bin/js-yaml.js" "$@"
+elif [ -n "$msys" ] && command -v node >/dev/null 2>&1; then
+  exec node  "$basedir_win/../js-yaml/bin/js-yaml.js" "$@"
+elif command -v node >/dev/null 2>&1; then
+  exec node  "$basedir_abs/../js-yaml/bin/js-yaml.js" "$@"
+elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then
+  exec node.exe  "$basedir_win/../js-yaml/bin/js-yaml.js" "$@"
+else
+  exec node  "$basedir_abs/../js-yaml/bin/js-yaml.js" "$@"
+fi
+# cmd-shim-target=../js-yaml/bin/js-yaml.js

package/dist/wasm/node_modules/.bin/node-which

@@ -0,0 +1,91 @@
+#!/bin/sh
+# Resolve $0 through symlinks so basedir is the shim's real directory.
+# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim.
+#
+# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed,
+# uname, and printf go through `command -p`, which searches the system default
+# path instead. A dependency's bin cannot stand in for one of them and take over
+# the shim before it reaches its target. Directories come from `${link%/*}`,
+# which needs no helper at all.
+#
+# Where no default path is compiled in, as on Nix, `command -p` searches PATH
+# instead, so the helpers run with node_modules and relative entries dropped from
+# PATH.
+caller_path_set=${PATH+set}
+caller_path=${PATH-}
+helper_path=
+rest=$caller_path:
+while [ -n "$rest" ]; do
+  dir=${rest%%:*}
+  rest=${rest#*:}
+  case "$dir" in
+    */node_modules/*|*/node_modules) ;;
+    /*) helper_path=${helper_path:+$helper_path:}$dir ;;
+  esac
+done
+# An empty PATH searches the current directory.
+PATH=${helper_path:-/}
+link="$0"
+# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup
+# and stands for a file in the current directory.
+case "$link" in
+  */*|*\\*) ;;
+  *) link="./$link" ;;
+esac
+hops=0
+while [ -L "$link" ] && [ "$hops" -lt 40 ]; do
+  hops=$((hops+1))
+  target=$(command -p readlink "$link")
+  case "$target" in
+    /*) link="$target" ;;
+    *)  link="${link%/*}/$target" ;;
+  esac
+done
+basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g')
+basedir="${basedir%/*}"
+basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $?
+basedir="$basedir_abs"
+basedir_win="$basedir"
+exe=""
+msys=""
+
+case `command -p uname -a` in
+  *CYGWIN*|*MINGW*|*MSYS*)
+    if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then
+      basedir_win="$converted"
+    elif command -v cygpath > /dev/null 2>&1; then
+      basedir_win=`cygpath -w "$basedir"`
+    fi
+    exe=".exe"
+    msys="true"
+  ;;
+  *WSL2*)
+    if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then
+      basedir_win="$converted"
+      exe=".exe"
+    elif command -v wslpath > /dev/null 2>&1; then
+      basedir_win="$(wslpath -w "$basedir" 2> /dev/null)"
+      if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then
+        basedir_win="$basedir"
+      else
+        exe=".exe"
+      fi
+    fi
+  ;;
+esac
+if [ -n "$caller_path_set" ]; then PATH=$caller_path; else unset PATH; fi
+
+if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then
+  exec "$basedir/node.exe"  "$basedir_win/../which/bin/node-which" "$@"
+elif [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir_abs/../which/bin/node-which" "$@"
+elif [ -n "$msys" ] && command -v node >/dev/null 2>&1; then
+  exec node  "$basedir_win/../which/bin/node-which" "$@"
+elif command -v node >/dev/null 2>&1; then
+  exec node  "$basedir_abs/../which/bin/node-which" "$@"
+elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then
+  exec node.exe  "$basedir_win/../which/bin/node-which" "$@"
+else
+  exec node  "$basedir_abs/../which/bin/node-which" "$@"
+fi
+# cmd-shim-target=../which/bin/node-which

package/dist/wasm/node_modules/.bin/shell

@@ -0,0 +1,91 @@
+#!/bin/sh
+# Resolve $0 through symlinks so basedir is the shim's real directory.
+# Cap hops at the kernel's ELOOP limit so a cycle cannot hang the shim.
+#
+# A shim runs with node_modules/.bin at the front of PATH, so readlink, sed,
+# uname, and printf go through `command -p`, which searches the system default
+# path instead. A dependency's bin cannot stand in for one of them and take over
+# the shim before it reaches its target. Directories come from `${link%/*}`,
+# which needs no helper at all.
+#
+# Where no default path is compiled in, as on Nix, `command -p` searches PATH
+# instead, so the helpers run with node_modules and relative entries dropped from
+# PATH.
+caller_path_set=${PATH+set}
+caller_path=${PATH-}
+helper_path=
+rest=$caller_path:
+while [ -n "$rest" ]; do
+  dir=${rest%%:*}
+  rest=${rest#*:}
+  case "$dir" in
+    */node_modules/*|*/node_modules) ;;
+    /*) helper_path=${helper_path:+$helper_path:}$dir ;;
+  esac
+done
+# An empty PATH searches the current directory.
+PATH=${helper_path:-/}
+link="$0"
+# `${link%/*}` needs a separator to strip. A bare name came from a PATH lookup
+# and stands for a file in the current directory.
+case "$link" in
+  */*|*\\*) ;;
+  *) link="./$link" ;;
+esac
+hops=0
+while [ -L "$link" ] && [ "$hops" -lt 40 ]; do
+  hops=$((hops+1))
+  target=$(command -p readlink "$link")
+  case "$target" in
+    /*) link="$target" ;;
+    *)  link="${link%/*}/$target" ;;
+  esac
+done
+basedir=$(command -p printf '%s\n' "$link" | command -p sed -e 's,\\,/,g')
+basedir="${basedir%/*}"
+basedir_abs=$(CDPATH= cd -P -- "$basedir" && pwd -P) || exit $?
+basedir="$basedir_abs"
+basedir_win="$basedir"
+exe=""
+msys=""
+
+case `command -p uname -a` in
+  *CYGWIN*|*MINGW*|*MSYS*)
+    if converted=$(command -p cygpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then
+      basedir_win="$converted"
+    elif command -v cygpath > /dev/null 2>&1; then
+      basedir_win=`cygpath -w "$basedir"`
+    fi
+    exe=".exe"
+    msys="true"
+  ;;
+  *WSL2*)
+    if converted=$(command -p wslpath -w "$basedir" 2>/dev/null) && [ -n "$converted" ]; then
+      basedir_win="$converted"
+      exe=".exe"
+    elif command -v wslpath > /dev/null 2>&1; then
+      basedir_win="$(wslpath -w "$basedir" 2> /dev/null)"
+      if [ $? -ne 0 ] || [ -z "$basedir_win" ]; then
+        basedir_win="$basedir"
+      else
+        exe=".exe"
+      fi
+    fi
+  ;;
+esac
+if [ -n "$caller_path_set" ]; then PATH=$caller_path; else unset PATH; fi
+
+if [ -n "$exe" ] && [ -x "$basedir/node.exe" ]; then
+  exec "$basedir/node.exe"  "$basedir_win/../@yarnpkg/shell/lib/cli.js" "$@"
+elif [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir_abs/../@yarnpkg/shell/lib/cli.js" "$@"
+elif [ -n "$msys" ] && command -v node >/dev/null 2>&1; then
+  exec node  "$basedir_win/../@yarnpkg/shell/lib/cli.js" "$@"
+elif command -v node >/dev/null 2>&1; then
+  exec node  "$basedir_abs/../@yarnpkg/shell/lib/cli.js" "$@"
+elif [ -n "$exe" ] && command -v node.exe >/dev/null 2>&1; then
+  exec node.exe  "$basedir_win/../@yarnpkg/shell/lib/cli.js" "$@"
+else
+  exec node  "$basedir_abs/../@yarnpkg/shell/lib/cli.js" "$@"
+fi
+# cmd-shim-target=../@yarnpkg/shell/lib/cli.js