test.js.snap

// Jest Snapshot v1, https://goo.gl/fbAQLP

exports[`custom node executable env.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

\\"/.pnpm/nodejs/16.0.0/node\\"  \\"$basedir/src.env\\" \\"$@\\"
exit $?
"
`;

exports[`custom node executable env.shim.cmd 1`] = `
"@SETLOCAL
@\\"/.pnpm/nodejs/16.0.0/node\\"  \\"%~dp0\\\\src.env\\" %*
"
`;

exports[`custom node executable env.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
}
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
  $input | & \\"/.pnpm/nodejs/16.0.0/node\\"  \\"$basedir/src.env\\" $args
} else {
  & \\"/.pnpm/nodejs/16.0.0/node\\"  \\"$basedir/src.env\\" $args
}
exit $LASTEXITCODE
"
`;

exports[`env shebang env.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

if [ -x \\"$basedir/node\\" ]; then
  exec \\"$basedir/node\\"  \\"$basedir/src.env\\" \\"$@\\"
else
  exec node  \\"$basedir/src.env\\" \\"$@\\"
fi
"
`;

exports[`env shebang env.shim.cmd 1`] = `
"@SETLOCAL
@IF EXIST \\"%~dp0\\\\node.exe\\" (
  \\"%~dp0\\\\node.exe\\"  \\"%~dp0\\\\src.env\\" %*
) ELSE (
  @SET PATHEXT=%PATHEXT:;.JS;=;%
  node  \\"%~dp0\\\\src.env\\" %*
)
"
`;

exports[`env shebang env.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
}
$ret=0
if (Test-Path \\"$basedir/node$exe\\") {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"$basedir/node$exe\\"  \\"$basedir/src.env\\" $args
  } else {
    & \\"$basedir/node$exe\\"  \\"$basedir/src.env\\" $args
  }
  $ret=$LASTEXITCODE
} else {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"node$exe\\"  \\"$basedir/src.env\\" $args
  } else {
    & \\"node$exe\\"  \\"$basedir/src.env\\" $args
  }
  $ret=$LASTEXITCODE
}
exit $ret
"
`;

exports[`env shebang with NODE_PATH env.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

if [ -z \\"$NODE_PATH\\" ]; then
  export NODE_PATH=\\"/john/src/node_modules:/bin/node/node_modules\\"
else
  export NODE_PATH=\\"$NODE_PATH:/john/src/node_modules:/bin/node/node_modules\\"
fi
if [ -x \\"$basedir/node\\" ]; then
  exec \\"$basedir/node\\"  \\"$basedir/src.env\\" \\"$@\\"
else
  exec node  \\"$basedir/src.env\\" \\"$@\\"
fi
"
`;

exports[`env shebang with NODE_PATH env.shim.cmd 1`] = `
"@SETLOCAL
@IF NOT DEFINED NODE_PATH (
  @SET \\"NODE_PATH=\\\\john\\\\src\\\\node_modules;\\\\bin\\\\node\\\\node_modules\\"
) ELSE (
  @SET \\"NODE_PATH=%NODE_PATH%;\\\\john\\\\src\\\\node_modules;\\\\bin\\\\node\\\\node_modules\\"
)
@IF EXIST \\"%~dp0\\\\node.exe\\" (
  \\"%~dp0\\\\node.exe\\"  \\"%~dp0\\\\src.env\\" %*
) ELSE (
  @SET PATHEXT=%PATHEXT:;.JS;=;%
  node  \\"%~dp0\\\\src.env\\" %*
)
"
`;

exports[`env shebang with NODE_PATH env.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
$pathsep=\\":\\"
$env_node_path=$env:NODE_PATH
$new_node_path=\\"\\\\john\\\\src\\\\node_modules;\\\\bin\\\\node\\\\node_modules\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
  $pathsep=\\";\\"
} else {
  $new_node_path=\\"/john/src/node_modules:/bin/node/node_modules\\"
}
if ([string]::IsNullOrEmpty($env_node_path)) {
  $env:NODE_PATH=$new_node_path
} else {
  $env:NODE_PATH=\\"$env_node_path$pathsep$new_node_path\\"
}

$ret=0
if (Test-Path \\"$basedir/node$exe\\") {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"$basedir/node$exe\\"  \\"$basedir/src.env\\" $args
  } else {
    & \\"$basedir/node$exe\\"  \\"$basedir/src.env\\" $args
  }
  $ret=$LASTEXITCODE
} else {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"node$exe\\"  \\"$basedir/src.env\\" $args
  } else {
    & \\"node$exe\\"  \\"$basedir/src.env\\" $args
  }
  $ret=$LASTEXITCODE
}
$env:NODE_PATH=$env_node_path
exit $ret
"
`;

exports[`env shebang with PATH extending env.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

export PATH=\\"/add-to-path:$PATH\\"
if [ -x \\"$basedir/node\\" ]; then
  exec \\"$basedir/node\\"  \\"$basedir/src.env\\" \\"$@\\"
else
  exec node  \\"$basedir/src.env\\" \\"$@\\"
fi
"
`;

exports[`env shebang with PATH extending env.shim.cmd 1`] = `
"@SETLOCAL
@SET \\"PATH=\\\\add-to-path:%PATH%\\"
@IF EXIST \\"%~dp0\\\\node.exe\\" (
  \\"%~dp0\\\\node.exe\\"  \\"%~dp0\\\\src.env\\" %*
) ELSE (
  @SET PATHEXT=%PATHEXT:;.JS;=;%
  node  \\"%~dp0\\\\src.env\\" %*
)
"
`;

exports[`env shebang with PATH extending env.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
$pathsep=\\":\\"
$env_path=$env:PATH
$prepend_path=\\"\\\\add-to-path\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
  $pathsep=\\";\\"
} else {
  $prepend_path=\\"/add-to-path\\"
}

$env:PATH=\\"$prepend_path$pathsep$env:PATH\\"

$ret=0
if (Test-Path \\"$basedir/node$exe\\") {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"$basedir/node$exe\\"  \\"$basedir/src.env\\" $args
  } else {
    & \\"$basedir/node$exe\\"  \\"$basedir/src.env\\" $args
  }
  $ret=$LASTEXITCODE
} else {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"node$exe\\"  \\"$basedir/src.env\\" $args
  } else {
    & \\"node$exe\\"  \\"$basedir/src.env\\" $args
  }
  $ret=$LASTEXITCODE
}
$env:PATH=$env_path
exit $ret
"
`;

exports[`env shebang with args env.args.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

if [ -x \\"$basedir/node\\" ]; then
  exec \\"$basedir/node\\"  --expose_gc \\"$basedir/src.env.args\\" \\"$@\\"
else
  exec node  --expose_gc \\"$basedir/src.env.args\\" \\"$@\\"
fi
"
`;

exports[`env shebang with args env.args.shim.cmd 1`] = `
"@SETLOCAL
@IF EXIST \\"%~dp0\\\\node.exe\\" (
  \\"%~dp0\\\\node.exe\\"  --expose_gc \\"%~dp0\\\\src.env.args\\" %*
) ELSE (
  @SET PATHEXT=%PATHEXT:;.JS;=;%
  node  --expose_gc \\"%~dp0\\\\src.env.args\\" %*
)
"
`;

exports[`env shebang with args env.args.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
}
$ret=0
if (Test-Path \\"$basedir/node$exe\\") {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"$basedir/node$exe\\"  --expose_gc \\"$basedir/src.env.args\\" $args
  } else {
    & \\"$basedir/node$exe\\"  --expose_gc \\"$basedir/src.env.args\\" $args
  }
  $ret=$LASTEXITCODE
} else {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"node$exe\\"  --expose_gc \\"$basedir/src.env.args\\" $args
  } else {
    & \\"node$exe\\"  --expose_gc \\"$basedir/src.env.args\\" $args
  }
  $ret=$LASTEXITCODE
}
exit $ret
"
`;

exports[`env shebang with default args env.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

if [ -x \\"$basedir/node\\" ]; then
  exec \\"$basedir/node\\" --preserve-symlinks \\"$basedir/src.env\\" \\"$@\\"
else
  exec node --preserve-symlinks \\"$basedir/src.env\\" \\"$@\\"
fi
"
`;

exports[`env shebang with default args env.shim.cmd 1`] = `
"@SETLOCAL
@IF EXIST \\"%~dp0\\\\node.exe\\" (
  \\"%~dp0\\\\node.exe\\" --preserve-symlinks \\"%~dp0\\\\src.env\\" %*
) ELSE (
  @SET PATHEXT=%PATHEXT:;.JS;=;%
  node --preserve-symlinks \\"%~dp0\\\\src.env\\" %*
)
"
`;

exports[`env shebang with default args env.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
}
$ret=0
if (Test-Path \\"$basedir/node$exe\\") {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"$basedir/node$exe\\" --preserve-symlinks \\"$basedir/src.env\\" $args
  } else {
    & \\"$basedir/node$exe\\" --preserve-symlinks \\"$basedir/src.env\\" $args
  }
  $ret=$LASTEXITCODE
} else {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"node$exe\\" --preserve-symlinks \\"$basedir/src.env\\" $args
  } else {
    & \\"node$exe\\" --preserve-symlinks \\"$basedir/src.env\\" $args
  }
  $ret=$LASTEXITCODE
}
exit $ret
"
`;

exports[`env shebang with no NODE_PATH env.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

if [ -x \\"$basedir/node\\" ]; then
  exec \\"$basedir/node\\"  \\"$basedir/src.env\\" \\"$@\\"
else
  exec node  \\"$basedir/src.env\\" \\"$@\\"
fi
"
`;

exports[`env shebang with no NODE_PATH env.shim.cmd 1`] = `
"@SETLOCAL
@IF EXIST \\"%~dp0\\\\node.exe\\" (
  \\"%~dp0\\\\node.exe\\"  \\"%~dp0\\\\src.env\\" %*
) ELSE (
  @SET PATHEXT=%PATHEXT:;.JS;=;%
  node  \\"%~dp0\\\\src.env\\" %*
)
"
`;

exports[`env shebang with no NODE_PATH env.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
}
$ret=0
if (Test-Path \\"$basedir/node$exe\\") {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"$basedir/node$exe\\"  \\"$basedir/src.env\\" $args
  } else {
    & \\"$basedir/node$exe\\"  \\"$basedir/src.env\\" $args
  }
  $ret=$LASTEXITCODE
} else {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"node$exe\\"  \\"$basedir/src.env\\" $args
  } else {
    & \\"node$exe\\"  \\"$basedir/src.env\\" $args
  }
  $ret=$LASTEXITCODE
}
exit $ret
"
`;

exports[`explicit shebang sh.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

if [ -x \\"$basedir//usr/bin/sh\\" ]; then
  exec \\"$basedir//usr/bin/sh\\"  \\"$basedir/src.sh\\" \\"$@\\"
else
  exec /usr/bin/sh  \\"$basedir/src.sh\\" \\"$@\\"
fi
"
`;

exports[`explicit shebang sh.shim.cmd 1`] = `
"@SETLOCAL
@IF EXIST \\"%~dp0\\\\/usr/bin/sh.exe\\" (
  \\"%~dp0\\\\/usr/bin/sh.exe\\"  \\"%~dp0\\\\src.sh\\" %*
) ELSE (
  @SET PATHEXT=%PATHEXT:;.JS;=;%
  /usr/bin/sh  \\"%~dp0\\\\src.sh\\" %*
)
"
`;

exports[`explicit shebang sh.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
}
$ret=0
if (Test-Path \\"$basedir//usr/bin/sh$exe\\") {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"$basedir//usr/bin/sh$exe\\"  \\"$basedir/src.sh\\" $args
  } else {
    & \\"$basedir//usr/bin/sh$exe\\"  \\"$basedir/src.sh\\" $args
  }
  $ret=$LASTEXITCODE
} else {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"/usr/bin/sh$exe\\"  \\"$basedir/src.sh\\" $args
  } else {
    & \\"/usr/bin/sh$exe\\"  \\"$basedir/src.sh\\" $args
  }
  $ret=$LASTEXITCODE
}
exit $ret
"
`;

exports[`explicit shebang with args sh.args.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

if [ -x \\"$basedir//usr/bin/sh\\" ]; then
  exec \\"$basedir//usr/bin/sh\\"  -x \\"$basedir/src.sh.args\\" \\"$@\\"
else
  exec /usr/bin/sh  -x \\"$basedir/src.sh.args\\" \\"$@\\"
fi
"
`;

exports[`explicit shebang with args sh.args.shim.cmd 1`] = `
"@SETLOCAL
@IF EXIST \\"%~dp0\\\\/usr/bin/sh.exe\\" (
  \\"%~dp0\\\\/usr/bin/sh.exe\\"  -x \\"%~dp0\\\\src.sh.args\\" %*
) ELSE (
  @SET PATHEXT=%PATHEXT:;.JS;=;%
  /usr/bin/sh  -x \\"%~dp0\\\\src.sh.args\\" %*
)
"
`;

exports[`explicit shebang with args sh.args.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
}
$ret=0
if (Test-Path \\"$basedir//usr/bin/sh$exe\\") {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"$basedir//usr/bin/sh$exe\\"  -x \\"$basedir/src.sh.args\\" $args
  } else {
    & \\"$basedir//usr/bin/sh$exe\\"  -x \\"$basedir/src.sh.args\\" $args
  }
  $ret=$LASTEXITCODE
} else {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"/usr/bin/sh$exe\\"  -x \\"$basedir/src.sh.args\\" $args
  } else {
    & \\"/usr/bin/sh$exe\\"  -x \\"$basedir/src.sh.args\\" $args
  }
  $ret=$LASTEXITCODE
}
exit $ret
"
`;

exports[`explicit shebang with args, linking to another drive on Windows sh.args.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

if [ -x \\"$basedir//usr/bin/sh\\" ]; then
  exec \\"$basedir//usr/bin/sh\\"  -x \\"J:/cmd-shim/fixtures/src.sh.args\\" \\"$@\\"
else
  exec /usr/bin/sh  -x \\"J:/cmd-shim/fixtures/src.sh.args\\" \\"$@\\"
fi
"
`;

exports[`explicit shebang with args, linking to another drive on Windows sh.args.shim.cmd 1`] = `
"@SETLOCAL
@IF EXIST \\"%~dp0\\\\/usr/bin/sh.exe\\" (
  \\"%~dp0\\\\/usr/bin/sh.exe\\"  -x \\"J:\\\\cmd-shim\\\\fixtures\\\\src.sh.args\\" %*
) ELSE (
  @SET PATHEXT=%PATHEXT:;.JS;=;%
  /usr/bin/sh  -x \\"J:\\\\cmd-shim\\\\fixtures\\\\src.sh.args\\" %*
)
"
`;

exports[`explicit shebang with args, linking to another drive on Windows sh.args.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
}
$ret=0
if (Test-Path \\"$basedir//usr/bin/sh$exe\\") {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"$basedir//usr/bin/sh$exe\\"  -x \\"J:/cmd-shim/fixtures/src.sh.args\\" $args
  } else {
    & \\"$basedir//usr/bin/sh$exe\\"  -x \\"J:/cmd-shim/fixtures/src.sh.args\\" $args
  }
  $ret=$LASTEXITCODE
} else {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"/usr/bin/sh$exe\\"  -x \\"J:/cmd-shim/fixtures/src.sh.args\\" $args
  } else {
    & \\"/usr/bin/sh$exe\\"  -x \\"J:/cmd-shim/fixtures/src.sh.args\\" $args
  }
  $ret=$LASTEXITCODE
}
exit $ret
"
`;

exports[`explicit shebang with prog args sh.args.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

if [ -x \\"$basedir//usr/bin/sh\\" ]; then
  exec \\"$basedir//usr/bin/sh\\"  -x \\"$basedir/src.sh.args\\" hello \\"$@\\"
else
  exec /usr/bin/sh  -x \\"$basedir/src.sh.args\\" hello \\"$@\\"
fi
"
`;

exports[`explicit shebang with prog args sh.args.shim.cmd 1`] = `
"@SETLOCAL
@IF EXIST \\"%~dp0\\\\/usr/bin/sh.exe\\" (
  \\"%~dp0\\\\/usr/bin/sh.exe\\"  -x \\"%~dp0\\\\src.sh.args\\" hello %*
) ELSE (
  @SET PATHEXT=%PATHEXT:;.JS;=;%
  /usr/bin/sh  -x \\"%~dp0\\\\src.sh.args\\" hello %*
)
"
`;

exports[`explicit shebang with prog args sh.args.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
}
$ret=0
if (Test-Path \\"$basedir//usr/bin/sh$exe\\") {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"$basedir//usr/bin/sh$exe\\"  -x \\"$basedir/src.sh.args\\" hello $args
  } else {
    & \\"$basedir//usr/bin/sh$exe\\"  -x \\"$basedir/src.sh.args\\" hello $args
  }
  $ret=$LASTEXITCODE
} else {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"/usr/bin/sh$exe\\"  -x \\"$basedir/src.sh.args\\" hello $args
  } else {
    & \\"/usr/bin/sh$exe\\"  -x \\"$basedir/src.sh.args\\" hello $args
  }
  $ret=$LASTEXITCODE
}
exit $ret
"
`;

exports[`no cmd file exe.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

\\"$basedir/src.exe\\"   \\"$@\\"
exit $?
"
`;

exports[`no cmd file exe.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
}
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
  $input | & \\"$basedir/src.exe\\"   $args
} else {
  & \\"$basedir/src.exe\\"   $args
}
exit $LASTEXITCODE
"
`;

exports[`no shebang exe.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

\\"$basedir/src.exe\\"   \\"$@\\"
exit $?
"
`;

exports[`no shebang exe.shim.cmd 1`] = `
"@SETLOCAL
@\\"%~dp0\\\\src.exe\\"   %*
"
`;

exports[`no shebang exe.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
}
# Support pipeline input
if ($MyInvocation.ExpectingInput) {
  $input | & \\"$basedir/src.exe\\"   $args
} else {
  & \\"$basedir/src.exe\\"   $args
}
exit $LASTEXITCODE
"
`;

exports[`shebang with -S from.env.S.shim 1`] = `
"#!/bin/sh
basedir=$(dirname \\"$(echo \\"$0\\" | sed -e 's,\\\\\\\\,/,g')\\")

case \`uname\` in
    *CYGWIN*) basedir=\`cygpath -w \\"$basedir\\"\`;;
esac

if [ -x \\"$basedir/node\\" ]; then
  exec \\"$basedir/node\\"  --expose_gc \\"$basedir/from.env.S\\" \\"$@\\"
else
  exec node  --expose_gc \\"$basedir/from.env.S\\" \\"$@\\"
fi
"
`;

exports[`shebang with -S from.env.S.shim.cmd 1`] = `
"@SETLOCAL
@IF EXIST \\"%~dp0\\\\node.exe\\" (
  \\"%~dp0\\\\node.exe\\"  --expose_gc \\"%~dp0\\\\from.env.S\\" %*
) ELSE (
  @SET PATHEXT=%PATHEXT:;.JS;=;%
  node  --expose_gc \\"%~dp0\\\\from.env.S\\" %*
)
"
`;

exports[`shebang with -S from.env.S.shim.ps1 1`] = `
"#!/usr/bin/env pwsh
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent

$exe=\\"\\"
if ($PSVersionTable.PSVersion -lt \\"6.0\\" -or $IsWindows) {
  # Fix case when both the Windows and Linux builds of Node
  # are installed in the same directory
  $exe=\\".exe\\"
}
$ret=0
if (Test-Path \\"$basedir/node$exe\\") {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"$basedir/node$exe\\"  --expose_gc \\"$basedir/from.env.S\\" $args
  } else {
    & \\"$basedir/node$exe\\"  --expose_gc \\"$basedir/from.env.S\\" $args
  }
  $ret=$LASTEXITCODE
} else {
  # Support pipeline input
  if ($MyInvocation.ExpectingInput) {
    $input | & \\"node$exe\\"  --expose_gc \\"$basedir/from.env.S\\" $args
  } else {
    & \\"node$exe\\"  --expose_gc \\"$basedir/from.env.S\\" $args
  }
  $ret=$LASTEXITCODE
}
exit $ret
"
`;