pnpm 12.9.0 → 12.9.1

package/dist/wasm/host/shell-runner.mjs

@@ -1,8 +0,0 @@
-import { execute } from '@yarnpkg/shell'
-
-try {
-  process.exitCode = await execute(process.argv[2], process.argv.slice(3))
-} catch (error) {
-  console.error(error.message)
-  process.exitCode = 1
-}

package/dist/wasm/host/shell.mjs

@@ -1,19 +0,0 @@
-import { fileURLToPath } from 'node:url'
-
-import { parseShell } from '@yarnpkg/parsers'
-import { globUtils } from '@yarnpkg/shell'
-
-import { spawnProcess } from './process.mjs'
-
-export function spawnShell (resources, options, configuration) {
-  try {
-    parseShell(options.script, globUtils)
-  } catch (error) {
-    throw Object.assign(new Error(error.message, { cause: error }), { code: 'ESHELLPARSE' })
-  }
-  return spawnProcess(resources, {
-    ...options,
-    program: process.execPath,
-    args: [fileURLToPath(new URL('./shell-runner.mjs', import.meta.url)), options.script, ...(options.args ?? [])],
-  }, configuration)
-}

package/dist/wasm/host/signals.mjs

@@ -1,49 +0,0 @@
-export function createSignals (source = process) {
-  const queued = []
-  const waiters = []
-  let handlers
-  let closed = false
-
-  function subscribe () {
-    if (handlers) return
-    handlers = ['SIGINT', 'SIGTERM'].map(signal => {
-      const listener = () => {
-        const value = { signal, number: signal === 'SIGINT' ? 2 : 15 }
-        const waiter = waiters.shift()
-        if (waiter) waiter.resolve(value)
-        else queued.push(value)
-      }
-      source.on(signal, listener)
-      return [signal, listener]
-    })
-  }
-
-  return {
-    next ({ signal } = {}) {
-      if (closed) return Promise.reject(new Error('Signal subscription is closed'))
-      signal?.throwIfAborted()
-      subscribe()
-      if (queued.length) return Promise.resolve(queued.shift())
-      return new Promise((resolve, reject) => {
-        const abort = () => {
-          const index = waiters.indexOf(waiter)
-          if (index !== -1) waiters.splice(index, 1)
-          waiter.reject(signal.reason)
-        }
-        const finish = callback => value => {
-          signal?.removeEventListener('abort', abort)
-          callback(value)
-        }
-        const waiter = { resolve: finish(resolve), reject: finish(reject) }
-        waiters.push(waiter)
-        signal?.addEventListener('abort', abort, { once: true })
-      })
-    },
-    close () {
-      closed = true
-      for (const [signal, listener] of handlers ?? []) source.off(signal, listener)
-      for (const waiter of waiters.splice(0)) waiter.reject(new Error('Signal subscription is closed'))
-      queued.length = 0
-    },
-  }
-}

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

@@ -1,7 +0,0 @@
-const activeInputs = new WeakSet()
-
-export function claimTerminalInput (input) {
-  if (activeInputs.has(input)) throw new Error('A terminal prompt is already active')
-  activeInputs.add(input)
-  return () => activeInputs.delete(input)
-}

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

@@ -1,32 +0,0 @@
-import { createResources } from './resources.mjs'
-import { openTerminal, writeTerminal } from './terminal-session.mjs'
-
-export async function password (options, context = {}) {
-  if (typeof options.message !== 'string') throw new TypeError('Password prompt message must be a string')
-  context.signal?.throwIfAborted()
-  const resources = createResources()
-  try {
-    const { handle } = await openTerminal(resources, { ...context, output: context.output ?? process.stderr, maxQueuedKeys: 65536 })
-    const session = resources.get(handle, 'terminal')
-    await writeTerminal(session, `${options.message}: `)
-    return await readPassword(session, options.allowEmpty, context.signal)
-  } finally {
-    await resources.closeAll()
-  }
-}
-
-async function readPassword (session, allowEmpty, signal) {
-  const characters = []
-  while (true) {
-    // eslint-disable-next-line no-await-in-loop -- input must be consumed in key order
-    const key = await session.read(signal)
-    if (['ctrl-c', 'escape', 'eof'].includes(key.name)) throw Object.assign(new Error('Password input cancelled'), { code: 'EINTR' })
-    if (key.name === 'enter' && (allowEmpty || characters.length)) {
-      await writeTerminal(session, '\n') // eslint-disable-line no-await-in-loop -- newline is emitted only after accepting the complete password
-      return characters.join('')
-    }
-    if (key.name === 'backspace' || key.name === 'delete') characters.pop()
-    else if (key.character && Array.from(key.character).every(character => character >= ' ' && character !== '\x7f')) characters.push(key.character)
-    if (characters.length > 65536) throw new Error('Password input exceeds the terminal limit')
-  }
-}

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

@@ -1,114 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,7 +0,0 @@
-// 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

@@ -1,81 +0,0 @@
-// 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

@@ -1,58 +0,0 @@
-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

@@ -1,91 +0,0 @@
-#!/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

@@ -1,91 +0,0 @@
-#!/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