diff --git a/.gitignore b/.gitignore
index 2833549fe5..f5ab48609c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -31,3 +31,6 @@ temp.dmi
node_modules/
package-lock.json
+
+# CBT Things
+.cache
diff --git a/_build_dependencies.sh b/_build_dependencies.sh
index 8b6659c3a9..a66b3a5a86 100644
--- a/_build_dependencies.sh
+++ b/_build_dependencies.sh
@@ -6,6 +6,6 @@ export NODE_VERSION=20
# Byond Major
export BYOND_MAJOR=515
# Byond Minor
-export BYOND_MINOR=1630
+export BYOND_MINOR=1637
# Macro Count
export MACRO_COUNT=4
diff --git a/build.cmd b/build.cmd
new file mode 100644
index 0000000000..dc791f60c9
--- /dev/null
+++ b/build.cmd
@@ -0,0 +1,2 @@
+@echo off
+call "%~dp0\tools\build\build.bat" --wait-on-error build %*
diff --git a/dependencies.sh b/dependencies.sh
new file mode 100644
index 0000000000..cba44327e5
--- /dev/null
+++ b/dependencies.sh
@@ -0,0 +1,34 @@
+#!/bin/sh
+
+#Project dependencies file
+#Final authority on what's required to fully build the project
+
+# byond version
+export BYOND_MAJOR=515
+export BYOND_MINOR=1637
+
+#rust_g git tag
+export RUST_G_VERSION=3.3.0
+
+#node version
+export NODE_VERSION_LTS=20.13.0
+# compatiblility mode MUST work with windows 7
+export NODE_VERSION_COMPAT=20.2.0
+
+# SpacemanDMM git tag
+export SPACEMAN_DMM_VERSION=suite-1.8
+
+# Python version for mapmerge and other tools
+export PYTHON_VERSION=3.9.0
+
+#dreamluau repo
+export DREAMLUAU_REPO="tgstation/dreamluau"
+
+#dreamluau git tag
+export DREAMLUAU_VERSION=0.1.2
+
+#hypnagogic repo
+export CUTTER_REPO=spacestation13/hypnagogic
+
+#hypnagogic git tag
+export CUTTER_VERSION=v4.0.0
diff --git a/tools/bootstrap/node b/tools/bootstrap/node
new file mode 100644
index 0000000000..10701bc39a
--- /dev/null
+++ b/tools/bootstrap/node
@@ -0,0 +1,73 @@
+#!/bin/sh
+# bootstrap/node
+#
+# Node-finding script for all `sh` environments, including Linux, MSYS2,
+# Git for Windows, and GitHub Desktop. Invokable from CLI or automation.
+#
+# If a node.exe installed by `node_.ps1` is present, it will be used.
+# Otherwise, this script requires a system `node` to be provided.
+set -e
+
+# Convenience variables
+Bootstrap="$(dirname "$0")"
+Cache="$Bootstrap/.cache"
+if [ "$TG_BOOTSTRAP_CACHE" ]; then
+ Cache="$TG_BOOTSTRAP_CACHE"
+fi
+OldPWD="$PWD"
+cd "$Bootstrap/../.."
+. ./dependencies.sh # sets NODE_VERSION_LTS
+cd "$OldPWD"
+NodeVersion="$NODE_VERSION_LTS"
+NodeFullVersion="node-v$NodeVersion-win-x64"
+NodeDir="$Cache/$NodeFullVersion"
+NodeExe="$NodeDir/node.exe"
+is_vendored="1"
+
+# If a bootstrapped Node is not present, search on $PATH.
+if [ "$(uname)" = "Linux" ] || [ ! -f "$NodeExe" ]; then
+ if [ "$TG_BOOTSTRAP_NODE_LINUX" ]; then
+ NodeFullVersion="node-v$NodeVersion-linux-x64"
+ NodeDir="$Cache/$NodeFullVersion/bin"
+ NodeExe="$NodeDir/node"
+
+ if [ ! -f "$NodeExe" ]; then
+ mkdir -p "$Cache"
+ Archive="$(realpath "$Cache/node-v$NodeVersion.tar.gz")"
+ curl "https://nodejs.org/download/release/v$NodeVersion/$NodeFullVersion.tar.gz" -o "$Archive"
+ (cd "$Cache" && tar xf "$Archive")
+ fi
+ elif command -v node >/dev/null 2>&1; then
+ NodeExe="node"
+ is_vendored="0"
+ else
+ echo
+ if command -v apt-get >/dev/null 2>&1; then
+ # Ubuntu advice
+ echo "Please install Node using your system's package manager:"
+ echo " sudo apt-get install nodejs"
+ elif uname | grep -q MSYS; then
+ # MSYS2 (not packaged) or Git for Windows advice
+ echo "Please run bootstrap/node.bat instead of bootstrap/node once"
+ echo "to install Node automatically, or install it from https://nodejs.org/"
+ elif command -v pacman >/dev/null 2>&1; then
+ # Arch advice
+ echo "Please install Node using your system's package manager:"
+ echo " sudo pacman -S nodejs"
+ else
+ # Generic advice
+ echo "Please install Node from https://nodejs.org/ or using your system's package manager."
+ fi
+ echo
+ exit 1
+ fi
+fi
+
+# Invoke Node with all command-line arguments
+if [ "$is_vendored" = "1" ]; then
+ PATH="$(readlink -f "$NodeDir"):$PATH"
+ echo "Using vendored Node $("$NodeExe" --version)"
+else
+ echo "Using system-wide Node $("$NodeExe" --version)"
+fi
+exec "$NodeExe" "$@"
diff --git a/tools/bootstrap/node.bat b/tools/bootstrap/node.bat
new file mode 100644
index 0000000000..a3fca88674
--- /dev/null
+++ b/tools/bootstrap/node.bat
@@ -0,0 +1,20 @@
+@echo off
+set NODE_SKIP_PLATFORM_CHECK=1
+call powershell -NoLogo -ExecutionPolicy Bypass -File "%~dp0\node_.ps1" Download-Node
+for /f "tokens=* USEBACKQ" %%s in (`
+ call powershell -NoLogo -ExecutionPolicy Bypass -File "%~dp0\node_.ps1" Get-Path
+`) do (
+ set "PATH=%%s;%PATH%"
+)
+where node.exe >nul 2>nul
+if %errorlevel% == 0 (
+ echo | set /p printed_str="Using vendored Node "
+ call node.exe --version
+ call node.exe %*
+ goto exit_with_last_error_level
+)
+echo "node.bat: Failed to bootstrap Node!"
+%COMSPEC% /c exit 1
+
+:exit_with_last_error_level
+if not %errorlevel% == 0 %COMSPEC% /c exit %errorlevel% >nul
diff --git a/tools/bootstrap/node_.ps1 b/tools/bootstrap/node_.ps1
new file mode 100644
index 0000000000..8e3c96517f
--- /dev/null
+++ b/tools/bootstrap/node_.ps1
@@ -0,0 +1,71 @@
+## bootstrap/node_.ps1
+## Downloads a Node version to a cache directory and invokes it.
+
+$ErrorActionPreference = "Stop"
+
+function Extract-Variable {
+ param([string] $Path, [string] $Key)
+ foreach ($Line in Get-Content $Path) {
+ if ($Line.StartsWith("export $Key=")) {
+ return $Line.Substring("export $Key=".Length)
+ }
+ }
+ throw "Couldn't find value for $Key in $Path"
+}
+
+function Download-Node {
+ if (Test-Path $NodeTarget -PathType Leaf) {
+ return
+ }
+ Write-Output "Downloading Node v$NodeVersion (may take a while)"
+ New-Item $NodeTargetDir -ItemType Directory -ErrorAction silentlyContinue | Out-Null
+ $WebClient = New-Object Net.WebClient
+ $WebClient.DownloadFile($NodeSource, "$NodeTarget.downloading")
+ Rename-Item "$NodeTarget.downloading" $NodeTarget
+}
+
+## Convenience variables
+$BaseDir = Split-Path $script:MyInvocation.MyCommand.Path
+$Cache = "$BaseDir\.cache"
+if ($Env:TG_BOOTSTRAP_CACHE) {
+ $Cache = $Env:TG_BOOTSTRAP_CACHE
+}
+
+# Get OS version
+[int]$OSMajor = (Get-WmiObject -Class Win32_OperatingSystem).Version.Split(".")[0]
+
+# Set Node version based on OS version
+if ($OSMajor -lt 10) {
+ # Anything under Windows 10
+ $NodeVersion = Extract-Variable -Path "$BaseDir\..\..\dependencies.sh" -Key "NODE_VERSION_COMPAT"
+}
+else {
+ $NodeVersion = Extract-Variable -Path "$BaseDir\..\..\dependencies.sh" -Key "NODE_VERSION_LTS"
+}
+
+$NodeSource = "https://nodejs.org/download/release/v$NodeVersion/win-x64/node.exe"
+$NodeTargetDir = "$Cache\node-v$NodeVersion-x64"
+$NodeTarget = "$NodeTargetDir\node.exe"
+
+## Just print the path and exit
+if ($Args.length -eq 1 -and $Args[0] -eq "Get-Path") {
+ Write-Output "$NodeTargetDir"
+ exit 0
+}
+
+## Just download node and exit
+if ($Args.length -eq 1 -and $Args[0] -eq "Download-Node") {
+ Download-Node
+ exit 0
+}
+
+## Download node
+Download-Node
+
+## Set PATH so that recursive calls find it
+$Env:PATH = "$NodeTargetDir;$ENV:Path"
+
+## Invoke Node with all command-line arguments
+$ErrorActionPreference = "Continue"
+& "$NodeTarget" @Args
+exit $LastExitCode
diff --git a/tools/bootstrap/python b/tools/bootstrap/python
new file mode 100644
index 0000000000..0c8d702020
--- /dev/null
+++ b/tools/bootstrap/python
@@ -0,0 +1,118 @@
+#!/bin/sh
+# bootstrap/python
+#
+# Python-finding script for all `sh` environments, including Linux, MSYS2,
+# Git for Windows, and GitHub Desktop. Invokable from CLI or automation.
+#
+# If a python.exe installed by `python_.ps1` is present, it will be used.
+# Otherwise, this script requires a system `python3` and `pip` to be provided,
+# and will create a standard virtualenv in which to install `requirements.txt`.
+set -e
+
+# Convenience variables
+Bootstrap="$(dirname "$0")"
+Sdk="$(dirname "$Bootstrap")"
+Cache="$Bootstrap/.cache"
+if [ "$TG_BOOTSTRAP_CACHE" ]; then
+ Cache="$TG_BOOTSTRAP_CACHE"
+fi
+OldPWD="$PWD"
+cd "$Bootstrap/../.."
+. ./dependencies.sh # sets PYTHON_VERSION
+cd "$OldPWD"
+PythonVersion="$PYTHON_VERSION"
+PythonDir="$Cache/python-$PythonVersion"
+PythonExe="$PythonDir/python.exe"
+Log="$Cache/last-command.log"
+
+# If a portable Python for Windows is not present, search on $PATH.
+if [ "$(uname)" = "Linux" ] || [ ! -f "$PythonExe" ]; then
+ # Strip the "App Execution Aliases" from $PATH. Even if the user installed
+ # Python using the Windows Store on purpose, these aliases always generate
+ # "Permission denied" errors when sh.exe tries to invoke them.
+ PATH=$(echo "$PATH" | tr ":" "\n" | grep -v "AppData/Local/Microsoft/WindowsApps" | tr "\n" ":")
+
+ # Try to find a Python executable.
+ if command -v python3 >/dev/null 2>&1; then
+ PythonExe=python3
+ elif command -v python >/dev/null 2>&1; then
+ PythonExe=python
+ elif command -v py >/dev/null 2>&1; then
+ PythonExe="py -3"
+ else
+ echo
+ if command -v apt-get >/dev/null 2>&1; then
+ echo "Please install Python using your system's package manager:"
+ echo " sudo apt-get install python3 python3-pip"
+ elif [ "$(uname -o)" = "Msys" ]; then
+ echo "Please run tools/bootstrap/python.bat instead of tools/bootstrap/python once to"
+ echo "install Python automatically, or install it from https://www.python.org/downloads/"
+ # TODO: give MSYS pacman advice?
+ elif command -v pacman >/dev/null 2>&1; then
+ echo "Please install Python using your system's package manager:"
+ echo " sudo pacman -S python python-pip"
+ else
+ echo "Please install Python from https://www.python.org/downloads/ or using your system's package manager."
+ fi
+ echo
+ exit 1
+ fi
+
+ # Create a venv and activate it
+ PythonDir="$Cache/venv"
+ if [ ! -d "$PythonDir" ]; then
+ echo "Creating virtualenv..."
+ "$PythonExe" -m venv "$PythonDir"
+ fi
+ if [ -f "$PythonDir/bin/python" ]; then
+ PythonExe="$PythonDir/bin/python"
+ elif [ -f "$PythonDir/scripts/python3.exe" ]; then
+ PythonExe="$PythonDir/scripts/python3.exe";
+ else
+ echo "bootstrap/python failed to find the python executable inside its virtualenv"
+ exit 1
+ fi
+fi
+
+# Use pip to install our requirements
+if [ ! -f "$PythonDir/requirements.txt" ] || [ "$(b2sum < "$Sdk/requirements.txt")" != "$(b2sum < "$PythonDir/requirements.txt")" ]; then
+ echo "Updating dependencies..."
+ "$PythonExe" -m pip install -U wheel
+ "$PythonExe" -m pip install -U pip -r "$Sdk/requirements.txt"
+ cp "$Sdk/requirements.txt" "$PythonDir/requirements.txt"
+ echo "---"
+fi
+
+# Verify version and deduce the path separator
+PythonMajor=${PythonVersion%%.*}
+PythonMinor=${PythonVersion#*.}
+PythonMinor=${PythonMinor%.*}
+PATHSEP=$("$PythonExe" - "$PythonMajor" "$PythonMinor" <<'EOF'
+import sys, os
+if sys.version_info.major != int(sys.argv[1]) or sys.version_info.minor < int(sys.argv[2]):
+ print("Error: Python ", sys.argv[1], ".", sys.argv[2], " or later is required, but you have:\n", sys.version, sep="", file=sys.stderr)
+ exit(1)
+print(os.pathsep)
+EOF
+)
+
+# Cheap shell function if tee.exe is not available
+if ! command -v tee >/dev/null 2>&1; then
+ tee() {
+ # Fudge: assume $1 is always "-a"
+ while read -r line; do
+ echo "$line" >> "$2"
+ echo "$line"
+ done
+ }
+fi
+
+# Invoke python with all command-line arguments
+export PYTHONPATH="$Sdk$PATHSEP${PYTHONPATH:-}"
+mkdir -p "$Cache"
+printf '%s\n' "$PythonExe" "$@" > "$Log"
+printf -- '---\n' >> "$Log"
+exec 4>&1
+exitstatus=$({ { set +e; "$PythonExe" -u "$@" 2>&1 3>&-; printf %s $? >&3; } 4>&- | tee -a "$Log" 1>&4; } 3>&1)
+exec 4>&-
+exit "$exitstatus"
diff --git a/tools/bootstrap/python.bat b/tools/bootstrap/python.bat
new file mode 100644
index 0000000000..5bec61b84c
--- /dev/null
+++ b/tools/bootstrap/python.bat
@@ -0,0 +1,2 @@
+@echo off
+call powershell.exe -NoLogo -ExecutionPolicy Bypass -File "%~dp0\python_.ps1" %*
diff --git a/tools/bootstrap/python_.ps1 b/tools/bootstrap/python_.ps1
new file mode 100644
index 0000000000..f37589f106
--- /dev/null
+++ b/tools/bootstrap/python_.ps1
@@ -0,0 +1,108 @@
+# bootstrap/python_.ps1
+#
+# Python bootstrapping script for Windows.
+#
+# Automatically downloads a portable edition of a pinned Python version to
+# a cache directory, installs Pip, installs `requirements.txt`, and then invokes
+# Python.
+#
+# The underscore in the name is so that typing `bootstrap/python` into
+# PowerShell finds the `.bat` file first, which ensures this script executes
+# regardless of ExecutionPolicy.
+$host.ui.RawUI.WindowTitle = "starting :: python $args"
+$ErrorActionPreference = "Stop"
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+Add-Type -AssemblyName System.IO.Compression.FileSystem
+
+function ExtractVersion {
+ param([string] $Path, [string] $Key)
+ foreach ($Line in Get-Content $Path) {
+ if ($Line.StartsWith("export $Key=")) {
+ return $Line.Substring("export $Key=".Length)
+ }
+ }
+ throw "Couldn't find value for $Key in $Path"
+}
+
+# Convenience variables
+$Bootstrap = Split-Path $script:MyInvocation.MyCommand.Path
+$Tools = Split-Path $Bootstrap
+$Cache = "$Bootstrap/.cache"
+if ($Env:TG_BOOTSTRAP_CACHE) {
+ $Cache = $Env:TG_BOOTSTRAP_CACHE
+}
+$PythonVersion = ExtractVersion -Path "$Bootstrap/../../dependencies.sh" -Key "PYTHON_VERSION"
+$PythonDir = "$Cache/python-$PythonVersion"
+$PythonExe = "$PythonDir/python.exe"
+$Log = "$Cache/last-command.log"
+
+# Download and unzip a portable version of Python
+if (!(Test-Path $PythonExe -PathType Leaf)) {
+ $host.ui.RawUI.WindowTitle = "Downloading Python $PythonVersion..."
+ New-Item $Cache -ItemType Directory -ErrorAction silentlyContinue | Out-Null
+
+ $Archive = "$Cache/python-$PythonVersion-embed.zip"
+ Invoke-WebRequest `
+ "https://www.python.org/ftp/python/$PythonVersion/python-$PythonVersion-embed-amd64.zip" `
+ -OutFile $Archive `
+ -ErrorAction Stop
+
+ [System.IO.Compression.ZipFile]::ExtractToDirectory($Archive, $PythonDir)
+
+ $PythonVersionArray = $PythonVersion.Split(".")
+ $PythonVersionString = "python$($PythonVersionArray[0])$($PythonVersionArray[1])"
+ Write-Output "Generating PATH descriptor."
+ New-Item "$Cache/$PythonVersionString._pth" | Out-Null
+ Set-Content "$Cache/$PythonVersionString._pth" "$PythonVersionString.zip`n.`n..\..\..`nimport site`n"
+ # Copy a ._pth file without "import site" commented, so pip will work
+ Copy-Item "$Cache/$PythonVersionString._pth" $PythonDir `
+ -ErrorAction Stop
+
+ Remove-Item $Archive
+}
+
+# Install pip
+if (!(Test-Path "$PythonDir/Scripts/pip.exe")) {
+ $host.ui.RawUI.WindowTitle = "Downloading Pip..."
+
+ Invoke-WebRequest "https://bootstrap.pypa.io/get-pip.py" `
+ -OutFile "$Cache/get-pip.py" `
+ -ErrorAction Stop
+
+ & $PythonExe "$Cache/get-pip.py" --no-warn-script-location
+ if ($LASTEXITCODE -ne 0) {
+ exit $LASTEXITCODE
+ }
+
+ Remove-Item "$Cache/get-pip.py" `
+ -ErrorAction Stop
+}
+
+# Use pip to install our requirements
+if (!(Test-Path "$PythonDir/requirements.txt") -or ((Get-FileHash "$Tools/requirements.txt").hash -ne (Get-FileHash "$PythonDir/requirements.txt").hash)) {
+ $host.ui.RawUI.WindowTitle = "Updating dependencies..."
+
+ & $PythonExe -m pip install -U pip -r "$Tools/requirements.txt"
+ if ($LASTEXITCODE -ne 0) {
+ exit $LASTEXITCODE
+ }
+
+ Copy-Item "$Tools/requirements.txt" "$PythonDir/requirements.txt"
+ Write-Output "`n---`n"
+}
+
+# Invoke python with all command-line arguments
+Write-Output $PythonExe | Out-File -Encoding utf8 $Log
+[System.String]::Join([System.Environment]::NewLine, $args) | Out-File -Encoding utf8 -Append $Log
+Write-Output "---" | Out-File -Encoding utf8 -Append $Log
+$host.ui.RawUI.WindowTitle = "python $args"
+$ErrorActionPreference = "Continue"
+& $PythonExe -u $args 2>&1 | ForEach-Object {
+ $str = "$_"
+ if ($_.GetType() -eq [System.Management.Automation.ErrorRecord]) {
+ $str = $str.TrimEnd("`r`n")
+ }
+ $str | Out-File -Encoding utf8 -Append $Log
+ $str | Out-Host
+}
+exit $LastExitCode
diff --git a/tools/build/.editorconfig b/tools/build/.editorconfig
new file mode 100644
index 0000000000..d1d8a4176a
--- /dev/null
+++ b/tools/build/.editorconfig
@@ -0,0 +1,10 @@
+# http://editorconfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
diff --git a/tools/build/README.md b/tools/build/README.md
new file mode 100644
index 0000000000..195c9eff83
--- /dev/null
+++ b/tools/build/README.md
@@ -0,0 +1,54 @@
+# /tg/station build script
+
+This build script is the recommended way to compile the game, including not only the DM code but also the JavaScript and any other dependencies.
+
+- VSCode:
+ a) Press `Ctrl+Shift+B` to build.
+ b) Press `F5` to build and run with debugger attached.
+- Windows:
+ a) Double-click `BUILD.bat` in the repository root to build (will wait for a key press before it closes).
+ b) Double-click `tools/build/build.bat` to build (will exit as soon as it finishes building).
+- Linux:
+ a) Run `tools/build/build` from the repository root.
+
+The script will skip build steps whose inputs have not changed since the last run.
+
+## Getting list of available targets
+
+You can get a list of all targets that you can build by running the following command:
+
+```
+tools/build/build --help
+```
+
+## Dependencies
+
+- On Windows, `build.bat` will automatically install a private (vendored) copy of Node.
+- On Linux, install Node using your package manager or from .
+- On Linux, unless using tgs4 or later you will need to compile rust-g on the server and obtain a .so file, for instructions see https://github.com/tgstation/rust-g
+
+## Why?
+
+We used to include compiled versions of the tgui JavaScript code in the Git repository so that the project could be compiled using BYOND only. These pre-compiled files tended to have merge conflicts for no good reason. Using a build script lets us avoid this problem, while keeping builds convenient for people who are not modifying tgui.
+
+This build script is based on [Juke Build](https://github.com/stylemistake/juke-build) - follow the link to read the documentation for the project and understand how it works and how to contribute.
+
+## Named byond versions
+
+If you have byond installations in non-standard locations or want to use few versions at once for testing you can fill in `dm_versions.json` file in this directory.
+Entries with "default" set to true will be used BEFORE byond installations in standard locations. Otherwise you need to pass `--dm-version={name}` to the build script to choose version you want to use.
+Example dm_versions.json file:
+```
+[
+ {
+ "name": "515.1594",
+ "path": "C:\\Repo\\ByondVersions\\515.1594_byond\\byond\\bin\\dm.exe",
+ "default": false
+ },
+ {
+ "name": "funny_version",
+ "path": "D:\\Repo\\ByondVersions\\514.1589_byond\\byond\\bin\\dm.exe",
+ "default": true
+ }
+]
+```
diff --git a/tools/build/build b/tools/build/build
new file mode 100644
index 0000000000..0e202e1bba
--- /dev/null
+++ b/tools/build/build
@@ -0,0 +1,4 @@
+#!/bin/sh
+set -e
+cd "$(dirname "$0")"
+exec ../bootstrap/node build.js "$@"
diff --git a/tools/build/build.bat b/tools/build/build.bat
new file mode 100644
index 0000000000..56e3bf1171
--- /dev/null
+++ b/tools/build/build.bat
@@ -0,0 +1,2 @@
+@echo off
+"%~dp0\..\bootstrap\node.bat" --experimental-modules "%~dp0\build.js" %*
diff --git a/tools/build/build.js b/tools/build/build.js
new file mode 100644
index 0000000000..fb3f93d5ab
--- /dev/null
+++ b/tools/build/build.js
@@ -0,0 +1,503 @@
+#!/usr/bin/env node
+/**
+ * Build script for /tg/station 13 codebase.
+ *
+ * This script uses Juke Build, read the docs here:
+ * https://github.com/stylemistake/juke-build
+ */
+
+import fs from 'fs';
+import https from 'https';
+import { env } from 'process';
+import Juke from './juke/index.js';
+import { DreamDaemon, DreamMaker, NamedVersionFile } from './lib/byond.js';
+import { yarn } from './lib/yarn.js';
+
+const TGS_MODE = process.env.CBT_BUILD_MODE === 'TGS';
+
+Juke.chdir('../..', import.meta.url);
+Juke.setup({ file: import.meta.url }).then((code) => {
+ // We're using the currently available quirk in Juke Build, which
+ // prevents it from exiting on Windows, to wait on errors.
+ if (code !== 0 && process.argv.includes('--wait-on-error')) {
+ Juke.logger.error('Please inspect the error and close the window.');
+ return;
+ }
+
+ if (TGS_MODE) {
+ // workaround for ESBuild process lingering
+ // Once https://github.com/privatenumber/esbuild-loader/pull/354 is merged and updated to, this can be removed
+ setTimeout(() => process.exit(code), 10000);
+ }
+ else {
+ process.exit(code);
+ }
+});
+
+const DME_NAME = 'vorestation';
+
+// Stores the contents of dependencies.sh as a key value pair
+// Best way I could figure to get ahold of this stuff
+const dependencies = fs.readFileSync('dependencies.sh', 'utf8')
+ .split("\n")
+ .map((statement) => statement.replace("export", "").trim())
+ .filter((value) => !(value == "" || value.startsWith("#")))
+ .map((statement) => statement.split("="))
+ .reduce((acc, kv_pair) => {
+ acc[kv_pair[0]] = kv_pair[1];
+ return acc
+ }, {})
+
+// Canonical path for the cutter exe at this moment
+const getCutterPath = () => {
+ const ver = dependencies.CUTTER_VERSION;
+ const suffix = process.platform === 'win32' ? '.exe' : '';
+ const file_ver = ver.split('.').join('-');
+ return `tools/icon_cutter/cache/hypnagogic${file_ver}${suffix}`;
+};
+
+const cutter_path = getCutterPath();
+
+export const DefineParameter = new Juke.Parameter({
+ type: 'string[]',
+ alias: 'D',
+});
+
+export const PortParameter = new Juke.Parameter({
+ type: 'string',
+ alias: 'p',
+});
+
+export const DmVersionParameter = new Juke.Parameter({
+ type: 'string',
+});
+
+export const CiParameter = new Juke.Parameter({ type: 'boolean' });
+
+export const ForceRecutParameter = new Juke.Parameter({
+ type: 'boolean',
+ name: "force-recut",
+});
+
+export const SkipIconCutter = new Juke.Parameter({
+ type: 'boolean',
+ name: "skip-icon-cutter",
+});
+
+export const WarningParameter = new Juke.Parameter({
+ type: 'string[]',
+ alias: 'W',
+});
+
+export const NoWarningParameter = new Juke.Parameter({
+ type: 'string[]',
+ alias: 'I',
+});
+
+export const CutterTarget = new Juke.Target({
+ onlyWhen: () => {
+ const files = Juke.glob(cutter_path);
+ return files.length == 0;
+ },
+ executes: async () => {
+ const repo = dependencies.CUTTER_REPO;
+ const ver = dependencies.CUTTER_VERSION;
+ const suffix = process.platform === 'win32' ? '.exe' : '';
+ const download_from = `https://github.com/${repo}/releases/download/${ver}/hypnagogic${suffix}`
+ await download_file(download_from, cutter_path);
+ if(process.platform !== 'win32') {
+ await Juke.exec("chmod", [
+ '+x',
+ cutter_path,
+ ]);
+ }
+ },
+});
+
+async function download_file(url, file) {
+ return new Promise((resolve, reject) => {
+ let file_stream = fs.createWriteStream(file);
+ https.get(url, function(response) {
+ if (response.statusCode === 302) {
+ file_stream.close();
+ download_file(response.headers.location, file)
+ .then((value) => resolve());
+ return;
+ }
+ if (response.statusCode !== 200) {
+ Juke.logger.error(`Failed to download ${url}: Status ${response.statusCode}`);
+ file_stream.close();
+ reject()
+ return
+ }
+ response.pipe(file_stream);
+
+ // after download completed close filestream
+ file_stream.on("finish", () => {
+ file_stream.close();
+ resolve()
+ });
+
+ }).on("error", (err) => {
+ file_stream.close();
+ Juke.rm(download_into);
+ Juke.logger.error(`Failed to download ${url}: ${err.message}`);
+ reject()
+ });
+ });
+}
+
+export const IconCutterTarget = new Juke.Target({
+ parameters: [ForceRecutParameter],
+ dependsOn: () => [
+ CutterTarget,
+ ],
+ inputs: ({ get }) => {
+ const standard_inputs = [
+ `icons/**/*.png.toml`,
+ `icons/**/*.dmi.toml`,
+ `cutter_templates/**/*.toml`,
+ cutter_path,
+ ]
+ // Alright we're gonna search out any existing toml files and convert
+ // them to their matching .dmi or .png file
+ const existing_configs = [
+ ...Juke.glob(`icons/**/*.png.toml`),
+ ...Juke.glob(`icons/**/*.dmi.toml`),
+ ];
+ return [
+ ...standard_inputs,
+ ...existing_configs.map((file) => file.replace('.toml', '')),
+ ]
+ },
+ outputs: ({ get }) => {
+ if(get(ForceRecutParameter))
+ return [];
+ const folders = [
+ ...Juke.glob(`icons/**/*.png.toml`),
+ ...Juke.glob(`icons/**/*.dmi.toml`),
+ ];
+ return folders
+ .map((file) => file.replace(`.png.toml`, '.dmi'))
+ .map((file) => file.replace(`.dmi.toml`, '.png'));
+ },
+ executes: async () => {
+ await Juke.exec(cutter_path, [
+ '--dont-wait',
+ '--templates',
+ 'cutter_templates',
+ 'icons',
+ ]);
+ },
+});
+
+export const DmMapsIncludeTarget = new Juke.Target({
+ executes: async () => {
+ const folders = [
+ ...Juke.glob('_maps/map_files/**/modular_pieces/*.dmm'),
+ ...Juke.glob('_maps/RandomRuins/**/*.dmm'),
+ ...Juke.glob('_maps/RandomZLevels/**/*.dmm'),
+ ...Juke.glob('_maps/shuttles/**/*.dmm'),
+ ...Juke.glob('_maps/templates/**/*.dmm'),
+ ];
+ const content = folders
+ .map((file) => file.replace('_maps/', ''))
+ .map((file) => `#include "${file}"`)
+ .join('\n') + '\n';
+ fs.writeFileSync('_maps/templates.dm', content);
+ },
+});
+
+export const DmTarget = new Juke.Target({
+ parameters: [DefineParameter, DmVersionParameter, WarningParameter, NoWarningParameter, SkipIconCutter],
+ dependsOn: ({ get }) => [
+ get(DefineParameter).includes('ALL_MAPS') && DmMapsIncludeTarget,
+ !get(SkipIconCutter) && IconCutterTarget,
+ ],
+ inputs: [
+ '_maps/map_files/generic/**',
+ 'maps/**/*.dm',
+ 'code/**',
+ 'html/**',
+ 'icons/**',
+ 'interface/**',
+ 'sound/**',
+ `${DME_NAME}.dme`,
+ NamedVersionFile,
+ ],
+ outputs: ({ get }) => {
+ if (get(DmVersionParameter)) {
+ return []; // Always rebuild when dm version is provided
+ }
+ return [
+ `${DME_NAME}.dmb`,
+ `${DME_NAME}.rsc`,
+ ]
+ },
+ executes: async ({ get }) => {
+ await DreamMaker(`${DME_NAME}.dme`, {
+ defines: ['CBT', ...get(DefineParameter)],
+ warningsAsErrors: get(WarningParameter).includes('error'),
+ ignoreWarningCodes: get(NoWarningParameter),
+ namedDmVersion: get(DmVersionParameter),
+ });
+ },
+});
+
+export const DmTestTarget = new Juke.Target({
+ parameters: [DefineParameter, DmVersionParameter, WarningParameter, NoWarningParameter],
+ dependsOn: ({ get }) => [
+ get(DefineParameter).includes('ALL_MAPS') && DmMapsIncludeTarget,
+ IconCutterTarget,
+ ],
+ executes: async ({ get }) => {
+ fs.copyFileSync(`${DME_NAME}.dme`, `${DME_NAME}.test.dme`);
+ await DreamMaker(`${DME_NAME}.test.dme`, {
+ defines: ['CBT', 'CIBUILDING', ...get(DefineParameter)],
+ warningsAsErrors: get(WarningParameter).includes('error'),
+ ignoreWarningCodes: get(NoWarningParameter),
+ namedDmVersion: get(DmVersionParameter),
+ });
+ Juke.rm('data/logs/ci', { recursive: true });
+ const options = {
+ dmbFile : `${DME_NAME}.test.dmb`,
+ namedDmVersion: get(DmVersionParameter),
+ }
+ await DreamDaemon(
+ options,
+ '-close', '-trusted', '-verbose',
+ '-params', 'log-directory=ci'
+ );
+ Juke.rm('*.test.*');
+ try {
+ const cleanRun = fs.readFileSync('data/logs/ci/clean_run.lk', 'utf-8');
+ console.log(cleanRun);
+ }
+ catch (err) {
+ Juke.logger.error('Test run was not clean, exiting');
+ throw new Juke.ExitCode(1);
+ }
+ },
+});
+
+export const AutowikiTarget = new Juke.Target({
+ parameters: [DefineParameter, DmVersionParameter, WarningParameter, NoWarningParameter],
+ dependsOn: ({ get }) => [
+ get(DefineParameter).includes('ALL_MAPS') && DmMapsIncludeTarget,
+ IconCutterTarget,
+ ],
+ outputs: [
+ 'data/autowiki_edits.txt',
+ ],
+ executes: async ({ get }) => {
+ fs.copyFileSync(`${DME_NAME}.dme`, `${DME_NAME}.test.dme`);
+ await DreamMaker(`${DME_NAME}.test.dme`, {
+ defines: ['CBT', 'AUTOWIKI', ...get(DefineParameter)],
+ warningsAsErrors: get(WarningParameter).includes('error'),
+ ignoreWarningCodes: get(NoWarningParameter),
+ namedDmVersion: get(DmVersionParameter),
+ });
+ Juke.rm('data/autowiki_edits.txt');
+ Juke.rm('data/autowiki_files', { recursive: true });
+ Juke.rm('data/logs/ci', { recursive: true });
+
+ const options = {
+ dmbFile: `${DME_NAME}.test.dmb`,
+ namedDmVersion: get(DmVersionParameter),
+ }
+ await DreamDaemon(
+ options,
+ '-close', '-trusted', '-verbose',
+ '-params', 'log-directory=ci',
+ );
+ Juke.rm('*.test.*');
+ if (!fs.existsSync('data/autowiki_edits.txt')) {
+ Juke.logger.error('Autowiki did not generate an output, exiting');
+ throw new Juke.ExitCode(1);
+ }
+ },
+})
+
+export const YarnTarget = new Juke.Target({
+ parameters: [CiParameter],
+ inputs: [
+ 'tgui/.yarn/+(cache|releases|plugins|sdks)/**/*',
+ 'tgui/**/package.json',
+ 'tgui/yarn.lock',
+ ],
+ outputs: [
+ 'tgui/.yarn/install-target',
+ ],
+ executes: ({ get }) => yarn('install', get(CiParameter) && '--immutable'),
+});
+
+export const TgFontTarget = new Juke.Target({
+ dependsOn: [YarnTarget],
+ inputs: [
+ 'tgui/.yarn/install-target',
+ 'tgui/packages/tgfont/**/*.+(js|cjs|svg)',
+ 'tgui/packages/tgfont/package.json',
+ ],
+ outputs: [
+ 'tgui/packages/tgfont/dist/tgfont.css',
+ 'tgui/packages/tgfont/dist/tgfont.eot',
+ 'tgui/packages/tgfont/dist/tgfont.woff2',
+ ],
+ executes: async () => {
+ await yarn('tgfont:build');
+ fs.copyFileSync('tgui/packages/tgfont/dist/tgfont.css', 'tgui/packages/tgfont/static/tgfont.css');
+ fs.copyFileSync('tgui/packages/tgfont/dist/tgfont.eot', 'tgui/packages/tgfont/static/tgfont.eot');
+ fs.copyFileSync('tgui/packages/tgfont/dist/tgfont.woff2', 'tgui/packages/tgfont/static/tgfont.woff2');
+ }
+});
+
+export const TguiTarget = new Juke.Target({
+ dependsOn: [YarnTarget],
+ inputs: [
+ 'tgui/.yarn/install-target',
+ 'tgui/webpack.config.js',
+ 'tgui/**/package.json',
+ 'tgui/packages/**/*.+(js|cjs|ts|tsx|jsx|scss)',
+ ],
+ outputs: [
+ 'tgui/public/tgui.bundle.css',
+ 'tgui/public/tgui.bundle.js',
+ 'tgui/public/tgui-panel.bundle.css',
+ 'tgui/public/tgui-panel.bundle.js',
+ 'tgui/public/tgui-say.bundle.css',
+ 'tgui/public/tgui-say.bundle.js',
+ ],
+ executes: () => yarn('tgui:build'),
+});
+
+export const TguiEslintTarget = new Juke.Target({
+ parameters: [CiParameter],
+ dependsOn: [YarnTarget],
+ executes: ({ get }) => yarn('tgui:lint', !get(CiParameter) && '--fix'),
+});
+
+export const TguiPrettierTarget = new Juke.Target({
+ dependsOn: [YarnTarget],
+ executes: () => yarn('tgui:prettier'),
+});
+
+export const TguiSonarTarget = new Juke.Target({
+ dependsOn: [YarnTarget],
+ executes: () => yarn('tgui:sonar'),
+});
+
+export const TguiTscTarget = new Juke.Target({
+ dependsOn: [YarnTarget],
+ executes: () => yarn('tgui:tsc'),
+});
+
+export const TguiTestTarget = new Juke.Target({
+ parameters: [CiParameter],
+ dependsOn: [YarnTarget],
+ executes: ({ get }) => yarn(`tgui:test-${get(CiParameter) ? 'ci' : 'simple'}`),
+});
+
+export const TguiLintTarget = new Juke.Target({
+ dependsOn: [YarnTarget, TguiPrettierTarget, TguiEslintTarget, TguiTscTarget],
+});
+
+export const TguiDevTarget = new Juke.Target({
+ dependsOn: [YarnTarget],
+ executes: ({ args }) => yarn('tgui:dev', ...args),
+});
+
+export const TguiAnalyzeTarget = new Juke.Target({
+ dependsOn: [YarnTarget],
+ executes: () => yarn('tgui:analyze'),
+});
+
+export const TguiBenchTarget = new Juke.Target({
+ dependsOn: [YarnTarget],
+ executes: () => yarn('tgui:bench'),
+});
+
+export const TestTarget = new Juke.Target({
+ dependsOn: [DmTestTarget, TguiTestTarget],
+});
+
+export const LintTarget = new Juke.Target({
+ dependsOn: [TguiLintTarget],
+});
+
+export const BuildTarget = new Juke.Target({
+ dependsOn: [TguiTarget, DmTarget],
+});
+
+export const ServerTarget = new Juke.Target({
+ parameters: [DmVersionParameter, PortParameter],
+ dependsOn: [BuildTarget],
+ executes: async ({ get }) => {
+ const port = get(PortParameter) || '1337';
+ const options = {
+ dmbFile: `${DME_NAME}.dmb`,
+ namedDmVersion: get(DmVersionParameter),
+ }
+ await DreamDaemon(options, port, '-trusted');
+ },
+});
+
+export const AllTarget = new Juke.Target({
+ dependsOn: [TestTarget, LintTarget, BuildTarget],
+});
+
+export const TguiCleanTarget = new Juke.Target({
+ executes: async () => {
+ Juke.rm('tgui/public/.tmp', { recursive: true });
+ Juke.rm('tgui/public/*.map');
+ Juke.rm('tgui/public/*.{chunk,bundle,hot-update}.*');
+ Juke.rm('tgui/packages/tgfont/dist', { recursive: true });
+ Juke.rm('tgui/.yarn/{cache,unplugged,webpack}', { recursive: true });
+ Juke.rm('tgui/.yarn/build-state.yml');
+ Juke.rm('tgui/.yarn/install-state.gz');
+ Juke.rm('tgui/.yarn/install-target');
+ Juke.rm('tgui/.pnp.*');
+ },
+});
+
+export const CleanTarget = new Juke.Target({
+ dependsOn: [TguiCleanTarget],
+ executes: async () => {
+ Juke.rm('*.{dmb,rsc}');
+ Juke.rm('_maps/templates.dm');
+ },
+});
+
+/**
+ * Removes more junk at the expense of much slower initial builds.
+ */
+export const CleanAllTarget = new Juke.Target({
+ dependsOn: [CleanTarget],
+ executes: async () => {
+ Juke.logger.info('Cleaning up data/logs');
+ Juke.rm('data/logs', { recursive: true });
+ Juke.logger.info('Cleaning up global yarn cache');
+ await yarn('cache', 'clean', '--all');
+ },
+});
+
+/**
+ * Prepends the defines to the .dme.
+ * Does not clean them up, as this is intended for TGS which
+ * clones new copies anyway.
+ */
+const prependDefines = (...defines) => {
+ const dmeContents = fs.readFileSync(`${DME_NAME}.dme`);
+ const textToWrite = defines.map(define => `#define ${define}\n`);
+ fs.writeFileSync(`${DME_NAME}.dme`, `${textToWrite}\n${dmeContents}`);
+};
+
+export const TgsTarget = new Juke.Target({
+ dependsOn: [TguiTarget],
+ executes: async () => {
+ Juke.logger.info('Prepending TGS define');
+ prependDefines('TGS');
+ },
+});
+
+
+export default TGS_MODE ? TgsTarget : BuildTarget;
diff --git a/tools/build/juke/index.d.ts b/tools/build/juke/index.d.ts
new file mode 100644
index 0000000000..cdc30ea577
--- /dev/null
+++ b/tools/build/juke/index.d.ts
@@ -0,0 +1,248 @@
+// Generated by dts-bundle-generator v5.9.0
+
+///
+
+import _chalk from 'chalk';
+import { SpawnOptionsWithoutStdio } from 'child_process';
+import EventEmitter from 'events';
+
+/**
+ * Change the current working directory of the Node.js process.
+ *
+ * Second argument is a file (or directory), relative to which chdir will be
+ * performed. This is usually `import.meta.url`.
+ */
+export declare const chdir: (directory: string, relativeTo?: string | undefined) => void;
+export declare const logger: {
+ log: (...args: unknown[]) => void;
+ error: (...args: unknown[]) => void;
+ action: (...args: unknown[]) => void;
+ warn: (...args: unknown[]) => void;
+ info: (...args: unknown[]) => void;
+ debug: (...args: unknown[]) => void;
+};
+export declare type ParameterType = (string | string[] | number | number[] | boolean | boolean[]);
+export declare type StringType = ("string" | "string[]" | "number" | "number[]" | "boolean" | "boolean[]");
+export declare type TypeByString = (T extends "string" ? string : T extends "string[]" ? string[] : T extends "number" ? number : T extends "number[]" ? number[] : T extends "boolean" ? boolean : T extends "boolean[]" ? boolean[] : never);
+export declare type ParameterConfig = {
+ /**
+ * Parameter name, as it would be used in CLI.
+ */
+ name?: string;
+ /**
+ * Parameter type, one of:
+ * - `string`
+ * - `string[]`
+ * - `number`
+ * - `number[]`
+ * - `boolean`
+ * - `boolean[]`
+ */
+ type: T;
+ /**
+ * Short flag for use in CLI, can only be a single character.
+ */
+ alias?: string;
+};
+export interface Parameter {
+ type: StringType;
+ name?: string;
+ alias?: string;
+ __internalType?: T;
+ isString(): this is Parameter;
+ isNumber(): this is Parameter;
+ isBoolean(): this is Parameter;
+ isArray(): this is Parameter;
+ toKebabCase(): string | undefined;
+ toConstCase(): string | undefined;
+ toCamelCase(): string | undefined;
+}
+export declare type ParameterCtor = {
+ new (config: ParameterConfig): Parameter>;
+};
+export declare const Parameter: ParameterCtor;
+export declare type ParameterCreator = (config: ParameterConfig) => Parameter>;
+export declare const createParameter: ParameterCreator;
+export declare type ExecutionContext = {
+ /** Get parameter value. */
+ get: (parameter: Parameter) => (T extends Array ? T : T | null);
+ args: string[];
+};
+export declare type BooleanLike = boolean | null | undefined;
+export declare type WithExecutionContext = (context: ExecutionContext) => R | Promise;
+export declare type WithOptionalExecutionContext = R | WithExecutionContext;
+export declare type DependsOn = WithOptionalExecutionContext<(Target | BooleanLike)[]>;
+export declare type ExecutesFn = WithExecutionContext;
+export declare type OnlyWhenFn = WithExecutionContext;
+export declare type FileIo = WithOptionalExecutionContext<(string | BooleanLike)[]>;
+export declare type TargetConfig = {
+ /**
+ * Target name. This parameter is required.
+ */
+ name?: string;
+ /**
+ * Dependencies for this target. They will be ran before executing this
+ * target, and may run in parallel.
+ */
+ dependsOn?: DependsOn;
+ /**
+ * Function that is delegated to the execution engine for building this
+ * target. It is normally an async function, which accepts a single
+ * argument - execution context (contains `get` for interacting with
+ * parameters).
+ *
+ * @example
+ * executes: async ({ get }) => {
+ * console.log(get(Parameter));
+ * },
+ */
+ executes?: ExecutesFn;
+ /**
+ * Files that are consumed by this target.
+ */
+ inputs?: FileIo;
+ /**
+ * Files that are produced by this target. Additionally, they are also
+ * touched every time target finishes executing in order to stop
+ * this target from re-running.
+ */
+ outputs?: FileIo;
+ /**
+ * Parameters that are local to this task. Can be retrieved via `get`
+ * in the executor function.
+ */
+ parameters?: Parameter[];
+ /**
+ * Target will run only when this function returns true. It accepts a
+ * single argument - execution context.
+ */
+ onlyWhen?: OnlyWhenFn;
+};
+export declare class Target {
+ name?: string;
+ dependsOn: DependsOn;
+ executes?: ExecutesFn;
+ inputs: FileIo;
+ outputs: FileIo;
+ parameters: Parameter[];
+ onlyWhen?: OnlyWhenFn;
+ constructor(target: TargetConfig);
+}
+export declare type TargetCreator = (target: TargetConfig) => Target;
+export declare const createTarget: TargetCreator;
+export declare type RunnerConfig = {
+ targets?: Target[];
+ default?: Target;
+ parameters?: Parameter[];
+ singleTarget?: boolean;
+};
+export declare const runner: {
+ config: RunnerConfig;
+ targets: Target[];
+ parameters: Parameter[];
+ workers: Worker[];
+ configure(config: RunnerConfig): void;
+ start(): Promise;
+};
+declare class Worker {
+ readonly target: Target;
+ readonly context: ExecutionContext;
+ readonly dependsOn: Target[];
+ dependencies: Set;
+ generator?: AsyncGenerator;
+ emitter: EventEmitter;
+ hasFailed: boolean;
+ constructor(target: Target, context: ExecutionContext, dependsOn: Target[]);
+ resolveDependency(target: Target): void;
+ rejectDependency(target: Target): void;
+ start(): void;
+ onFinish(fn: () => void): void;
+ onFail(fn: () => void): void;
+ private debugLog;
+ private process;
+}
+export declare class ExitCode extends Error {
+ code: number | null;
+ signal: string | null;
+ constructor(code: number | null, signal?: string | null);
+}
+export declare type ExecOptions = SpawnOptionsWithoutStdio & {
+ /**
+ * If `true`, this exec call will not pipe its output to stdio.
+ * @default false
+ */
+ silent?: boolean;
+ /**
+ * Throw an exception on non-zero exit code.
+ * @default true
+ */
+ throw?: boolean;
+};
+export declare type ExecReturn = {
+ /** Exit code of the program. */
+ code: number | null;
+ /** Signal received by the program which caused it to exit. */
+ signal: NodeJS.Signals | null;
+ /** Output collected from `stdout` */
+ stdout: string;
+ /** Output collected from `stderr` */
+ stderr: string;
+ /** A combined output collected from `stdout` and `stderr`. */
+ combined: string;
+};
+export declare const exec: (executable: string, args?: string[], options?: ExecOptions) => Promise;
+/**
+ * Unix style pathname pattern expansion.
+ *
+ * Perform a search matching a specified pattern according to the rules of
+ * the `glob` npm package. Path can be either absolute or relative, and can
+ * contain shell-style wildcards. Broken symlinks are included in the results
+ * (as in the shell). Whether or not the results are sorted depends on the
+ * file system.
+ *
+ * @returns A possibly empty list of file paths.
+ */
+export declare const glob: (globPath: string) => string[];
+export declare type RmOptions = {
+ /**
+ * If true, perform a recursive directory removal.
+ */
+ recursive?: boolean;
+ /**
+ * If true, exceptions will be ignored if file or directory does not exist.
+ */
+ force?: boolean;
+};
+/**
+ * Removes files and directories (synchronously). Supports globs.
+ */
+export declare const rm: (path: string, options?: RmOptions) => void;
+export declare const chalk: _chalk.Chalk & _chalk.ChalkFunction & {
+ supportsColor: false | _chalk.ColorSupport;
+ Level: _chalk.Level;
+ Color: ("black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright") | ("bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright");
+ ForegroundColor: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright";
+ BackgroundColor: "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright";
+ Modifiers: "bold" | "reset" | "dim" | "italic" | "underline" | "inverse" | "hidden" | "strikethrough" | "visible";
+ stderr: _chalk.Chalk & {
+ supportsColor: false | _chalk.ColorSupport;
+ };
+};
+export declare type SetupConfig = {
+ file: string;
+ /**
+ * If true, CLI will only accept a single target to run and will receive all
+ * passed arguments as is (not only flags).
+ */
+ singleTarget?: boolean;
+};
+/**
+ * Configures Juke Build and starts executing targets.
+ *
+ * @param config Juke Build configuration.
+ * @returns Exit code of the whole runner process.
+ */
+export declare const setup: (config: SetupConfig) => Promise;
+export declare const sleep: (time: number) => Promise;
+
+export {};
diff --git a/tools/build/juke/index.js b/tools/build/juke/index.js
new file mode 100644
index 0000000000..4ee8fbf0bf
--- /dev/null
+++ b/tools/build/juke/index.js
@@ -0,0 +1,5128 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+ for (var prop in b || (b = {}))
+ if (__hasOwnProp.call(b, prop))
+ __defNormalProp(a, prop, b[prop]);
+ if (__getOwnPropSymbols)
+ for (var prop of __getOwnPropSymbols(b)) {
+ if (__propIsEnum.call(b, prop))
+ __defNormalProp(a, prop, b[prop]);
+ }
+ return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __objRest = (source, exclude) => {
+ var target = {};
+ for (var prop in source)
+ if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+ target[prop] = source[prop];
+ if (source != null && __getOwnPropSymbols)
+ for (var prop of __getOwnPropSymbols(source)) {
+ if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+ target[prop] = source[prop];
+ }
+ return target;
+};
+var __commonJS = (cb, mod) => function __require() {
+ return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+ __markAsModule(target);
+ for (var name in all)
+ __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+ if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+ for (let key of __getOwnPropNames(module2))
+ if (!__hasOwnProp.call(target, key) && key !== "default")
+ __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+ }
+ return target;
+};
+var __toModule = (module2) => {
+ return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+
+// pnp:color-name-npm-1.1.4-025792b0ea-b044585952.zip/node_modules/color-name/index.js
+var require_color_name = __commonJS({
+ "pnp:color-name-npm-1.1.4-025792b0ea-b044585952.zip/node_modules/color-name/index.js"(exports, module2) {
+ "use strict";
+ module2.exports = {
+ "aliceblue": [240, 248, 255],
+ "antiquewhite": [250, 235, 215],
+ "aqua": [0, 255, 255],
+ "aquamarine": [127, 255, 212],
+ "azure": [240, 255, 255],
+ "beige": [245, 245, 220],
+ "bisque": [255, 228, 196],
+ "black": [0, 0, 0],
+ "blanchedalmond": [255, 235, 205],
+ "blue": [0, 0, 255],
+ "blueviolet": [138, 43, 226],
+ "brown": [165, 42, 42],
+ "burlywood": [222, 184, 135],
+ "cadetblue": [95, 158, 160],
+ "chartreuse": [127, 255, 0],
+ "chocolate": [210, 105, 30],
+ "coral": [255, 127, 80],
+ "cornflowerblue": [100, 149, 237],
+ "cornsilk": [255, 248, 220],
+ "crimson": [220, 20, 60],
+ "cyan": [0, 255, 255],
+ "darkblue": [0, 0, 139],
+ "darkcyan": [0, 139, 139],
+ "darkgoldenrod": [184, 134, 11],
+ "darkgray": [169, 169, 169],
+ "darkgreen": [0, 100, 0],
+ "darkgrey": [169, 169, 169],
+ "darkkhaki": [189, 183, 107],
+ "darkmagenta": [139, 0, 139],
+ "darkolivegreen": [85, 107, 47],
+ "darkorange": [255, 140, 0],
+ "darkorchid": [153, 50, 204],
+ "darkred": [139, 0, 0],
+ "darksalmon": [233, 150, 122],
+ "darkseagreen": [143, 188, 143],
+ "darkslateblue": [72, 61, 139],
+ "darkslategray": [47, 79, 79],
+ "darkslategrey": [47, 79, 79],
+ "darkturquoise": [0, 206, 209],
+ "darkviolet": [148, 0, 211],
+ "deeppink": [255, 20, 147],
+ "deepskyblue": [0, 191, 255],
+ "dimgray": [105, 105, 105],
+ "dimgrey": [105, 105, 105],
+ "dodgerblue": [30, 144, 255],
+ "firebrick": [178, 34, 34],
+ "floralwhite": [255, 250, 240],
+ "forestgreen": [34, 139, 34],
+ "fuchsia": [255, 0, 255],
+ "gainsboro": [220, 220, 220],
+ "ghostwhite": [248, 248, 255],
+ "gold": [255, 215, 0],
+ "goldenrod": [218, 165, 32],
+ "gray": [128, 128, 128],
+ "green": [0, 128, 0],
+ "greenyellow": [173, 255, 47],
+ "grey": [128, 128, 128],
+ "honeydew": [240, 255, 240],
+ "hotpink": [255, 105, 180],
+ "indianred": [205, 92, 92],
+ "indigo": [75, 0, 130],
+ "ivory": [255, 255, 240],
+ "khaki": [240, 230, 140],
+ "lavender": [230, 230, 250],
+ "lavenderblush": [255, 240, 245],
+ "lawngreen": [124, 252, 0],
+ "lemonchiffon": [255, 250, 205],
+ "lightblue": [173, 216, 230],
+ "lightcoral": [240, 128, 128],
+ "lightcyan": [224, 255, 255],
+ "lightgoldenrodyellow": [250, 250, 210],
+ "lightgray": [211, 211, 211],
+ "lightgreen": [144, 238, 144],
+ "lightgrey": [211, 211, 211],
+ "lightpink": [255, 182, 193],
+ "lightsalmon": [255, 160, 122],
+ "lightseagreen": [32, 178, 170],
+ "lightskyblue": [135, 206, 250],
+ "lightslategray": [119, 136, 153],
+ "lightslategrey": [119, 136, 153],
+ "lightsteelblue": [176, 196, 222],
+ "lightyellow": [255, 255, 224],
+ "lime": [0, 255, 0],
+ "limegreen": [50, 205, 50],
+ "linen": [250, 240, 230],
+ "magenta": [255, 0, 255],
+ "maroon": [128, 0, 0],
+ "mediumaquamarine": [102, 205, 170],
+ "mediumblue": [0, 0, 205],
+ "mediumorchid": [186, 85, 211],
+ "mediumpurple": [147, 112, 219],
+ "mediumseagreen": [60, 179, 113],
+ "mediumslateblue": [123, 104, 238],
+ "mediumspringgreen": [0, 250, 154],
+ "mediumturquoise": [72, 209, 204],
+ "mediumvioletred": [199, 21, 133],
+ "midnightblue": [25, 25, 112],
+ "mintcream": [245, 255, 250],
+ "mistyrose": [255, 228, 225],
+ "moccasin": [255, 228, 181],
+ "navajowhite": [255, 222, 173],
+ "navy": [0, 0, 128],
+ "oldlace": [253, 245, 230],
+ "olive": [128, 128, 0],
+ "olivedrab": [107, 142, 35],
+ "orange": [255, 165, 0],
+ "orangered": [255, 69, 0],
+ "orchid": [218, 112, 214],
+ "palegoldenrod": [238, 232, 170],
+ "palegreen": [152, 251, 152],
+ "paleturquoise": [175, 238, 238],
+ "palevioletred": [219, 112, 147],
+ "papayawhip": [255, 239, 213],
+ "peachpuff": [255, 218, 185],
+ "peru": [205, 133, 63],
+ "pink": [255, 192, 203],
+ "plum": [221, 160, 221],
+ "powderblue": [176, 224, 230],
+ "purple": [128, 0, 128],
+ "rebeccapurple": [102, 51, 153],
+ "red": [255, 0, 0],
+ "rosybrown": [188, 143, 143],
+ "royalblue": [65, 105, 225],
+ "saddlebrown": [139, 69, 19],
+ "salmon": [250, 128, 114],
+ "sandybrown": [244, 164, 96],
+ "seagreen": [46, 139, 87],
+ "seashell": [255, 245, 238],
+ "sienna": [160, 82, 45],
+ "silver": [192, 192, 192],
+ "skyblue": [135, 206, 235],
+ "slateblue": [106, 90, 205],
+ "slategray": [112, 128, 144],
+ "slategrey": [112, 128, 144],
+ "snow": [255, 250, 250],
+ "springgreen": [0, 255, 127],
+ "steelblue": [70, 130, 180],
+ "tan": [210, 180, 140],
+ "teal": [0, 128, 128],
+ "thistle": [216, 191, 216],
+ "tomato": [255, 99, 71],
+ "turquoise": [64, 224, 208],
+ "violet": [238, 130, 238],
+ "wheat": [245, 222, 179],
+ "white": [255, 255, 255],
+ "whitesmoke": [245, 245, 245],
+ "yellow": [255, 255, 0],
+ "yellowgreen": [154, 205, 50]
+ };
+ }
+});
+
+// pnp:color-convert-npm-2.0.1-79730e935b-79e6bdb9fd.zip/node_modules/color-convert/conversions.js
+var require_conversions = __commonJS({
+ "pnp:color-convert-npm-2.0.1-79730e935b-79e6bdb9fd.zip/node_modules/color-convert/conversions.js"(exports, module2) {
+ var cssKeywords = require_color_name();
+ var reverseKeywords = {};
+ for (const key of Object.keys(cssKeywords)) {
+ reverseKeywords[cssKeywords[key]] = key;
+ }
+ var convert = {
+ rgb: { channels: 3, labels: "rgb" },
+ hsl: { channels: 3, labels: "hsl" },
+ hsv: { channels: 3, labels: "hsv" },
+ hwb: { channels: 3, labels: "hwb" },
+ cmyk: { channels: 4, labels: "cmyk" },
+ xyz: { channels: 3, labels: "xyz" },
+ lab: { channels: 3, labels: "lab" },
+ lch: { channels: 3, labels: "lch" },
+ hex: { channels: 1, labels: ["hex"] },
+ keyword: { channels: 1, labels: ["keyword"] },
+ ansi16: { channels: 1, labels: ["ansi16"] },
+ ansi256: { channels: 1, labels: ["ansi256"] },
+ hcg: { channels: 3, labels: ["h", "c", "g"] },
+ apple: { channels: 3, labels: ["r16", "g16", "b16"] },
+ gray: { channels: 1, labels: ["gray"] }
+ };
+ module2.exports = convert;
+ for (const model of Object.keys(convert)) {
+ if (!("channels" in convert[model])) {
+ throw new Error("missing channels property: " + model);
+ }
+ if (!("labels" in convert[model])) {
+ throw new Error("missing channel labels property: " + model);
+ }
+ if (convert[model].labels.length !== convert[model].channels) {
+ throw new Error("channel and label counts mismatch: " + model);
+ }
+ const { channels, labels } = convert[model];
+ delete convert[model].channels;
+ delete convert[model].labels;
+ Object.defineProperty(convert[model], "channels", { value: channels });
+ Object.defineProperty(convert[model], "labels", { value: labels });
+ }
+ convert.rgb.hsl = function(rgb) {
+ const r = rgb[0] / 255;
+ const g = rgb[1] / 255;
+ const b = rgb[2] / 255;
+ const min = Math.min(r, g, b);
+ const max = Math.max(r, g, b);
+ const delta = max - min;
+ let h;
+ let s;
+ if (max === min) {
+ h = 0;
+ } else if (r === max) {
+ h = (g - b) / delta;
+ } else if (g === max) {
+ h = 2 + (b - r) / delta;
+ } else if (b === max) {
+ h = 4 + (r - g) / delta;
+ }
+ h = Math.min(h * 60, 360);
+ if (h < 0) {
+ h += 360;
+ }
+ const l = (min + max) / 2;
+ if (max === min) {
+ s = 0;
+ } else if (l <= 0.5) {
+ s = delta / (max + min);
+ } else {
+ s = delta / (2 - max - min);
+ }
+ return [h, s * 100, l * 100];
+ };
+ convert.rgb.hsv = function(rgb) {
+ let rdif;
+ let gdif;
+ let bdif;
+ let h;
+ let s;
+ const r = rgb[0] / 255;
+ const g = rgb[1] / 255;
+ const b = rgb[2] / 255;
+ const v = Math.max(r, g, b);
+ const diff = v - Math.min(r, g, b);
+ const diffc = function(c) {
+ return (v - c) / 6 / diff + 1 / 2;
+ };
+ if (diff === 0) {
+ h = 0;
+ s = 0;
+ } else {
+ s = diff / v;
+ rdif = diffc(r);
+ gdif = diffc(g);
+ bdif = diffc(b);
+ if (r === v) {
+ h = bdif - gdif;
+ } else if (g === v) {
+ h = 1 / 3 + rdif - bdif;
+ } else if (b === v) {
+ h = 2 / 3 + gdif - rdif;
+ }
+ if (h < 0) {
+ h += 1;
+ } else if (h > 1) {
+ h -= 1;
+ }
+ }
+ return [
+ h * 360,
+ s * 100,
+ v * 100
+ ];
+ };
+ convert.rgb.hwb = function(rgb) {
+ const r = rgb[0];
+ const g = rgb[1];
+ let b = rgb[2];
+ const h = convert.rgb.hsl(rgb)[0];
+ const w = 1 / 255 * Math.min(r, Math.min(g, b));
+ b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+ return [h, w * 100, b * 100];
+ };
+ convert.rgb.cmyk = function(rgb) {
+ const r = rgb[0] / 255;
+ const g = rgb[1] / 255;
+ const b = rgb[2] / 255;
+ const k = Math.min(1 - r, 1 - g, 1 - b);
+ const c = (1 - r - k) / (1 - k) || 0;
+ const m = (1 - g - k) / (1 - k) || 0;
+ const y = (1 - b - k) / (1 - k) || 0;
+ return [c * 100, m * 100, y * 100, k * 100];
+ };
+ function comparativeDistance(x, y) {
+ return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
+ }
+ convert.rgb.keyword = function(rgb) {
+ const reversed = reverseKeywords[rgb];
+ if (reversed) {
+ return reversed;
+ }
+ let currentClosestDistance = Infinity;
+ let currentClosestKeyword;
+ for (const keyword of Object.keys(cssKeywords)) {
+ const value = cssKeywords[keyword];
+ const distance = comparativeDistance(rgb, value);
+ if (distance < currentClosestDistance) {
+ currentClosestDistance = distance;
+ currentClosestKeyword = keyword;
+ }
+ }
+ return currentClosestKeyword;
+ };
+ convert.keyword.rgb = function(keyword) {
+ return cssKeywords[keyword];
+ };
+ convert.rgb.xyz = function(rgb) {
+ let r = rgb[0] / 255;
+ let g = rgb[1] / 255;
+ let b = rgb[2] / 255;
+ r = r > 0.04045 ? ((r + 0.055) / 1.055) ** 2.4 : r / 12.92;
+ g = g > 0.04045 ? ((g + 0.055) / 1.055) ** 2.4 : g / 12.92;
+ b = b > 0.04045 ? ((b + 0.055) / 1.055) ** 2.4 : b / 12.92;
+ const x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+ const y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+ const z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+ return [x * 100, y * 100, z * 100];
+ };
+ convert.rgb.lab = function(rgb) {
+ const xyz = convert.rgb.xyz(rgb);
+ let x = xyz[0];
+ let y = xyz[1];
+ let z = xyz[2];
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
+ x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+ y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+ z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+ const l = 116 * y - 16;
+ const a = 500 * (x - y);
+ const b = 200 * (y - z);
+ return [l, a, b];
+ };
+ convert.hsl.rgb = function(hsl) {
+ const h = hsl[0] / 360;
+ const s = hsl[1] / 100;
+ const l = hsl[2] / 100;
+ let t2;
+ let t3;
+ let val;
+ if (s === 0) {
+ val = l * 255;
+ return [val, val, val];
+ }
+ if (l < 0.5) {
+ t2 = l * (1 + s);
+ } else {
+ t2 = l + s - l * s;
+ }
+ const t1 = 2 * l - t2;
+ const rgb = [0, 0, 0];
+ for (let i = 0; i < 3; i++) {
+ t3 = h + 1 / 3 * -(i - 1);
+ if (t3 < 0) {
+ t3++;
+ }
+ if (t3 > 1) {
+ t3--;
+ }
+ if (6 * t3 < 1) {
+ val = t1 + (t2 - t1) * 6 * t3;
+ } else if (2 * t3 < 1) {
+ val = t2;
+ } else if (3 * t3 < 2) {
+ val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+ } else {
+ val = t1;
+ }
+ rgb[i] = val * 255;
+ }
+ return rgb;
+ };
+ convert.hsl.hsv = function(hsl) {
+ const h = hsl[0];
+ let s = hsl[1] / 100;
+ let l = hsl[2] / 100;
+ let smin = s;
+ const lmin = Math.max(l, 0.01);
+ l *= 2;
+ s *= l <= 1 ? l : 2 - l;
+ smin *= lmin <= 1 ? lmin : 2 - lmin;
+ const v = (l + s) / 2;
+ const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+ return [h, sv * 100, v * 100];
+ };
+ convert.hsv.rgb = function(hsv) {
+ const h = hsv[0] / 60;
+ const s = hsv[1] / 100;
+ let v = hsv[2] / 100;
+ const hi = Math.floor(h) % 6;
+ const f = h - Math.floor(h);
+ const p = 255 * v * (1 - s);
+ const q = 255 * v * (1 - s * f);
+ const t = 255 * v * (1 - s * (1 - f));
+ v *= 255;
+ switch (hi) {
+ case 0:
+ return [v, t, p];
+ case 1:
+ return [q, v, p];
+ case 2:
+ return [p, v, t];
+ case 3:
+ return [p, q, v];
+ case 4:
+ return [t, p, v];
+ case 5:
+ return [v, p, q];
+ }
+ };
+ convert.hsv.hsl = function(hsv) {
+ const h = hsv[0];
+ const s = hsv[1] / 100;
+ const v = hsv[2] / 100;
+ const vmin = Math.max(v, 0.01);
+ let sl;
+ let l;
+ l = (2 - s) * v;
+ const lmin = (2 - s) * vmin;
+ sl = s * vmin;
+ sl /= lmin <= 1 ? lmin : 2 - lmin;
+ sl = sl || 0;
+ l /= 2;
+ return [h, sl * 100, l * 100];
+ };
+ convert.hwb.rgb = function(hwb) {
+ const h = hwb[0] / 360;
+ let wh = hwb[1] / 100;
+ let bl = hwb[2] / 100;
+ const ratio = wh + bl;
+ let f;
+ if (ratio > 1) {
+ wh /= ratio;
+ bl /= ratio;
+ }
+ const i = Math.floor(6 * h);
+ const v = 1 - bl;
+ f = 6 * h - i;
+ if ((i & 1) !== 0) {
+ f = 1 - f;
+ }
+ const n = wh + f * (v - wh);
+ let r;
+ let g;
+ let b;
+ switch (i) {
+ default:
+ case 6:
+ case 0:
+ r = v;
+ g = n;
+ b = wh;
+ break;
+ case 1:
+ r = n;
+ g = v;
+ b = wh;
+ break;
+ case 2:
+ r = wh;
+ g = v;
+ b = n;
+ break;
+ case 3:
+ r = wh;
+ g = n;
+ b = v;
+ break;
+ case 4:
+ r = n;
+ g = wh;
+ b = v;
+ break;
+ case 5:
+ r = v;
+ g = wh;
+ b = n;
+ break;
+ }
+ return [r * 255, g * 255, b * 255];
+ };
+ convert.cmyk.rgb = function(cmyk) {
+ const c = cmyk[0] / 100;
+ const m = cmyk[1] / 100;
+ const y = cmyk[2] / 100;
+ const k = cmyk[3] / 100;
+ const r = 1 - Math.min(1, c * (1 - k) + k);
+ const g = 1 - Math.min(1, m * (1 - k) + k);
+ const b = 1 - Math.min(1, y * (1 - k) + k);
+ return [r * 255, g * 255, b * 255];
+ };
+ convert.xyz.rgb = function(xyz) {
+ const x = xyz[0] / 100;
+ const y = xyz[1] / 100;
+ const z = xyz[2] / 100;
+ let r;
+ let g;
+ let b;
+ r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+ g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+ b = x * 0.0557 + y * -0.204 + z * 1.057;
+ r = r > 31308e-7 ? 1.055 * r ** (1 / 2.4) - 0.055 : r * 12.92;
+ g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : g * 12.92;
+ b = b > 31308e-7 ? 1.055 * b ** (1 / 2.4) - 0.055 : b * 12.92;
+ r = Math.min(Math.max(0, r), 1);
+ g = Math.min(Math.max(0, g), 1);
+ b = Math.min(Math.max(0, b), 1);
+ return [r * 255, g * 255, b * 255];
+ };
+ convert.xyz.lab = function(xyz) {
+ let x = xyz[0];
+ let y = xyz[1];
+ let z = xyz[2];
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
+ x = x > 8856e-6 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+ y = y > 8856e-6 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+ z = z > 8856e-6 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+ const l = 116 * y - 16;
+ const a = 500 * (x - y);
+ const b = 200 * (y - z);
+ return [l, a, b];
+ };
+ convert.lab.xyz = function(lab) {
+ const l = lab[0];
+ const a = lab[1];
+ const b = lab[2];
+ let x;
+ let y;
+ let z;
+ y = (l + 16) / 116;
+ x = a / 500 + y;
+ z = y - b / 200;
+ const y2 = y ** 3;
+ const x2 = x ** 3;
+ const z2 = z ** 3;
+ y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;
+ x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;
+ z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787;
+ x *= 95.047;
+ y *= 100;
+ z *= 108.883;
+ return [x, y, z];
+ };
+ convert.lab.lch = function(lab) {
+ const l = lab[0];
+ const a = lab[1];
+ const b = lab[2];
+ let h;
+ const hr = Math.atan2(b, a);
+ h = hr * 360 / 2 / Math.PI;
+ if (h < 0) {
+ h += 360;
+ }
+ const c = Math.sqrt(a * a + b * b);
+ return [l, c, h];
+ };
+ convert.lch.lab = function(lch) {
+ const l = lch[0];
+ const c = lch[1];
+ const h = lch[2];
+ const hr = h / 360 * 2 * Math.PI;
+ const a = c * Math.cos(hr);
+ const b = c * Math.sin(hr);
+ return [l, a, b];
+ };
+ convert.rgb.ansi16 = function(args, saturation = null) {
+ const [r, g, b] = args;
+ let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation;
+ value = Math.round(value / 50);
+ if (value === 0) {
+ return 30;
+ }
+ let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+ if (value === 2) {
+ ansi += 60;
+ }
+ return ansi;
+ };
+ convert.hsv.ansi16 = function(args) {
+ return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+ };
+ convert.rgb.ansi256 = function(args) {
+ const r = args[0];
+ const g = args[1];
+ const b = args[2];
+ if (r === g && g === b) {
+ if (r < 8) {
+ return 16;
+ }
+ if (r > 248) {
+ return 231;
+ }
+ return Math.round((r - 8) / 247 * 24) + 232;
+ }
+ const ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+ return ansi;
+ };
+ convert.ansi16.rgb = function(args) {
+ let color = args % 10;
+ if (color === 0 || color === 7) {
+ if (args > 50) {
+ color += 3.5;
+ }
+ color = color / 10.5 * 255;
+ return [color, color, color];
+ }
+ const mult = (~~(args > 50) + 1) * 0.5;
+ const r = (color & 1) * mult * 255;
+ const g = (color >> 1 & 1) * mult * 255;
+ const b = (color >> 2 & 1) * mult * 255;
+ return [r, g, b];
+ };
+ convert.ansi256.rgb = function(args) {
+ if (args >= 232) {
+ const c = (args - 232) * 10 + 8;
+ return [c, c, c];
+ }
+ args -= 16;
+ let rem;
+ const r = Math.floor(args / 36) / 5 * 255;
+ const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+ const b = rem % 6 / 5 * 255;
+ return [r, g, b];
+ };
+ convert.rgb.hex = function(args) {
+ const integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
+ const string = integer.toString(16).toUpperCase();
+ return "000000".substring(string.length) + string;
+ };
+ convert.hex.rgb = function(args) {
+ const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+ if (!match) {
+ return [0, 0, 0];
+ }
+ let colorString = match[0];
+ if (match[0].length === 3) {
+ colorString = colorString.split("").map((char) => {
+ return char + char;
+ }).join("");
+ }
+ const integer = parseInt(colorString, 16);
+ const r = integer >> 16 & 255;
+ const g = integer >> 8 & 255;
+ const b = integer & 255;
+ return [r, g, b];
+ };
+ convert.rgb.hcg = function(rgb) {
+ const r = rgb[0] / 255;
+ const g = rgb[1] / 255;
+ const b = rgb[2] / 255;
+ const max = Math.max(Math.max(r, g), b);
+ const min = Math.min(Math.min(r, g), b);
+ const chroma = max - min;
+ let grayscale;
+ let hue;
+ if (chroma < 1) {
+ grayscale = min / (1 - chroma);
+ } else {
+ grayscale = 0;
+ }
+ if (chroma <= 0) {
+ hue = 0;
+ } else if (max === r) {
+ hue = (g - b) / chroma % 6;
+ } else if (max === g) {
+ hue = 2 + (b - r) / chroma;
+ } else {
+ hue = 4 + (r - g) / chroma;
+ }
+ hue /= 6;
+ hue %= 1;
+ return [hue * 360, chroma * 100, grayscale * 100];
+ };
+ convert.hsl.hcg = function(hsl) {
+ const s = hsl[1] / 100;
+ const l = hsl[2] / 100;
+ const c = l < 0.5 ? 2 * s * l : 2 * s * (1 - l);
+ let f = 0;
+ if (c < 1) {
+ f = (l - 0.5 * c) / (1 - c);
+ }
+ return [hsl[0], c * 100, f * 100];
+ };
+ convert.hsv.hcg = function(hsv) {
+ const s = hsv[1] / 100;
+ const v = hsv[2] / 100;
+ const c = s * v;
+ let f = 0;
+ if (c < 1) {
+ f = (v - c) / (1 - c);
+ }
+ return [hsv[0], c * 100, f * 100];
+ };
+ convert.hcg.rgb = function(hcg) {
+ const h = hcg[0] / 360;
+ const c = hcg[1] / 100;
+ const g = hcg[2] / 100;
+ if (c === 0) {
+ return [g * 255, g * 255, g * 255];
+ }
+ const pure = [0, 0, 0];
+ const hi = h % 1 * 6;
+ const v = hi % 1;
+ const w = 1 - v;
+ let mg = 0;
+ switch (Math.floor(hi)) {
+ case 0:
+ pure[0] = 1;
+ pure[1] = v;
+ pure[2] = 0;
+ break;
+ case 1:
+ pure[0] = w;
+ pure[1] = 1;
+ pure[2] = 0;
+ break;
+ case 2:
+ pure[0] = 0;
+ pure[1] = 1;
+ pure[2] = v;
+ break;
+ case 3:
+ pure[0] = 0;
+ pure[1] = w;
+ pure[2] = 1;
+ break;
+ case 4:
+ pure[0] = v;
+ pure[1] = 0;
+ pure[2] = 1;
+ break;
+ default:
+ pure[0] = 1;
+ pure[1] = 0;
+ pure[2] = w;
+ }
+ mg = (1 - c) * g;
+ return [
+ (c * pure[0] + mg) * 255,
+ (c * pure[1] + mg) * 255,
+ (c * pure[2] + mg) * 255
+ ];
+ };
+ convert.hcg.hsv = function(hcg) {
+ const c = hcg[1] / 100;
+ const g = hcg[2] / 100;
+ const v = c + g * (1 - c);
+ let f = 0;
+ if (v > 0) {
+ f = c / v;
+ }
+ return [hcg[0], f * 100, v * 100];
+ };
+ convert.hcg.hsl = function(hcg) {
+ const c = hcg[1] / 100;
+ const g = hcg[2] / 100;
+ const l = g * (1 - c) + 0.5 * c;
+ let s = 0;
+ if (l > 0 && l < 0.5) {
+ s = c / (2 * l);
+ } else if (l >= 0.5 && l < 1) {
+ s = c / (2 * (1 - l));
+ }
+ return [hcg[0], s * 100, l * 100];
+ };
+ convert.hcg.hwb = function(hcg) {
+ const c = hcg[1] / 100;
+ const g = hcg[2] / 100;
+ const v = c + g * (1 - c);
+ return [hcg[0], (v - c) * 100, (1 - v) * 100];
+ };
+ convert.hwb.hcg = function(hwb) {
+ const w = hwb[1] / 100;
+ const b = hwb[2] / 100;
+ const v = 1 - b;
+ const c = v - w;
+ let g = 0;
+ if (c < 1) {
+ g = (v - c) / (1 - c);
+ }
+ return [hwb[0], c * 100, g * 100];
+ };
+ convert.apple.rgb = function(apple) {
+ return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
+ };
+ convert.rgb.apple = function(rgb) {
+ return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
+ };
+ convert.gray.rgb = function(args) {
+ return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+ };
+ convert.gray.hsl = function(args) {
+ return [0, 0, args[0]];
+ };
+ convert.gray.hsv = convert.gray.hsl;
+ convert.gray.hwb = function(gray) {
+ return [0, 100, gray[0]];
+ };
+ convert.gray.cmyk = function(gray) {
+ return [0, 0, 0, gray[0]];
+ };
+ convert.gray.lab = function(gray) {
+ return [gray[0], 0, 0];
+ };
+ convert.gray.hex = function(gray) {
+ const val = Math.round(gray[0] / 100 * 255) & 255;
+ const integer = (val << 16) + (val << 8) + val;
+ const string = integer.toString(16).toUpperCase();
+ return "000000".substring(string.length) + string;
+ };
+ convert.rgb.gray = function(rgb) {
+ const val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+ return [val / 255 * 100];
+ };
+ }
+});
+
+// pnp:color-convert-npm-2.0.1-79730e935b-79e6bdb9fd.zip/node_modules/color-convert/route.js
+var require_route = __commonJS({
+ "pnp:color-convert-npm-2.0.1-79730e935b-79e6bdb9fd.zip/node_modules/color-convert/route.js"(exports, module2) {
+ var conversions = require_conversions();
+ function buildGraph() {
+ const graph = {};
+ const models = Object.keys(conversions);
+ for (let len = models.length, i = 0; i < len; i++) {
+ graph[models[i]] = {
+ distance: -1,
+ parent: null
+ };
+ }
+ return graph;
+ }
+ function deriveBFS(fromModel) {
+ const graph = buildGraph();
+ const queue = [fromModel];
+ graph[fromModel].distance = 0;
+ while (queue.length) {
+ const current = queue.pop();
+ const adjacents = Object.keys(conversions[current]);
+ for (let len = adjacents.length, i = 0; i < len; i++) {
+ const adjacent = adjacents[i];
+ const node = graph[adjacent];
+ if (node.distance === -1) {
+ node.distance = graph[current].distance + 1;
+ node.parent = current;
+ queue.unshift(adjacent);
+ }
+ }
+ }
+ return graph;
+ }
+ function link(from, to) {
+ return function(args) {
+ return to(from(args));
+ };
+ }
+ function wrapConversion(toModel, graph) {
+ const path2 = [graph[toModel].parent, toModel];
+ let fn = conversions[graph[toModel].parent][toModel];
+ let cur = graph[toModel].parent;
+ while (graph[cur].parent) {
+ path2.unshift(graph[cur].parent);
+ fn = link(conversions[graph[cur].parent][cur], fn);
+ cur = graph[cur].parent;
+ }
+ fn.conversion = path2;
+ return fn;
+ }
+ module2.exports = function(fromModel) {
+ const graph = deriveBFS(fromModel);
+ const conversion = {};
+ const models = Object.keys(graph);
+ for (let len = models.length, i = 0; i < len; i++) {
+ const toModel = models[i];
+ const node = graph[toModel];
+ if (node.parent === null) {
+ continue;
+ }
+ conversion[toModel] = wrapConversion(toModel, graph);
+ }
+ return conversion;
+ };
+ }
+});
+
+// pnp:color-convert-npm-2.0.1-79730e935b-79e6bdb9fd.zip/node_modules/color-convert/index.js
+var require_color_convert = __commonJS({
+ "pnp:color-convert-npm-2.0.1-79730e935b-79e6bdb9fd.zip/node_modules/color-convert/index.js"(exports, module2) {
+ var conversions = require_conversions();
+ var route = require_route();
+ var convert = {};
+ var models = Object.keys(conversions);
+ function wrapRaw(fn) {
+ const wrappedFn = function(...args) {
+ const arg0 = args[0];
+ if (arg0 === void 0 || arg0 === null) {
+ return arg0;
+ }
+ if (arg0.length > 1) {
+ args = arg0;
+ }
+ return fn(args);
+ };
+ if ("conversion" in fn) {
+ wrappedFn.conversion = fn.conversion;
+ }
+ return wrappedFn;
+ }
+ function wrapRounded(fn) {
+ const wrappedFn = function(...args) {
+ const arg0 = args[0];
+ if (arg0 === void 0 || arg0 === null) {
+ return arg0;
+ }
+ if (arg0.length > 1) {
+ args = arg0;
+ }
+ const result = fn(args);
+ if (typeof result === "object") {
+ for (let len = result.length, i = 0; i < len; i++) {
+ result[i] = Math.round(result[i]);
+ }
+ }
+ return result;
+ };
+ if ("conversion" in fn) {
+ wrappedFn.conversion = fn.conversion;
+ }
+ return wrappedFn;
+ }
+ models.forEach((fromModel) => {
+ convert[fromModel] = {};
+ Object.defineProperty(convert[fromModel], "channels", { value: conversions[fromModel].channels });
+ Object.defineProperty(convert[fromModel], "labels", { value: conversions[fromModel].labels });
+ const routes = route(fromModel);
+ const routeModels = Object.keys(routes);
+ routeModels.forEach((toModel) => {
+ const fn = routes[toModel];
+ convert[fromModel][toModel] = wrapRounded(fn);
+ convert[fromModel][toModel].raw = wrapRaw(fn);
+ });
+ });
+ module2.exports = convert;
+ }
+});
+
+// pnp:ansi-styles-npm-4.3.0-245c7d42c7-513b44c3b2.zip/node_modules/ansi-styles/index.js
+var require_ansi_styles = __commonJS({
+ "pnp:ansi-styles-npm-4.3.0-245c7d42c7-513b44c3b2.zip/node_modules/ansi-styles/index.js"(exports, module2) {
+ "use strict";
+ var wrapAnsi16 = (fn, offset) => (...args) => {
+ const code = fn(...args);
+ return `[${code + offset}m`;
+ };
+ var wrapAnsi256 = (fn, offset) => (...args) => {
+ const code = fn(...args);
+ return `[${38 + offset};5;${code}m`;
+ };
+ var wrapAnsi16m = (fn, offset) => (...args) => {
+ const rgb = fn(...args);
+ return `[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+ };
+ var ansi2ansi = (n) => n;
+ var rgb2rgb = (r, g, b) => [r, g, b];
+ var setLazyProperty = (object, property, get) => {
+ Object.defineProperty(object, property, {
+ get: () => {
+ const value = get();
+ Object.defineProperty(object, property, {
+ value,
+ enumerable: true,
+ configurable: true
+ });
+ return value;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ };
+ var colorConvert;
+ var makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => {
+ if (colorConvert === void 0) {
+ colorConvert = require_color_convert();
+ }
+ const offset = isBackground ? 10 : 0;
+ const styles = {};
+ for (const [sourceSpace, suite] of Object.entries(colorConvert)) {
+ const name = sourceSpace === "ansi16" ? "ansi" : sourceSpace;
+ if (sourceSpace === targetSpace) {
+ styles[name] = wrap(identity, offset);
+ } else if (typeof suite === "object") {
+ styles[name] = wrap(suite[targetSpace], offset);
+ }
+ }
+ return styles;
+ };
+ function assembleStyles() {
+ const codes = new Map();
+ const styles = {
+ modifier: {
+ reset: [0, 0],
+ bold: [1, 22],
+ dim: [2, 22],
+ italic: [3, 23],
+ underline: [4, 24],
+ inverse: [7, 27],
+ hidden: [8, 28],
+ strikethrough: [9, 29]
+ },
+ color: {
+ black: [30, 39],
+ red: [31, 39],
+ green: [32, 39],
+ yellow: [33, 39],
+ blue: [34, 39],
+ magenta: [35, 39],
+ cyan: [36, 39],
+ white: [37, 39],
+ blackBright: [90, 39],
+ redBright: [91, 39],
+ greenBright: [92, 39],
+ yellowBright: [93, 39],
+ blueBright: [94, 39],
+ magentaBright: [95, 39],
+ cyanBright: [96, 39],
+ whiteBright: [97, 39]
+ },
+ bgColor: {
+ bgBlack: [40, 49],
+ bgRed: [41, 49],
+ bgGreen: [42, 49],
+ bgYellow: [43, 49],
+ bgBlue: [44, 49],
+ bgMagenta: [45, 49],
+ bgCyan: [46, 49],
+ bgWhite: [47, 49],
+ bgBlackBright: [100, 49],
+ bgRedBright: [101, 49],
+ bgGreenBright: [102, 49],
+ bgYellowBright: [103, 49],
+ bgBlueBright: [104, 49],
+ bgMagentaBright: [105, 49],
+ bgCyanBright: [106, 49],
+ bgWhiteBright: [107, 49]
+ }
+ };
+ styles.color.gray = styles.color.blackBright;
+ styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+ styles.color.grey = styles.color.blackBright;
+ styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+ for (const [groupName, group] of Object.entries(styles)) {
+ for (const [styleName, style] of Object.entries(group)) {
+ styles[styleName] = {
+ open: `[${style[0]}m`,
+ close: `[${style[1]}m`
+ };
+ group[styleName] = styles[styleName];
+ codes.set(style[0], style[1]);
+ }
+ Object.defineProperty(styles, groupName, {
+ value: group,
+ enumerable: false
+ });
+ }
+ Object.defineProperty(styles, "codes", {
+ value: codes,
+ enumerable: false
+ });
+ styles.color.close = "[39m";
+ styles.bgColor.close = "[49m";
+ setLazyProperty(styles.color, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, false));
+ setLazyProperty(styles.color, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, false));
+ setLazyProperty(styles.color, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, false));
+ setLazyProperty(styles.bgColor, "ansi", () => makeDynamicStyles(wrapAnsi16, "ansi16", ansi2ansi, true));
+ setLazyProperty(styles.bgColor, "ansi256", () => makeDynamicStyles(wrapAnsi256, "ansi256", ansi2ansi, true));
+ setLazyProperty(styles.bgColor, "ansi16m", () => makeDynamicStyles(wrapAnsi16m, "rgb", rgb2rgb, true));
+ return styles;
+ }
+ Object.defineProperty(module2, "exports", {
+ enumerable: true,
+ get: assembleStyles
+ });
+ }
+});
+
+// pnp:has-flag-npm-4.0.0-32af9f0536-261a135703.zip/node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+ "pnp:has-flag-npm-4.0.0-32af9f0536-261a135703.zip/node_modules/has-flag/index.js"(exports, module2) {
+ "use strict";
+ module2.exports = (flag, argv = process.argv) => {
+ const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+ const position = argv.indexOf(prefix + flag);
+ const terminatorPosition = argv.indexOf("--");
+ return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+ };
+ }
+});
+
+// pnp:supports-color-npm-7.2.0-606bfcf7da-3dda818de0.zip/node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+ "pnp:supports-color-npm-7.2.0-606bfcf7da-3dda818de0.zip/node_modules/supports-color/index.js"(exports, module2) {
+ "use strict";
+ var os = require("os");
+ var tty = require("tty");
+ var hasFlag = require_has_flag();
+ var { env } = process;
+ var forceColor;
+ if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+ forceColor = 0;
+ } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+ forceColor = 1;
+ }
+ if ("FORCE_COLOR" in env) {
+ if (env.FORCE_COLOR === "true") {
+ forceColor = 1;
+ } else if (env.FORCE_COLOR === "false") {
+ forceColor = 0;
+ } else {
+ forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+ }
+ }
+ function translateLevel(level) {
+ if (level === 0) {
+ return false;
+ }
+ return {
+ level,
+ hasBasic: true,
+ has256: level >= 2,
+ has16m: level >= 3
+ };
+ }
+ function supportsColor(haveStream, streamIsTTY) {
+ if (forceColor === 0) {
+ return 0;
+ }
+ if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+ return 3;
+ }
+ if (hasFlag("color=256")) {
+ return 2;
+ }
+ if (haveStream && !streamIsTTY && forceColor === void 0) {
+ return 0;
+ }
+ const min = forceColor || 0;
+ if (env.TERM === "dumb") {
+ return min;
+ }
+ if (process.platform === "win32") {
+ const osRelease = os.release().split(".");
+ if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+ return Number(osRelease[2]) >= 14931 ? 3 : 2;
+ }
+ return 1;
+ }
+ if ("CI" in env) {
+ if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+ return 1;
+ }
+ return min;
+ }
+ if ("TEAMCITY_VERSION" in env) {
+ return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+ }
+ if (env.COLORTERM === "truecolor") {
+ return 3;
+ }
+ if ("TERM_PROGRAM" in env) {
+ const version2 = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+ switch (env.TERM_PROGRAM) {
+ case "iTerm.app":
+ return version2 >= 3 ? 3 : 2;
+ case "Apple_Terminal":
+ return 2;
+ }
+ }
+ if (/-256(color)?$/i.test(env.TERM)) {
+ return 2;
+ }
+ if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+ return 1;
+ }
+ if ("COLORTERM" in env) {
+ return 1;
+ }
+ return min;
+ }
+ function getSupportLevel(stream) {
+ const level = supportsColor(stream, stream && stream.isTTY);
+ return translateLevel(level);
+ }
+ module2.exports = {
+ supportsColor: getSupportLevel,
+ stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+ stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+ };
+ }
+});
+
+// pnp:chalk-npm-4.1.2-ba8b67ab80-fe75c9d5c7.zip/node_modules/chalk/source/util.js
+var require_util = __commonJS({
+ "pnp:chalk-npm-4.1.2-ba8b67ab80-fe75c9d5c7.zip/node_modules/chalk/source/util.js"(exports, module2) {
+ "use strict";
+ var stringReplaceAll = (string, substring, replacer) => {
+ let index = string.indexOf(substring);
+ if (index === -1) {
+ return string;
+ }
+ const substringLength = substring.length;
+ let endIndex = 0;
+ let returnValue = "";
+ do {
+ returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+ endIndex = index + substringLength;
+ index = string.indexOf(substring, endIndex);
+ } while (index !== -1);
+ returnValue += string.substr(endIndex);
+ return returnValue;
+ };
+ var stringEncaseCRLFWithFirstIndex = (string, prefix, postfix, index) => {
+ let endIndex = 0;
+ let returnValue = "";
+ do {
+ const gotCR = string[index - 1] === "\r";
+ returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+ endIndex = index + 1;
+ index = string.indexOf("\n", endIndex);
+ } while (index !== -1);
+ returnValue += string.substr(endIndex);
+ return returnValue;
+ };
+ module2.exports = {
+ stringReplaceAll,
+ stringEncaseCRLFWithFirstIndex
+ };
+ }
+});
+
+// pnp:chalk-npm-4.1.2-ba8b67ab80-fe75c9d5c7.zip/node_modules/chalk/source/templates.js
+var require_templates = __commonJS({
+ "pnp:chalk-npm-4.1.2-ba8b67ab80-fe75c9d5c7.zip/node_modules/chalk/source/templates.js"(exports, module2) {
+ "use strict";
+ var TEMPLATE_REGEX = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+ var STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+ var STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+ var ESCAPE_REGEX = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
+ var ESCAPES = new Map([
+ ["n", "\n"],
+ ["r", "\r"],
+ ["t", " "],
+ ["b", "\b"],
+ ["f", "\f"],
+ ["v", "\v"],
+ ["0", "\0"],
+ ["\\", "\\"],
+ ["e", ""],
+ ["a", "\x07"]
+ ]);
+ function unescape(c) {
+ const u = c[0] === "u";
+ const bracket = c[1] === "{";
+ if (u && !bracket && c.length === 5 || c[0] === "x" && c.length === 3) {
+ return String.fromCharCode(parseInt(c.slice(1), 16));
+ }
+ if (u && bracket) {
+ return String.fromCodePoint(parseInt(c.slice(2, -1), 16));
+ }
+ return ESCAPES.get(c) || c;
+ }
+ function parseArguments(name, arguments_) {
+ const results = [];
+ const chunks = arguments_.trim().split(/\s*,\s*/g);
+ let matches;
+ for (const chunk of chunks) {
+ const number = Number(chunk);
+ if (!Number.isNaN(number)) {
+ results.push(number);
+ } else if (matches = chunk.match(STRING_REGEX)) {
+ results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
+ } else {
+ throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+ }
+ }
+ return results;
+ }
+ function parseStyle(style) {
+ STYLE_REGEX.lastIndex = 0;
+ const results = [];
+ let matches;
+ while ((matches = STYLE_REGEX.exec(style)) !== null) {
+ const name = matches[1];
+ if (matches[2]) {
+ const args = parseArguments(name, matches[2]);
+ results.push([name].concat(args));
+ } else {
+ results.push([name]);
+ }
+ }
+ return results;
+ }
+ function buildStyle(chalk5, styles) {
+ const enabled = {};
+ for (const layer of styles) {
+ for (const style of layer.styles) {
+ enabled[style[0]] = layer.inverse ? null : style.slice(1);
+ }
+ }
+ let current = chalk5;
+ for (const [styleName, styles2] of Object.entries(enabled)) {
+ if (!Array.isArray(styles2)) {
+ continue;
+ }
+ if (!(styleName in current)) {
+ throw new Error(`Unknown Chalk style: ${styleName}`);
+ }
+ current = styles2.length > 0 ? current[styleName](...styles2) : current[styleName];
+ }
+ return current;
+ }
+ module2.exports = (chalk5, temporary) => {
+ const styles = [];
+ const chunks = [];
+ let chunk = [];
+ temporary.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
+ if (escapeCharacter) {
+ chunk.push(unescape(escapeCharacter));
+ } else if (style) {
+ const string = chunk.join("");
+ chunk = [];
+ chunks.push(styles.length === 0 ? string : buildStyle(chalk5, styles)(string));
+ styles.push({ inverse, styles: parseStyle(style) });
+ } else if (close) {
+ if (styles.length === 0) {
+ throw new Error("Found extraneous } in Chalk template literal");
+ }
+ chunks.push(buildStyle(chalk5, styles)(chunk.join("")));
+ chunk = [];
+ styles.pop();
+ } else {
+ chunk.push(character);
+ }
+ });
+ chunks.push(chunk.join(""));
+ if (styles.length > 0) {
+ const errMessage = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
+ throw new Error(errMessage);
+ }
+ return chunks.join("");
+ };
+ }
+});
+
+// pnp:chalk-npm-4.1.2-ba8b67ab80-fe75c9d5c7.zip/node_modules/chalk/source/index.js
+var require_source = __commonJS({
+ "pnp:chalk-npm-4.1.2-ba8b67ab80-fe75c9d5c7.zip/node_modules/chalk/source/index.js"(exports, module2) {
+ "use strict";
+ var ansiStyles = require_ansi_styles();
+ var { stdout: stdoutColor, stderr: stderrColor } = require_supports_color();
+ var {
+ stringReplaceAll,
+ stringEncaseCRLFWithFirstIndex
+ } = require_util();
+ var { isArray } = Array;
+ var levelMapping = [
+ "ansi",
+ "ansi",
+ "ansi256",
+ "ansi16m"
+ ];
+ var styles = Object.create(null);
+ var applyOptions = (object, options = {}) => {
+ if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+ throw new Error("The `level` option should be an integer from 0 to 3");
+ }
+ const colorLevel = stdoutColor ? stdoutColor.level : 0;
+ object.level = options.level === void 0 ? colorLevel : options.level;
+ };
+ var ChalkClass = class {
+ constructor(options) {
+ return chalkFactory(options);
+ }
+ };
+ var chalkFactory = (options) => {
+ const chalk6 = {};
+ applyOptions(chalk6, options);
+ chalk6.template = (...arguments_) => chalkTag(chalk6.template, ...arguments_);
+ Object.setPrototypeOf(chalk6, Chalk.prototype);
+ Object.setPrototypeOf(chalk6.template, chalk6);
+ chalk6.template.constructor = () => {
+ throw new Error("`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead.");
+ };
+ chalk6.template.Instance = ChalkClass;
+ return chalk6.template;
+ };
+ function Chalk(options) {
+ return chalkFactory(options);
+ }
+ for (const [styleName, style] of Object.entries(ansiStyles)) {
+ styles[styleName] = {
+ get() {
+ const builder = createBuilder(this, createStyler(style.open, style.close, this._styler), this._isEmpty);
+ Object.defineProperty(this, styleName, { value: builder });
+ return builder;
+ }
+ };
+ }
+ styles.visible = {
+ get() {
+ const builder = createBuilder(this, this._styler, true);
+ Object.defineProperty(this, "visible", { value: builder });
+ return builder;
+ }
+ };
+ var usedModels = ["rgb", "hex", "keyword", "hsl", "hsv", "hwb", "ansi", "ansi256"];
+ for (const model of usedModels) {
+ styles[model] = {
+ get() {
+ const { level } = this;
+ return function(...arguments_) {
+ const styler = createStyler(ansiStyles.color[levelMapping[level]][model](...arguments_), ansiStyles.color.close, this._styler);
+ return createBuilder(this, styler, this._isEmpty);
+ };
+ }
+ };
+ }
+ for (const model of usedModels) {
+ const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+ styles[bgModel] = {
+ get() {
+ const { level } = this;
+ return function(...arguments_) {
+ const styler = createStyler(ansiStyles.bgColor[levelMapping[level]][model](...arguments_), ansiStyles.bgColor.close, this._styler);
+ return createBuilder(this, styler, this._isEmpty);
+ };
+ }
+ };
+ }
+ var proto = Object.defineProperties(() => {
+ }, __spreadProps(__spreadValues({}, styles), {
+ level: {
+ enumerable: true,
+ get() {
+ return this._generator.level;
+ },
+ set(level) {
+ this._generator.level = level;
+ }
+ }
+ }));
+ var createStyler = (open, close, parent) => {
+ let openAll;
+ let closeAll;
+ if (parent === void 0) {
+ openAll = open;
+ closeAll = close;
+ } else {
+ openAll = parent.openAll + open;
+ closeAll = close + parent.closeAll;
+ }
+ return {
+ open,
+ close,
+ openAll,
+ closeAll,
+ parent
+ };
+ };
+ var createBuilder = (self, _styler, _isEmpty) => {
+ const builder = (...arguments_) => {
+ if (isArray(arguments_[0]) && isArray(arguments_[0].raw)) {
+ return applyStyle(builder, chalkTag(builder, ...arguments_));
+ }
+ return applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+ };
+ Object.setPrototypeOf(builder, proto);
+ builder._generator = self;
+ builder._styler = _styler;
+ builder._isEmpty = _isEmpty;
+ return builder;
+ };
+ var applyStyle = (self, string) => {
+ if (self.level <= 0 || !string) {
+ return self._isEmpty ? "" : string;
+ }
+ let styler = self._styler;
+ if (styler === void 0) {
+ return string;
+ }
+ const { openAll, closeAll } = styler;
+ if (string.indexOf("") !== -1) {
+ while (styler !== void 0) {
+ string = stringReplaceAll(string, styler.close, styler.open);
+ styler = styler.parent;
+ }
+ }
+ const lfIndex = string.indexOf("\n");
+ if (lfIndex !== -1) {
+ string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+ }
+ return openAll + string + closeAll;
+ };
+ var template;
+ var chalkTag = (chalk6, ...strings) => {
+ const [firstString] = strings;
+ if (!isArray(firstString) || !isArray(firstString.raw)) {
+ return strings.join(" ");
+ }
+ const arguments_ = strings.slice(1);
+ const parts = [firstString.raw[0]];
+ for (let i = 1; i < firstString.length; i++) {
+ parts.push(String(arguments_[i - 1]).replace(/[{}\\]/g, "\\$&"), String(firstString.raw[i]));
+ }
+ if (template === void 0) {
+ template = require_templates();
+ }
+ return template(chalk6, parts.join(""));
+ };
+ Object.defineProperties(Chalk.prototype, styles);
+ var chalk5 = Chalk();
+ chalk5.supportsColor = stdoutColor;
+ chalk5.stderr = Chalk({ level: stderrColor ? stderrColor.level : 0 });
+ chalk5.stderr.supportsColor = stderrColor;
+ module2.exports = chalk5;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/lowercase.js
+var require_lowercase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/lowercase.js"(exports, module2) {
+ "use strict";
+ function lowercase(str) {
+ str = String(str);
+ if (!str) {
+ return str;
+ }
+ return str.toLowerCase();
+ }
+ lowercase.isLowercase = function(str) {
+ return str && !/[A-Z]+/.test(str);
+ };
+ module2.exports = lowercase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/uppercase.js
+var require_uppercase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/uppercase.js"(exports, module2) {
+ "use strict";
+ function uppercase(str) {
+ str = String(str);
+ if (!str) {
+ return str;
+ }
+ return str.toUpperCase();
+ }
+ uppercase.isUppercase = function(str) {
+ return str && !/[a-z]+/.test(str);
+ };
+ module2.exports = uppercase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/camelcase.js
+var require_camelcase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/camelcase.js"(exports, module2) {
+ "use strict";
+ var lowercase = require_lowercase();
+ var uppercase = require_uppercase();
+ var replacing = {
+ from: /[\-_:\.\s]([a-zA-Z])([a-zA-Z]*)/g,
+ to: function(match, $1, $2, offset, src) {
+ const len = $1.length;
+ return uppercase($1) + $2;
+ }
+ };
+ function camelcase2(str) {
+ if (camelcase2.isCamelcase(str)) {
+ return str;
+ }
+ str = String(str).replace(/^[\-_:\.\s]/, "");
+ if (!str) {
+ return str;
+ }
+ if (uppercase.isUppercase(str)) {
+ str = lowercase(str);
+ }
+ return lowercase(str[0]) + str.replace(replacing.from, replacing.to).slice(1).replace(/^([A-Z]+)([A-Z])/, (match, $1, $2) => lowercase($1) + $2);
+ }
+ camelcase2.isCamelcase = function(str) {
+ return str && /^[a-zA-Z]+$/.test(str) && lowercase(str[0]) === str[0];
+ };
+ module2.exports = camelcase2;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/capitalcase.js
+var require_capitalcase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/capitalcase.js"(exports, module2) {
+ "use strict";
+ var uppercase = require_uppercase();
+ function capitalcase(str) {
+ str = String(str);
+ if (!str) {
+ return str;
+ }
+ return uppercase(str[0]) + str.slice(1);
+ }
+ module2.exports = capitalcase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/snakecase.js
+var require_snakecase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/snakecase.js"(exports, module2) {
+ "use strict";
+ var lowercase = require_lowercase();
+ var uppercase = require_uppercase();
+ var JOINER = "_";
+ var replacing = {
+ from: /([A-Z]+)/g,
+ to(match, $1, offset, src) {
+ const prefix = offset === 0 ? "" : JOINER;
+ const len = $1.length;
+ if (len === 1) {
+ return prefix + lowercase($1);
+ }
+ const next = src.slice(offset + $1.length);
+ const isOneWord = uppercase.isUppercase($1) && next[0] === JOINER;
+ if (isOneWord) {
+ return prefix + lowercase($1);
+ }
+ const replaced = lowercase($1.substr(0, len - 1)) + JOINER + lowercase($1[len - 1]);
+ return prefix + replaced;
+ }
+ };
+ function snakecase(str) {
+ if (snakecase.isSnakecase(str)) {
+ return str;
+ }
+ str = String(str).replace(/[\-.:\s]/g, JOINER);
+ if (!str) {
+ return str;
+ }
+ if (uppercase.isUppercase(str)) {
+ str = lowercase(str);
+ }
+ return str.replace(replacing.from, replacing.to).replace(/_+/g, "_");
+ }
+ snakecase.isSnakecase = function(str) {
+ return str && /^[a-z_]+$/.test(str);
+ };
+ module2.exports = snakecase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/constcase.js
+var require_constcase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/constcase.js"(exports, module2) {
+ "use strict";
+ var uppercase = require_uppercase();
+ var snakecase = require_snakecase();
+ function constcase2(str) {
+ if (constcase2.isConstcase(str)) {
+ return str;
+ }
+ return uppercase(snakecase(str));
+ }
+ constcase2.isConstcase = function(str) {
+ return str && /^[A-Z_]+$/.test(str);
+ };
+ module2.exports = constcase2;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/cramcase.js
+var require_cramcase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/cramcase.js"(exports, module2) {
+ "use strict";
+ var snakecase = require_snakecase();
+ function cramcase(str) {
+ return snakecase(str).replace(/_/g, "");
+ }
+ module2.exports = cramcase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/decapitalcase.js
+var require_decapitalcase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/decapitalcase.js"(exports, module2) {
+ "use strict";
+ var lowercase = require_lowercase();
+ function capitalcase(str) {
+ str = String(str);
+ if (!str) {
+ return str;
+ }
+ return lowercase(str[0]) + str.slice(1);
+ }
+ module2.exports = capitalcase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/dotcase.js
+var require_dotcase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/dotcase.js"(exports, module2) {
+ "use strict";
+ var snakecase = require_snakecase();
+ function dotcase(str) {
+ return snakecase(str).replace(/_/g, ".");
+ }
+ module2.exports = dotcase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/enumcase.js
+var require_enumcase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/enumcase.js"(exports, module2) {
+ "use strict";
+ var snakecase = require_snakecase();
+ function enumcase(str) {
+ return snakecase(str).replace(/_/g, ":");
+ }
+ module2.exports = enumcase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/pascalcase.js
+var require_pascalcase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/pascalcase.js"(exports, module2) {
+ "use strict";
+ var camelcase2 = require_camelcase();
+ var capitalcase = require_capitalcase();
+ function pascalcase(str) {
+ return capitalcase(camelcase2(str));
+ }
+ module2.exports = pascalcase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/pathcase.js
+var require_pathcase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/pathcase.js"(exports, module2) {
+ "use strict";
+ var snakecase = require_snakecase();
+ function pathcase(str) {
+ return snakecase(str).replace(/_/g, "/");
+ }
+ module2.exports = pathcase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/trimcase.js
+var require_trimcase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/trimcase.js"(exports, module2) {
+ "use strict";
+ function trimcase(str) {
+ return String(str).trim();
+ }
+ module2.exports = trimcase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/sentencecase.js
+var require_sentencecase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/sentencecase.js"(exports, module2) {
+ "use strict";
+ var lowercase = require_lowercase();
+ var trimcase = require_trimcase();
+ var snakecase = require_snakecase();
+ var capitalcase = require_capitalcase();
+ var JOINER = " ";
+ function sentencecase(str) {
+ str = String(str).replace(/^[\-_\.\s]/g, JOINER);
+ if (!str) {
+ return str;
+ }
+ return capitalcase(snakecase(trimcase(str)).replace(/_/g, JOINER));
+ }
+ module2.exports = sentencecase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/spacecase.js
+var require_spacecase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/spacecase.js"(exports, module2) {
+ "use strict";
+ var snakecase = require_snakecase();
+ function spacecase(str) {
+ return snakecase(str).replace(/_/g, " ");
+ }
+ module2.exports = spacecase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/spinalcase.js
+var require_spinalcase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/spinalcase.js"(exports, module2) {
+ "use strict";
+ var snakecase = require_snakecase();
+ function spinalcase2(str) {
+ return snakecase(str).replace(/_/g, "-");
+ }
+ module2.exports = spinalcase2;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/titlecase.js
+var require_titlecase = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/titlecase.js"(exports, module2) {
+ "use strict";
+ var snakecase = require_snakecase();
+ var lowercase = require_lowercase();
+ var trimcase = require_trimcase();
+ var capitalcase = require_capitalcase();
+ var LOWERCASE_WORDS = "a,the,and,or,not,but,for,of".split(",");
+ function titlecase(str) {
+ return snakecase(str).split(/_/g).map(trimcase).map(function(word) {
+ var lower = !!~LOWERCASE_WORDS.indexOf(word);
+ if (lower) {
+ return lowercase(word);
+ } else {
+ return capitalcase(word);
+ }
+ }).join(" ");
+ }
+ module2.exports = titlecase;
+ }
+});
+
+// pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/index.js
+var require_lib = __commonJS({
+ "pnp:stringcase-npm-4.3.1-2f1c329337-741a448632.zip/node_modules/stringcase/lib/index.js"(exports, module2) {
+ "use strict";
+ var camelcase2 = require_camelcase();
+ var capitalcase = require_capitalcase();
+ var constcase2 = require_constcase();
+ var cramcase = require_cramcase();
+ var decapitalcase = require_decapitalcase();
+ var dotcase = require_dotcase();
+ var enumcase = require_enumcase();
+ var lowercase = require_lowercase();
+ var pascalcase = require_pascalcase();
+ var pathcase = require_pathcase();
+ var sentencecase = require_sentencecase();
+ var snakecase = require_snakecase();
+ var spacecase = require_spacecase();
+ var spinalcase2 = require_spinalcase();
+ var titlecase = require_titlecase();
+ var trimcase = require_trimcase();
+ var uppercase = require_uppercase();
+ exports.camelcase = camelcase2;
+ exports.capitalcase = capitalcase;
+ exports.constcase = constcase2;
+ exports.cramcase = cramcase;
+ exports.decapitalcase = decapitalcase;
+ exports.dotcase = dotcase;
+ exports.enumcase = enumcase;
+ exports.lowercase = lowercase;
+ exports.pascalcase = pascalcase;
+ exports.pathcase = pathcase;
+ exports.sentencecase = sentencecase;
+ exports.snakecase = snakecase;
+ exports.spacecase = spacecase;
+ exports.spinalcase = spinalcase2;
+ exports.titlecase = titlecase;
+ exports.trimcase = trimcase;
+ exports.uppercase = uppercase;
+ module2.exports = {
+ camelcase: camelcase2,
+ capitalcase,
+ constcase: constcase2,
+ cramcase,
+ decapitalcase,
+ dotcase,
+ enumcase,
+ lowercase,
+ pascalcase,
+ pathcase,
+ sentencecase,
+ snakecase,
+ spacecase,
+ spinalcase: spinalcase2,
+ titlecase,
+ trimcase,
+ uppercase
+ };
+ }
+});
+
+// pnp:fs.realpath-npm-1.0.0-c8f05d8126-99ddea01a7.zip/node_modules/fs.realpath/old.js
+var require_old = __commonJS({
+ "pnp:fs.realpath-npm-1.0.0-c8f05d8126-99ddea01a7.zip/node_modules/fs.realpath/old.js"(exports) {
+ var pathModule = require("path");
+ var isWindows = process.platform === "win32";
+ var fs4 = require("fs");
+ var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
+ function rethrow() {
+ var callback;
+ if (DEBUG) {
+ var backtrace = new Error();
+ callback = debugCallback;
+ } else
+ callback = missingCallback;
+ return callback;
+ function debugCallback(err) {
+ if (err) {
+ backtrace.message = err.message;
+ err = backtrace;
+ missingCallback(err);
+ }
+ }
+ function missingCallback(err) {
+ if (err) {
+ if (process.throwDeprecation)
+ throw err;
+ else if (!process.noDeprecation) {
+ var msg = "fs: missing callback " + (err.stack || err.message);
+ if (process.traceDeprecation)
+ console.trace(msg);
+ else
+ console.error(msg);
+ }
+ }
+ }
+ }
+ function maybeCallback(cb) {
+ return typeof cb === "function" ? cb : rethrow();
+ }
+ var normalize = pathModule.normalize;
+ if (isWindows) {
+ nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
+ } else {
+ nextPartRe = /(.*?)(?:[\/]+|$)/g;
+ }
+ var nextPartRe;
+ if (isWindows) {
+ splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
+ } else {
+ splitRootRe = /^[\/]*/;
+ }
+ var splitRootRe;
+ exports.realpathSync = function realpathSync(p, cache) {
+ p = pathModule.resolve(p);
+ if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+ return cache[p];
+ }
+ var original = p, seenLinks = {}, knownHard = {};
+ var pos;
+ var current;
+ var base;
+ var previous;
+ start();
+ function start() {
+ var m = splitRootRe.exec(p);
+ pos = m[0].length;
+ current = m[0];
+ base = m[0];
+ previous = "";
+ if (isWindows && !knownHard[base]) {
+ fs4.lstatSync(base);
+ knownHard[base] = true;
+ }
+ }
+ while (pos < p.length) {
+ nextPartRe.lastIndex = pos;
+ var result = nextPartRe.exec(p);
+ previous = current;
+ current += result[0];
+ base = previous + result[1];
+ pos = nextPartRe.lastIndex;
+ if (knownHard[base] || cache && cache[base] === base) {
+ continue;
+ }
+ var resolvedLink;
+ if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+ resolvedLink = cache[base];
+ } else {
+ var stat = fs4.lstatSync(base);
+ if (!stat.isSymbolicLink()) {
+ knownHard[base] = true;
+ if (cache)
+ cache[base] = base;
+ continue;
+ }
+ var linkTarget = null;
+ if (!isWindows) {
+ var id = stat.dev.toString(32) + ":" + stat.ino.toString(32);
+ if (seenLinks.hasOwnProperty(id)) {
+ linkTarget = seenLinks[id];
+ }
+ }
+ if (linkTarget === null) {
+ fs4.statSync(base);
+ linkTarget = fs4.readlinkSync(base);
+ }
+ resolvedLink = pathModule.resolve(previous, linkTarget);
+ if (cache)
+ cache[base] = resolvedLink;
+ if (!isWindows)
+ seenLinks[id] = linkTarget;
+ }
+ p = pathModule.resolve(resolvedLink, p.slice(pos));
+ start();
+ }
+ if (cache)
+ cache[original] = p;
+ return p;
+ };
+ exports.realpath = function realpath(p, cache, cb) {
+ if (typeof cb !== "function") {
+ cb = maybeCallback(cache);
+ cache = null;
+ }
+ p = pathModule.resolve(p);
+ if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+ return process.nextTick(cb.bind(null, null, cache[p]));
+ }
+ var original = p, seenLinks = {}, knownHard = {};
+ var pos;
+ var current;
+ var base;
+ var previous;
+ start();
+ function start() {
+ var m = splitRootRe.exec(p);
+ pos = m[0].length;
+ current = m[0];
+ base = m[0];
+ previous = "";
+ if (isWindows && !knownHard[base]) {
+ fs4.lstat(base, function(err) {
+ if (err)
+ return cb(err);
+ knownHard[base] = true;
+ LOOP();
+ });
+ } else {
+ process.nextTick(LOOP);
+ }
+ }
+ function LOOP() {
+ if (pos >= p.length) {
+ if (cache)
+ cache[original] = p;
+ return cb(null, p);
+ }
+ nextPartRe.lastIndex = pos;
+ var result = nextPartRe.exec(p);
+ previous = current;
+ current += result[0];
+ base = previous + result[1];
+ pos = nextPartRe.lastIndex;
+ if (knownHard[base] || cache && cache[base] === base) {
+ return process.nextTick(LOOP);
+ }
+ if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+ return gotResolvedLink(cache[base]);
+ }
+ return fs4.lstat(base, gotStat);
+ }
+ function gotStat(err, stat) {
+ if (err)
+ return cb(err);
+ if (!stat.isSymbolicLink()) {
+ knownHard[base] = true;
+ if (cache)
+ cache[base] = base;
+ return process.nextTick(LOOP);
+ }
+ if (!isWindows) {
+ var id = stat.dev.toString(32) + ":" + stat.ino.toString(32);
+ if (seenLinks.hasOwnProperty(id)) {
+ return gotTarget(null, seenLinks[id], base);
+ }
+ }
+ fs4.stat(base, function(err2) {
+ if (err2)
+ return cb(err2);
+ fs4.readlink(base, function(err3, target) {
+ if (!isWindows)
+ seenLinks[id] = target;
+ gotTarget(err3, target);
+ });
+ });
+ }
+ function gotTarget(err, target, base2) {
+ if (err)
+ return cb(err);
+ var resolvedLink = pathModule.resolve(previous, target);
+ if (cache)
+ cache[base2] = resolvedLink;
+ gotResolvedLink(resolvedLink);
+ }
+ function gotResolvedLink(resolvedLink) {
+ p = pathModule.resolve(resolvedLink, p.slice(pos));
+ start();
+ }
+ };
+ }
+});
+
+// pnp:fs.realpath-npm-1.0.0-c8f05d8126-99ddea01a7.zip/node_modules/fs.realpath/index.js
+var require_fs = __commonJS({
+ "pnp:fs.realpath-npm-1.0.0-c8f05d8126-99ddea01a7.zip/node_modules/fs.realpath/index.js"(exports, module2) {
+ module2.exports = realpath;
+ realpath.realpath = realpath;
+ realpath.sync = realpathSync;
+ realpath.realpathSync = realpathSync;
+ realpath.monkeypatch = monkeypatch;
+ realpath.unmonkeypatch = unmonkeypatch;
+ var fs4 = require("fs");
+ var origRealpath = fs4.realpath;
+ var origRealpathSync = fs4.realpathSync;
+ var version2 = process.version;
+ var ok = /^v[0-5]\./.test(version2);
+ var old = require_old();
+ function newError(er) {
+ return er && er.syscall === "realpath" && (er.code === "ELOOP" || er.code === "ENOMEM" || er.code === "ENAMETOOLONG");
+ }
+ function realpath(p, cache, cb) {
+ if (ok) {
+ return origRealpath(p, cache, cb);
+ }
+ if (typeof cache === "function") {
+ cb = cache;
+ cache = null;
+ }
+ origRealpath(p, cache, function(er, result) {
+ if (newError(er)) {
+ old.realpath(p, cache, cb);
+ } else {
+ cb(er, result);
+ }
+ });
+ }
+ function realpathSync(p, cache) {
+ if (ok) {
+ return origRealpathSync(p, cache);
+ }
+ try {
+ return origRealpathSync(p, cache);
+ } catch (er) {
+ if (newError(er)) {
+ return old.realpathSync(p, cache);
+ } else {
+ throw er;
+ }
+ }
+ }
+ function monkeypatch() {
+ fs4.realpath = realpath;
+ fs4.realpathSync = realpathSync;
+ }
+ function unmonkeypatch() {
+ fs4.realpath = origRealpath;
+ fs4.realpathSync = origRealpathSync;
+ }
+ }
+});
+
+// pnp:concat-map-npm-0.0.1-85a921b7ee-902a9f5d89.zip/node_modules/concat-map/index.js
+var require_concat_map = __commonJS({
+ "pnp:concat-map-npm-0.0.1-85a921b7ee-902a9f5d89.zip/node_modules/concat-map/index.js"(exports, module2) {
+ module2.exports = function(xs, fn) {
+ var res = [];
+ for (var i = 0; i < xs.length; i++) {
+ var x = fn(xs[i], i);
+ if (isArray(x))
+ res.push.apply(res, x);
+ else
+ res.push(x);
+ }
+ return res;
+ };
+ var isArray = Array.isArray || function(xs) {
+ return Object.prototype.toString.call(xs) === "[object Array]";
+ };
+ }
+});
+
+// pnp:balanced-match-npm-1.0.0-951a2ad706-9b67bfe558.zip/node_modules/balanced-match/index.js
+var require_balanced_match = __commonJS({
+ "pnp:balanced-match-npm-1.0.0-951a2ad706-9b67bfe558.zip/node_modules/balanced-match/index.js"(exports, module2) {
+ "use strict";
+ module2.exports = balanced;
+ function balanced(a, b, str) {
+ if (a instanceof RegExp)
+ a = maybeMatch(a, str);
+ if (b instanceof RegExp)
+ b = maybeMatch(b, str);
+ var r = range(a, b, str);
+ return r && {
+ start: r[0],
+ end: r[1],
+ pre: str.slice(0, r[0]),
+ body: str.slice(r[0] + a.length, r[1]),
+ post: str.slice(r[1] + b.length)
+ };
+ }
+ function maybeMatch(reg, str) {
+ var m = str.match(reg);
+ return m ? m[0] : null;
+ }
+ balanced.range = range;
+ function range(a, b, str) {
+ var begs, beg, left, right, result;
+ var ai = str.indexOf(a);
+ var bi = str.indexOf(b, ai + 1);
+ var i = ai;
+ if (ai >= 0 && bi > 0) {
+ begs = [];
+ left = str.length;
+ while (i >= 0 && !result) {
+ if (i == ai) {
+ begs.push(i);
+ ai = str.indexOf(a, i + 1);
+ } else if (begs.length == 1) {
+ result = [begs.pop(), bi];
+ } else {
+ beg = begs.pop();
+ if (beg < left) {
+ left = beg;
+ right = bi;
+ }
+ bi = str.indexOf(b, i + 1);
+ }
+ i = ai < bi && ai >= 0 ? ai : bi;
+ }
+ if (begs.length) {
+ result = [left, right];
+ }
+ }
+ return result;
+ }
+ }
+});
+
+// pnp:brace-expansion-npm-1.1.11-fb95eb05ad-faf34a7bb0.zip/node_modules/brace-expansion/index.js
+var require_brace_expansion = __commonJS({
+ "pnp:brace-expansion-npm-1.1.11-fb95eb05ad-faf34a7bb0.zip/node_modules/brace-expansion/index.js"(exports, module2) {
+ var concatMap = require_concat_map();
+ var balanced = require_balanced_match();
+ module2.exports = expandTop;
+ var escSlash = "\0SLASH" + Math.random() + "\0";
+ var escOpen = "\0OPEN" + Math.random() + "\0";
+ var escClose = "\0CLOSE" + Math.random() + "\0";
+ var escComma = "\0COMMA" + Math.random() + "\0";
+ var escPeriod = "\0PERIOD" + Math.random() + "\0";
+ function numeric(str) {
+ return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+ }
+ function escapeBraces(str) {
+ return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+ }
+ function unescapeBraces(str) {
+ return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+ }
+ function parseCommaParts(str) {
+ if (!str)
+ return [""];
+ var parts = [];
+ var m = balanced("{", "}", str);
+ if (!m)
+ return str.split(",");
+ var pre = m.pre;
+ var body = m.body;
+ var post = m.post;
+ var p = pre.split(",");
+ p[p.length - 1] += "{" + body + "}";
+ var postParts = parseCommaParts(post);
+ if (post.length) {
+ p[p.length - 1] += postParts.shift();
+ p.push.apply(p, postParts);
+ }
+ parts.push.apply(parts, p);
+ return parts;
+ }
+ function expandTop(str) {
+ if (!str)
+ return [];
+ if (str.substr(0, 2) === "{}") {
+ str = "\\{\\}" + str.substr(2);
+ }
+ return expand(escapeBraces(str), true).map(unescapeBraces);
+ }
+ function embrace(str) {
+ return "{" + str + "}";
+ }
+ function isPadded(el) {
+ return /^-?0\d/.test(el);
+ }
+ function lte(i, y) {
+ return i <= y;
+ }
+ function gte(i, y) {
+ return i >= y;
+ }
+ function expand(str, isTop) {
+ var expansions = [];
+ var m = balanced("{", "}", str);
+ if (!m || /\$$/.test(m.pre))
+ return [str];
+ var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+ var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+ var isSequence = isNumericSequence || isAlphaSequence;
+ var isOptions = m.body.indexOf(",") >= 0;
+ if (!isSequence && !isOptions) {
+ if (m.post.match(/,.*\}/)) {
+ str = m.pre + "{" + m.body + escClose + m.post;
+ return expand(str);
+ }
+ return [str];
+ }
+ var n;
+ if (isSequence) {
+ n = m.body.split(/\.\./);
+ } else {
+ n = parseCommaParts(m.body);
+ if (n.length === 1) {
+ n = expand(n[0], false).map(embrace);
+ if (n.length === 1) {
+ var post = m.post.length ? expand(m.post, false) : [""];
+ return post.map(function(p) {
+ return m.pre + n[0] + p;
+ });
+ }
+ }
+ }
+ var pre = m.pre;
+ var post = m.post.length ? expand(m.post, false) : [""];
+ var N;
+ if (isSequence) {
+ var x = numeric(n[0]);
+ var y = numeric(n[1]);
+ var width = Math.max(n[0].length, n[1].length);
+ var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
+ var test = lte;
+ var reverse = y < x;
+ if (reverse) {
+ incr *= -1;
+ test = gte;
+ }
+ var pad = n.some(isPadded);
+ N = [];
+ for (var i = x; test(i, y); i += incr) {
+ var c;
+ if (isAlphaSequence) {
+ c = String.fromCharCode(i);
+ if (c === "\\")
+ c = "";
+ } else {
+ c = String(i);
+ if (pad) {
+ var need = width - c.length;
+ if (need > 0) {
+ var z = new Array(need + 1).join("0");
+ if (i < 0)
+ c = "-" + z + c.slice(1);
+ else
+ c = z + c;
+ }
+ }
+ }
+ N.push(c);
+ }
+ } else {
+ N = concatMap(n, function(el) {
+ return expand(el, false);
+ });
+ }
+ for (var j = 0; j < N.length; j++) {
+ for (var k = 0; k < post.length; k++) {
+ var expansion = pre + N[j] + post[k];
+ if (!isTop || isSequence || expansion)
+ expansions.push(expansion);
+ }
+ }
+ return expansions;
+ }
+ }
+});
+
+// pnp:minimatch-npm-3.0.4-6e76f51c23-66ac295f8a.zip/node_modules/minimatch/minimatch.js
+var require_minimatch = __commonJS({
+ "pnp:minimatch-npm-3.0.4-6e76f51c23-66ac295f8a.zip/node_modules/minimatch/minimatch.js"(exports, module2) {
+ module2.exports = minimatch;
+ minimatch.Minimatch = Minimatch;
+ var path2 = { sep: "/" };
+ try {
+ path2 = require("path");
+ } catch (er) {
+ }
+ var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
+ var expand = require_brace_expansion();
+ var plTypes = {
+ "!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
+ "?": { open: "(?:", close: ")?" },
+ "+": { open: "(?:", close: ")+" },
+ "*": { open: "(?:", close: ")*" },
+ "@": { open: "(?:", close: ")" }
+ };
+ var qmark = "[^/]";
+ var star = qmark + "*?";
+ var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+ var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+ var reSpecials = charSet("().*{}+?[]^$\\!");
+ function charSet(s) {
+ return s.split("").reduce(function(set, c) {
+ set[c] = true;
+ return set;
+ }, {});
+ }
+ var slashSplit = /\/+/;
+ minimatch.filter = filter;
+ function filter(pattern, options) {
+ options = options || {};
+ return function(p, i, list) {
+ return minimatch(p, pattern, options);
+ };
+ }
+ function ext(a, b) {
+ a = a || {};
+ b = b || {};
+ var t = {};
+ Object.keys(b).forEach(function(k) {
+ t[k] = b[k];
+ });
+ Object.keys(a).forEach(function(k) {
+ t[k] = a[k];
+ });
+ return t;
+ }
+ minimatch.defaults = function(def) {
+ if (!def || !Object.keys(def).length)
+ return minimatch;
+ var orig = minimatch;
+ var m = function minimatch2(p, pattern, options) {
+ return orig.minimatch(p, pattern, ext(def, options));
+ };
+ m.Minimatch = function Minimatch2(pattern, options) {
+ return new orig.Minimatch(pattern, ext(def, options));
+ };
+ return m;
+ };
+ Minimatch.defaults = function(def) {
+ if (!def || !Object.keys(def).length)
+ return Minimatch;
+ return minimatch.defaults(def).Minimatch;
+ };
+ function minimatch(p, pattern, options) {
+ if (typeof pattern !== "string") {
+ throw new TypeError("glob pattern string required");
+ }
+ if (!options)
+ options = {};
+ if (!options.nocomment && pattern.charAt(0) === "#") {
+ return false;
+ }
+ if (pattern.trim() === "")
+ return p === "";
+ return new Minimatch(pattern, options).match(p);
+ }
+ function Minimatch(pattern, options) {
+ if (!(this instanceof Minimatch)) {
+ return new Minimatch(pattern, options);
+ }
+ if (typeof pattern !== "string") {
+ throw new TypeError("glob pattern string required");
+ }
+ if (!options)
+ options = {};
+ pattern = pattern.trim();
+ if (path2.sep !== "/") {
+ pattern = pattern.split(path2.sep).join("/");
+ }
+ this.options = options;
+ this.set = [];
+ this.pattern = pattern;
+ this.regexp = null;
+ this.negate = false;
+ this.comment = false;
+ this.empty = false;
+ this.make();
+ }
+ Minimatch.prototype.debug = function() {
+ };
+ Minimatch.prototype.make = make;
+ function make() {
+ if (this._made)
+ return;
+ var pattern = this.pattern;
+ var options = this.options;
+ if (!options.nocomment && pattern.charAt(0) === "#") {
+ this.comment = true;
+ return;
+ }
+ if (!pattern) {
+ this.empty = true;
+ return;
+ }
+ this.parseNegate();
+ var set = this.globSet = this.braceExpand();
+ if (options.debug)
+ this.debug = console.error;
+ this.debug(this.pattern, set);
+ set = this.globParts = set.map(function(s) {
+ return s.split(slashSplit);
+ });
+ this.debug(this.pattern, set);
+ set = set.map(function(s, si, set2) {
+ return s.map(this.parse, this);
+ }, this);
+ this.debug(this.pattern, set);
+ set = set.filter(function(s) {
+ return s.indexOf(false) === -1;
+ });
+ this.debug(this.pattern, set);
+ this.set = set;
+ }
+ Minimatch.prototype.parseNegate = parseNegate;
+ function parseNegate() {
+ var pattern = this.pattern;
+ var negate = false;
+ var options = this.options;
+ var negateOffset = 0;
+ if (options.nonegate)
+ return;
+ for (var i = 0, l = pattern.length; i < l && pattern.charAt(i) === "!"; i++) {
+ negate = !negate;
+ negateOffset++;
+ }
+ if (negateOffset)
+ this.pattern = pattern.substr(negateOffset);
+ this.negate = negate;
+ }
+ minimatch.braceExpand = function(pattern, options) {
+ return braceExpand(pattern, options);
+ };
+ Minimatch.prototype.braceExpand = braceExpand;
+ function braceExpand(pattern, options) {
+ if (!options) {
+ if (this instanceof Minimatch) {
+ options = this.options;
+ } else {
+ options = {};
+ }
+ }
+ pattern = typeof pattern === "undefined" ? this.pattern : pattern;
+ if (typeof pattern === "undefined") {
+ throw new TypeError("undefined pattern");
+ }
+ if (options.nobrace || !pattern.match(/\{.*\}/)) {
+ return [pattern];
+ }
+ return expand(pattern);
+ }
+ Minimatch.prototype.parse = parse;
+ var SUBPARSE = {};
+ function parse(pattern, isSub) {
+ if (pattern.length > 1024 * 64) {
+ throw new TypeError("pattern is too long");
+ }
+ var options = this.options;
+ if (!options.noglobstar && pattern === "**")
+ return GLOBSTAR;
+ if (pattern === "")
+ return "";
+ var re = "";
+ var hasMagic = !!options.nocase;
+ var escaping = false;
+ var patternListStack = [];
+ var negativeLists = [];
+ var stateChar;
+ var inClass = false;
+ var reClassStart = -1;
+ var classStart = -1;
+ var patternStart = pattern.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
+ var self = this;
+ function clearStateChar() {
+ if (stateChar) {
+ switch (stateChar) {
+ case "*":
+ re += star;
+ hasMagic = true;
+ break;
+ case "?":
+ re += qmark;
+ hasMagic = true;
+ break;
+ default:
+ re += "\\" + stateChar;
+ break;
+ }
+ self.debug("clearStateChar %j %j", stateChar, re);
+ stateChar = false;
+ }
+ }
+ for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) {
+ this.debug("%s %s %s %j", pattern, i, re, c);
+ if (escaping && reSpecials[c]) {
+ re += "\\" + c;
+ escaping = false;
+ continue;
+ }
+ switch (c) {
+ case "/":
+ return false;
+ case "\\":
+ clearStateChar();
+ escaping = true;
+ continue;
+ case "?":
+ case "*":
+ case "+":
+ case "@":
+ case "!":
+ this.debug("%s %s %s %j <-- stateChar", pattern, i, re, c);
+ if (inClass) {
+ this.debug(" in class");
+ if (c === "!" && i === classStart + 1)
+ c = "^";
+ re += c;
+ continue;
+ }
+ self.debug("call clearStateChar %j", stateChar);
+ clearStateChar();
+ stateChar = c;
+ if (options.noext)
+ clearStateChar();
+ continue;
+ case "(":
+ if (inClass) {
+ re += "(";
+ continue;
+ }
+ if (!stateChar) {
+ re += "\\(";
+ continue;
+ }
+ patternListStack.push({
+ type: stateChar,
+ start: i - 1,
+ reStart: re.length,
+ open: plTypes[stateChar].open,
+ close: plTypes[stateChar].close
+ });
+ re += stateChar === "!" ? "(?:(?!(?:" : "(?:";
+ this.debug("plType %j %j", stateChar, re);
+ stateChar = false;
+ continue;
+ case ")":
+ if (inClass || !patternListStack.length) {
+ re += "\\)";
+ continue;
+ }
+ clearStateChar();
+ hasMagic = true;
+ var pl = patternListStack.pop();
+ re += pl.close;
+ if (pl.type === "!") {
+ negativeLists.push(pl);
+ }
+ pl.reEnd = re.length;
+ continue;
+ case "|":
+ if (inClass || !patternListStack.length || escaping) {
+ re += "\\|";
+ escaping = false;
+ continue;
+ }
+ clearStateChar();
+ re += "|";
+ continue;
+ case "[":
+ clearStateChar();
+ if (inClass) {
+ re += "\\" + c;
+ continue;
+ }
+ inClass = true;
+ classStart = i;
+ reClassStart = re.length;
+ re += c;
+ continue;
+ case "]":
+ if (i === classStart + 1 || !inClass) {
+ re += "\\" + c;
+ escaping = false;
+ continue;
+ }
+ if (inClass) {
+ var cs = pattern.substring(classStart + 1, i);
+ try {
+ RegExp("[" + cs + "]");
+ } catch (er) {
+ var sp = this.parse(cs, SUBPARSE);
+ re = re.substr(0, reClassStart) + "\\[" + sp[0] + "\\]";
+ hasMagic = hasMagic || sp[1];
+ inClass = false;
+ continue;
+ }
+ }
+ hasMagic = true;
+ inClass = false;
+ re += c;
+ continue;
+ default:
+ clearStateChar();
+ if (escaping) {
+ escaping = false;
+ } else if (reSpecials[c] && !(c === "^" && inClass)) {
+ re += "\\";
+ }
+ re += c;
+ }
+ }
+ if (inClass) {
+ cs = pattern.substr(classStart + 1);
+ sp = this.parse(cs, SUBPARSE);
+ re = re.substr(0, reClassStart) + "\\[" + sp[0];
+ hasMagic = hasMagic || sp[1];
+ }
+ for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+ var tail = re.slice(pl.reStart + pl.open.length);
+ this.debug("setting tail", re, pl);
+ tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function(_, $1, $2) {
+ if (!$2) {
+ $2 = "\\";
+ }
+ return $1 + $1 + $2 + "|";
+ });
+ this.debug("tail=%j\n %s", tail, tail, pl, re);
+ var t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
+ hasMagic = true;
+ re = re.slice(0, pl.reStart) + t + "\\(" + tail;
+ }
+ clearStateChar();
+ if (escaping) {
+ re += "\\\\";
+ }
+ var addPatternStart = false;
+ switch (re.charAt(0)) {
+ case ".":
+ case "[":
+ case "(":
+ addPatternStart = true;
+ }
+ for (var n = negativeLists.length - 1; n > -1; n--) {
+ var nl = negativeLists[n];
+ var nlBefore = re.slice(0, nl.reStart);
+ var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+ var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
+ var nlAfter = re.slice(nl.reEnd);
+ nlLast += nlAfter;
+ var openParensBefore = nlBefore.split("(").length - 1;
+ var cleanAfter = nlAfter;
+ for (i = 0; i < openParensBefore; i++) {
+ cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
+ }
+ nlAfter = cleanAfter;
+ var dollar = "";
+ if (nlAfter === "" && isSub !== SUBPARSE) {
+ dollar = "$";
+ }
+ var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+ re = newRe;
+ }
+ if (re !== "" && hasMagic) {
+ re = "(?=.)" + re;
+ }
+ if (addPatternStart) {
+ re = patternStart + re;
+ }
+ if (isSub === SUBPARSE) {
+ return [re, hasMagic];
+ }
+ if (!hasMagic) {
+ return globUnescape(pattern);
+ }
+ var flags = options.nocase ? "i" : "";
+ try {
+ var regExp = new RegExp("^" + re + "$", flags);
+ } catch (er) {
+ return new RegExp("$.");
+ }
+ regExp._glob = pattern;
+ regExp._src = re;
+ return regExp;
+ }
+ minimatch.makeRe = function(pattern, options) {
+ return new Minimatch(pattern, options || {}).makeRe();
+ };
+ Minimatch.prototype.makeRe = makeRe;
+ function makeRe() {
+ if (this.regexp || this.regexp === false)
+ return this.regexp;
+ var set = this.set;
+ if (!set.length) {
+ this.regexp = false;
+ return this.regexp;
+ }
+ var options = this.options;
+ var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+ var flags = options.nocase ? "i" : "";
+ var re = set.map(function(pattern) {
+ return pattern.map(function(p) {
+ return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._src;
+ }).join("\\/");
+ }).join("|");
+ re = "^(?:" + re + ")$";
+ if (this.negate)
+ re = "^(?!" + re + ").*$";
+ try {
+ this.regexp = new RegExp(re, flags);
+ } catch (ex) {
+ this.regexp = false;
+ }
+ return this.regexp;
+ }
+ minimatch.match = function(list, pattern, options) {
+ options = options || {};
+ var mm = new Minimatch(pattern, options);
+ list = list.filter(function(f) {
+ return mm.match(f);
+ });
+ if (mm.options.nonull && !list.length) {
+ list.push(pattern);
+ }
+ return list;
+ };
+ Minimatch.prototype.match = match;
+ function match(f, partial) {
+ this.debug("match", f, this.pattern);
+ if (this.comment)
+ return false;
+ if (this.empty)
+ return f === "";
+ if (f === "/" && partial)
+ return true;
+ var options = this.options;
+ if (path2.sep !== "/") {
+ f = f.split(path2.sep).join("/");
+ }
+ f = f.split(slashSplit);
+ this.debug(this.pattern, "split", f);
+ var set = this.set;
+ this.debug(this.pattern, "set", set);
+ var filename;
+ var i;
+ for (i = f.length - 1; i >= 0; i--) {
+ filename = f[i];
+ if (filename)
+ break;
+ }
+ for (i = 0; i < set.length; i++) {
+ var pattern = set[i];
+ var file = f;
+ if (options.matchBase && pattern.length === 1) {
+ file = [filename];
+ }
+ var hit = this.matchOne(file, pattern, partial);
+ if (hit) {
+ if (options.flipNegate)
+ return true;
+ return !this.negate;
+ }
+ }
+ if (options.flipNegate)
+ return false;
+ return this.negate;
+ }
+ Minimatch.prototype.matchOne = function(file, pattern, partial) {
+ var options = this.options;
+ this.debug("matchOne", { "this": this, file, pattern });
+ this.debug("matchOne", file.length, pattern.length);
+ for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+ this.debug("matchOne loop");
+ var p = pattern[pi];
+ var f = file[fi];
+ this.debug(pattern, p, f);
+ if (p === false)
+ return false;
+ if (p === GLOBSTAR) {
+ this.debug("GLOBSTAR", [pattern, p, f]);
+ var fr = fi;
+ var pr = pi + 1;
+ if (pr === pl) {
+ this.debug("** at the end");
+ for (; fi < fl; fi++) {
+ if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
+ return false;
+ }
+ return true;
+ }
+ while (fr < fl) {
+ var swallowee = file[fr];
+ this.debug("\nglobstar while", file, fr, pattern, pr, swallowee);
+ if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+ this.debug("globstar found match!", fr, fl, swallowee);
+ return true;
+ } else {
+ if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
+ this.debug("dot detected!", file, fr, pattern, pr);
+ break;
+ }
+ this.debug("globstar swallow a segment, and continue");
+ fr++;
+ }
+ }
+ if (partial) {
+ this.debug("\n>>> no match, partial?", file, fr, pattern, pr);
+ if (fr === fl)
+ return true;
+ }
+ return false;
+ }
+ var hit;
+ if (typeof p === "string") {
+ if (options.nocase) {
+ hit = f.toLowerCase() === p.toLowerCase();
+ } else {
+ hit = f === p;
+ }
+ this.debug("string match", p, f, hit);
+ } else {
+ hit = f.match(p);
+ this.debug("pattern match", p, f, hit);
+ }
+ if (!hit)
+ return false;
+ }
+ if (fi === fl && pi === pl) {
+ return true;
+ } else if (fi === fl) {
+ return partial;
+ } else if (pi === pl) {
+ var emptyFileEnd = fi === fl - 1 && file[fi] === "";
+ return emptyFileEnd;
+ }
+ throw new Error("wtf?");
+ };
+ function globUnescape(s) {
+ return s.replace(/\\(.)/g, "$1");
+ }
+ function regExpEscape(s) {
+ return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+ }
+ }
+});
+
+// pnp:inherits-npm-2.0.4-c66b3957a0-4a48a73384.zip/node_modules/inherits/inherits_browser.js
+var require_inherits_browser = __commonJS({
+ "pnp:inherits-npm-2.0.4-c66b3957a0-4a48a73384.zip/node_modules/inherits/inherits_browser.js"(exports, module2) {
+ if (typeof Object.create === "function") {
+ module2.exports = function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor;
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ }
+ };
+ } else {
+ module2.exports = function inherits(ctor, superCtor) {
+ if (superCtor) {
+ ctor.super_ = superCtor;
+ var TempCtor = function() {
+ };
+ TempCtor.prototype = superCtor.prototype;
+ ctor.prototype = new TempCtor();
+ ctor.prototype.constructor = ctor;
+ }
+ };
+ }
+ }
+});
+
+// pnp:inherits-npm-2.0.4-c66b3957a0-4a48a73384.zip/node_modules/inherits/inherits.js
+var require_inherits = __commonJS({
+ "pnp:inherits-npm-2.0.4-c66b3957a0-4a48a73384.zip/node_modules/inherits/inherits.js"(exports, module2) {
+ try {
+ util = require("util");
+ if (typeof util.inherits !== "function")
+ throw "";
+ module2.exports = util.inherits;
+ } catch (e) {
+ module2.exports = require_inherits_browser();
+ }
+ var util;
+ }
+});
+
+// pnp:path-is-absolute-npm-1.0.1-31bc695ffd-060840f92c.zip/node_modules/path-is-absolute/index.js
+var require_path_is_absolute = __commonJS({
+ "pnp:path-is-absolute-npm-1.0.1-31bc695ffd-060840f92c.zip/node_modules/path-is-absolute/index.js"(exports, module2) {
+ "use strict";
+ function posix(path2) {
+ return path2.charAt(0) === "/";
+ }
+ function win32(path2) {
+ var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+ var result = splitDeviceRe.exec(path2);
+ var device = result[1] || "";
+ var isUnc = Boolean(device && device.charAt(1) !== ":");
+ return Boolean(result[2] || isUnc);
+ }
+ module2.exports = process.platform === "win32" ? win32 : posix;
+ module2.exports.posix = posix;
+ module2.exports.win32 = win32;
+ }
+});
+
+// pnp:glob-npm-7.1.7-5698ad9c48-b61f48973b.zip/node_modules/glob/common.js
+var require_common = __commonJS({
+ "pnp:glob-npm-7.1.7-5698ad9c48-b61f48973b.zip/node_modules/glob/common.js"(exports) {
+ exports.setopts = setopts;
+ exports.ownProp = ownProp;
+ exports.makeAbs = makeAbs;
+ exports.finish = finish;
+ exports.mark = mark;
+ exports.isIgnored = isIgnored;
+ exports.childrenIgnored = childrenIgnored;
+ function ownProp(obj, field) {
+ return Object.prototype.hasOwnProperty.call(obj, field);
+ }
+ var path2 = require("path");
+ var minimatch = require_minimatch();
+ var isAbsolute = require_path_is_absolute();
+ var Minimatch = minimatch.Minimatch;
+ function alphasort(a, b) {
+ return a.localeCompare(b, "en");
+ }
+ function setupIgnores(self, options) {
+ self.ignore = options.ignore || [];
+ if (!Array.isArray(self.ignore))
+ self.ignore = [self.ignore];
+ if (self.ignore.length) {
+ self.ignore = self.ignore.map(ignoreMap);
+ }
+ }
+ function ignoreMap(pattern) {
+ var gmatcher = null;
+ if (pattern.slice(-3) === "/**") {
+ var gpattern = pattern.replace(/(\/\*\*)+$/, "");
+ gmatcher = new Minimatch(gpattern, { dot: true });
+ }
+ return {
+ matcher: new Minimatch(pattern, { dot: true }),
+ gmatcher
+ };
+ }
+ function setopts(self, pattern, options) {
+ if (!options)
+ options = {};
+ if (options.matchBase && pattern.indexOf("/") === -1) {
+ if (options.noglobstar) {
+ throw new Error("base matching requires globstar");
+ }
+ pattern = "**/" + pattern;
+ }
+ self.silent = !!options.silent;
+ self.pattern = pattern;
+ self.strict = options.strict !== false;
+ self.realpath = !!options.realpath;
+ self.realpathCache = options.realpathCache || Object.create(null);
+ self.follow = !!options.follow;
+ self.dot = !!options.dot;
+ self.mark = !!options.mark;
+ self.nodir = !!options.nodir;
+ if (self.nodir)
+ self.mark = true;
+ self.sync = !!options.sync;
+ self.nounique = !!options.nounique;
+ self.nonull = !!options.nonull;
+ self.nosort = !!options.nosort;
+ self.nocase = !!options.nocase;
+ self.stat = !!options.stat;
+ self.noprocess = !!options.noprocess;
+ self.absolute = !!options.absolute;
+ self.maxLength = options.maxLength || Infinity;
+ self.cache = options.cache || Object.create(null);
+ self.statCache = options.statCache || Object.create(null);
+ self.symlinks = options.symlinks || Object.create(null);
+ setupIgnores(self, options);
+ self.changedCwd = false;
+ var cwd = process.cwd();
+ if (!ownProp(options, "cwd"))
+ self.cwd = cwd;
+ else {
+ self.cwd = path2.resolve(options.cwd);
+ self.changedCwd = self.cwd !== cwd;
+ }
+ self.root = options.root || path2.resolve(self.cwd, "/");
+ self.root = path2.resolve(self.root);
+ if (process.platform === "win32")
+ self.root = self.root.replace(/\\/g, "/");
+ self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
+ if (process.platform === "win32")
+ self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
+ self.nomount = !!options.nomount;
+ options.nonegate = true;
+ options.nocomment = true;
+ self.minimatch = new Minimatch(pattern, options);
+ self.options = self.minimatch.options;
+ }
+ function finish(self) {
+ var nou = self.nounique;
+ var all = nou ? [] : Object.create(null);
+ for (var i = 0, l = self.matches.length; i < l; i++) {
+ var matches = self.matches[i];
+ if (!matches || Object.keys(matches).length === 0) {
+ if (self.nonull) {
+ var literal = self.minimatch.globSet[i];
+ if (nou)
+ all.push(literal);
+ else
+ all[literal] = true;
+ }
+ } else {
+ var m = Object.keys(matches);
+ if (nou)
+ all.push.apply(all, m);
+ else
+ m.forEach(function(m2) {
+ all[m2] = true;
+ });
+ }
+ }
+ if (!nou)
+ all = Object.keys(all);
+ if (!self.nosort)
+ all = all.sort(alphasort);
+ if (self.mark) {
+ for (var i = 0; i < all.length; i++) {
+ all[i] = self._mark(all[i]);
+ }
+ if (self.nodir) {
+ all = all.filter(function(e) {
+ var notDir = !/\/$/.test(e);
+ var c = self.cache[e] || self.cache[makeAbs(self, e)];
+ if (notDir && c)
+ notDir = c !== "DIR" && !Array.isArray(c);
+ return notDir;
+ });
+ }
+ }
+ if (self.ignore.length)
+ all = all.filter(function(m2) {
+ return !isIgnored(self, m2);
+ });
+ self.found = all;
+ }
+ function mark(self, p) {
+ var abs = makeAbs(self, p);
+ var c = self.cache[abs];
+ var m = p;
+ if (c) {
+ var isDir = c === "DIR" || Array.isArray(c);
+ var slash = p.slice(-1) === "/";
+ if (isDir && !slash)
+ m += "/";
+ else if (!isDir && slash)
+ m = m.slice(0, -1);
+ if (m !== p) {
+ var mabs = makeAbs(self, m);
+ self.statCache[mabs] = self.statCache[abs];
+ self.cache[mabs] = self.cache[abs];
+ }
+ }
+ return m;
+ }
+ function makeAbs(self, f) {
+ var abs = f;
+ if (f.charAt(0) === "/") {
+ abs = path2.join(self.root, f);
+ } else if (isAbsolute(f) || f === "") {
+ abs = f;
+ } else if (self.changedCwd) {
+ abs = path2.resolve(self.cwd, f);
+ } else {
+ abs = path2.resolve(f);
+ }
+ if (process.platform === "win32")
+ abs = abs.replace(/\\/g, "/");
+ return abs;
+ }
+ function isIgnored(self, path3) {
+ if (!self.ignore.length)
+ return false;
+ return self.ignore.some(function(item) {
+ return item.matcher.match(path3) || !!(item.gmatcher && item.gmatcher.match(path3));
+ });
+ }
+ function childrenIgnored(self, path3) {
+ if (!self.ignore.length)
+ return false;
+ return self.ignore.some(function(item) {
+ return !!(item.gmatcher && item.gmatcher.match(path3));
+ });
+ }
+ }
+});
+
+// pnp:glob-npm-7.1.7-5698ad9c48-b61f48973b.zip/node_modules/glob/sync.js
+var require_sync = __commonJS({
+ "pnp:glob-npm-7.1.7-5698ad9c48-b61f48973b.zip/node_modules/glob/sync.js"(exports, module2) {
+ module2.exports = globSync;
+ globSync.GlobSync = GlobSync;
+ var fs4 = require("fs");
+ var rp = require_fs();
+ var minimatch = require_minimatch();
+ var Minimatch = minimatch.Minimatch;
+ var Glob2 = require_glob().Glob;
+ var util = require("util");
+ var path2 = require("path");
+ var assert = require("assert");
+ var isAbsolute = require_path_is_absolute();
+ var common = require_common();
+ var setopts = common.setopts;
+ var ownProp = common.ownProp;
+ var childrenIgnored = common.childrenIgnored;
+ var isIgnored = common.isIgnored;
+ function globSync(pattern, options) {
+ if (typeof options === "function" || arguments.length === 3)
+ throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
+ return new GlobSync(pattern, options).found;
+ }
+ function GlobSync(pattern, options) {
+ if (!pattern)
+ throw new Error("must provide pattern");
+ if (typeof options === "function" || arguments.length === 3)
+ throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
+ if (!(this instanceof GlobSync))
+ return new GlobSync(pattern, options);
+ setopts(this, pattern, options);
+ if (this.noprocess)
+ return this;
+ var n = this.minimatch.set.length;
+ this.matches = new Array(n);
+ for (var i = 0; i < n; i++) {
+ this._process(this.minimatch.set[i], i, false);
+ }
+ this._finish();
+ }
+ GlobSync.prototype._finish = function() {
+ assert(this instanceof GlobSync);
+ if (this.realpath) {
+ var self = this;
+ this.matches.forEach(function(matchset, index) {
+ var set = self.matches[index] = Object.create(null);
+ for (var p in matchset) {
+ try {
+ p = self._makeAbs(p);
+ var real = rp.realpathSync(p, self.realpathCache);
+ set[real] = true;
+ } catch (er) {
+ if (er.syscall === "stat")
+ set[self._makeAbs(p)] = true;
+ else
+ throw er;
+ }
+ }
+ });
+ }
+ common.finish(this);
+ };
+ GlobSync.prototype._process = function(pattern, index, inGlobStar) {
+ assert(this instanceof GlobSync);
+ var n = 0;
+ while (typeof pattern[n] === "string") {
+ n++;
+ }
+ var prefix;
+ switch (n) {
+ case pattern.length:
+ this._processSimple(pattern.join("/"), index);
+ return;
+ case 0:
+ prefix = null;
+ break;
+ default:
+ prefix = pattern.slice(0, n).join("/");
+ break;
+ }
+ var remain = pattern.slice(n);
+ var read;
+ if (prefix === null)
+ read = ".";
+ else if (isAbsolute(prefix) || isAbsolute(pattern.join("/"))) {
+ if (!prefix || !isAbsolute(prefix))
+ prefix = "/" + prefix;
+ read = prefix;
+ } else
+ read = prefix;
+ var abs = this._makeAbs(read);
+ if (childrenIgnored(this, read))
+ return;
+ var isGlobStar = remain[0] === minimatch.GLOBSTAR;
+ if (isGlobStar)
+ this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);
+ else
+ this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
+ };
+ GlobSync.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar) {
+ var entries = this._readdir(abs, inGlobStar);
+ if (!entries)
+ return;
+ var pn = remain[0];
+ var negate = !!this.minimatch.negate;
+ var rawGlob = pn._glob;
+ var dotOk = this.dot || rawGlob.charAt(0) === ".";
+ var matchedEntries = [];
+ for (var i = 0; i < entries.length; i++) {
+ var e = entries[i];
+ if (e.charAt(0) !== "." || dotOk) {
+ var m;
+ if (negate && !prefix) {
+ m = !e.match(pn);
+ } else {
+ m = e.match(pn);
+ }
+ if (m)
+ matchedEntries.push(e);
+ }
+ }
+ var len = matchedEntries.length;
+ if (len === 0)
+ return;
+ if (remain.length === 1 && !this.mark && !this.stat) {
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null);
+ for (var i = 0; i < len; i++) {
+ var e = matchedEntries[i];
+ if (prefix) {
+ if (prefix.slice(-1) !== "/")
+ e = prefix + "/" + e;
+ else
+ e = prefix + e;
+ }
+ if (e.charAt(0) === "/" && !this.nomount) {
+ e = path2.join(this.root, e);
+ }
+ this._emitMatch(index, e);
+ }
+ return;
+ }
+ remain.shift();
+ for (var i = 0; i < len; i++) {
+ var e = matchedEntries[i];
+ var newPattern;
+ if (prefix)
+ newPattern = [prefix, e];
+ else
+ newPattern = [e];
+ this._process(newPattern.concat(remain), index, inGlobStar);
+ }
+ };
+ GlobSync.prototype._emitMatch = function(index, e) {
+ if (isIgnored(this, e))
+ return;
+ var abs = this._makeAbs(e);
+ if (this.mark)
+ e = this._mark(e);
+ if (this.absolute) {
+ e = abs;
+ }
+ if (this.matches[index][e])
+ return;
+ if (this.nodir) {
+ var c = this.cache[abs];
+ if (c === "DIR" || Array.isArray(c))
+ return;
+ }
+ this.matches[index][e] = true;
+ if (this.stat)
+ this._stat(e);
+ };
+ GlobSync.prototype._readdirInGlobStar = function(abs) {
+ if (this.follow)
+ return this._readdir(abs, false);
+ var entries;
+ var lstat;
+ var stat;
+ try {
+ lstat = fs4.lstatSync(abs);
+ } catch (er) {
+ if (er.code === "ENOENT") {
+ return null;
+ }
+ }
+ var isSym = lstat && lstat.isSymbolicLink();
+ this.symlinks[abs] = isSym;
+ if (!isSym && lstat && !lstat.isDirectory())
+ this.cache[abs] = "FILE";
+ else
+ entries = this._readdir(abs, false);
+ return entries;
+ };
+ GlobSync.prototype._readdir = function(abs, inGlobStar) {
+ var entries;
+ if (inGlobStar && !ownProp(this.symlinks, abs))
+ return this._readdirInGlobStar(abs);
+ if (ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (!c || c === "FILE")
+ return null;
+ if (Array.isArray(c))
+ return c;
+ }
+ try {
+ return this._readdirEntries(abs, fs4.readdirSync(abs));
+ } catch (er) {
+ this._readdirError(abs, er);
+ return null;
+ }
+ };
+ GlobSync.prototype._readdirEntries = function(abs, entries) {
+ if (!this.mark && !this.stat) {
+ for (var i = 0; i < entries.length; i++) {
+ var e = entries[i];
+ if (abs === "/")
+ e = abs + e;
+ else
+ e = abs + "/" + e;
+ this.cache[e] = true;
+ }
+ }
+ this.cache[abs] = entries;
+ return entries;
+ };
+ GlobSync.prototype._readdirError = function(f, er) {
+ switch (er.code) {
+ case "ENOTSUP":
+ case "ENOTDIR":
+ var abs = this._makeAbs(f);
+ this.cache[abs] = "FILE";
+ if (abs === this.cwdAbs) {
+ var error = new Error(er.code + " invalid cwd " + this.cwd);
+ error.path = this.cwd;
+ error.code = er.code;
+ throw error;
+ }
+ break;
+ case "ENOENT":
+ case "ELOOP":
+ case "ENAMETOOLONG":
+ case "UNKNOWN":
+ this.cache[this._makeAbs(f)] = false;
+ break;
+ default:
+ this.cache[this._makeAbs(f)] = false;
+ if (this.strict)
+ throw er;
+ if (!this.silent)
+ console.error("glob error", er);
+ break;
+ }
+ };
+ GlobSync.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar) {
+ var entries = this._readdir(abs, inGlobStar);
+ if (!entries)
+ return;
+ var remainWithoutGlobStar = remain.slice(1);
+ var gspref = prefix ? [prefix] : [];
+ var noGlobStar = gspref.concat(remainWithoutGlobStar);
+ this._process(noGlobStar, index, false);
+ var len = entries.length;
+ var isSym = this.symlinks[abs];
+ if (isSym && inGlobStar)
+ return;
+ for (var i = 0; i < len; i++) {
+ var e = entries[i];
+ if (e.charAt(0) === "." && !this.dot)
+ continue;
+ var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+ this._process(instead, index, true);
+ var below = gspref.concat(entries[i], remain);
+ this._process(below, index, true);
+ }
+ };
+ GlobSync.prototype._processSimple = function(prefix, index) {
+ var exists = this._stat(prefix);
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null);
+ if (!exists)
+ return;
+ if (prefix && isAbsolute(prefix) && !this.nomount) {
+ var trail = /[\/\\]$/.test(prefix);
+ if (prefix.charAt(0) === "/") {
+ prefix = path2.join(this.root, prefix);
+ } else {
+ prefix = path2.resolve(this.root, prefix);
+ if (trail)
+ prefix += "/";
+ }
+ }
+ if (process.platform === "win32")
+ prefix = prefix.replace(/\\/g, "/");
+ this._emitMatch(index, prefix);
+ };
+ GlobSync.prototype._stat = function(f) {
+ var abs = this._makeAbs(f);
+ var needDir = f.slice(-1) === "/";
+ if (f.length > this.maxLength)
+ return false;
+ if (!this.stat && ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (Array.isArray(c))
+ c = "DIR";
+ if (!needDir || c === "DIR")
+ return c;
+ if (needDir && c === "FILE")
+ return false;
+ }
+ var exists;
+ var stat = this.statCache[abs];
+ if (!stat) {
+ var lstat;
+ try {
+ lstat = fs4.lstatSync(abs);
+ } catch (er) {
+ if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
+ this.statCache[abs] = false;
+ return false;
+ }
+ }
+ if (lstat && lstat.isSymbolicLink()) {
+ try {
+ stat = fs4.statSync(abs);
+ } catch (er) {
+ stat = lstat;
+ }
+ } else {
+ stat = lstat;
+ }
+ }
+ this.statCache[abs] = stat;
+ var c = true;
+ if (stat)
+ c = stat.isDirectory() ? "DIR" : "FILE";
+ this.cache[abs] = this.cache[abs] || c;
+ if (needDir && c === "FILE")
+ return false;
+ return c;
+ };
+ GlobSync.prototype._mark = function(p) {
+ return common.mark(this, p);
+ };
+ GlobSync.prototype._makeAbs = function(f) {
+ return common.makeAbs(this, f);
+ };
+ }
+});
+
+// pnp:wrappy-npm-1.0.2-916de4d4b3-159da4805f.zip/node_modules/wrappy/wrappy.js
+var require_wrappy = __commonJS({
+ "pnp:wrappy-npm-1.0.2-916de4d4b3-159da4805f.zip/node_modules/wrappy/wrappy.js"(exports, module2) {
+ module2.exports = wrappy;
+ function wrappy(fn, cb) {
+ if (fn && cb)
+ return wrappy(fn)(cb);
+ if (typeof fn !== "function")
+ throw new TypeError("need wrapper function");
+ Object.keys(fn).forEach(function(k) {
+ wrapper[k] = fn[k];
+ });
+ return wrapper;
+ function wrapper() {
+ var args = new Array(arguments.length);
+ for (var i = 0; i < args.length; i++) {
+ args[i] = arguments[i];
+ }
+ var ret = fn.apply(this, args);
+ var cb2 = args[args.length - 1];
+ if (typeof ret === "function" && ret !== cb2) {
+ Object.keys(cb2).forEach(function(k) {
+ ret[k] = cb2[k];
+ });
+ }
+ return ret;
+ }
+ }
+ }
+});
+
+// pnp:once-npm-1.4.0-ccf03ef07a-cd0a885013.zip/node_modules/once/once.js
+var require_once = __commonJS({
+ "pnp:once-npm-1.4.0-ccf03ef07a-cd0a885013.zip/node_modules/once/once.js"(exports, module2) {
+ var wrappy = require_wrappy();
+ module2.exports = wrappy(once);
+ module2.exports.strict = wrappy(onceStrict);
+ once.proto = once(function() {
+ Object.defineProperty(Function.prototype, "once", {
+ value: function() {
+ return once(this);
+ },
+ configurable: true
+ });
+ Object.defineProperty(Function.prototype, "onceStrict", {
+ value: function() {
+ return onceStrict(this);
+ },
+ configurable: true
+ });
+ });
+ function once(fn) {
+ var f = function() {
+ if (f.called)
+ return f.value;
+ f.called = true;
+ return f.value = fn.apply(this, arguments);
+ };
+ f.called = false;
+ return f;
+ }
+ function onceStrict(fn) {
+ var f = function() {
+ if (f.called)
+ throw new Error(f.onceError);
+ f.called = true;
+ return f.value = fn.apply(this, arguments);
+ };
+ var name = fn.name || "Function wrapped with `once`";
+ f.onceError = name + " shouldn't be called more than once";
+ f.called = false;
+ return f;
+ }
+ }
+});
+
+// pnp:inflight-npm-1.0.6-ccedb4b908-f4f76aa072.zip/node_modules/inflight/inflight.js
+var require_inflight = __commonJS({
+ "pnp:inflight-npm-1.0.6-ccedb4b908-f4f76aa072.zip/node_modules/inflight/inflight.js"(exports, module2) {
+ var wrappy = require_wrappy();
+ var reqs = Object.create(null);
+ var once = require_once();
+ module2.exports = wrappy(inflight);
+ function inflight(key, cb) {
+ if (reqs[key]) {
+ reqs[key].push(cb);
+ return null;
+ } else {
+ reqs[key] = [cb];
+ return makeres(key);
+ }
+ }
+ function makeres(key) {
+ return once(function RES() {
+ var cbs = reqs[key];
+ var len = cbs.length;
+ var args = slice(arguments);
+ try {
+ for (var i = 0; i < len; i++) {
+ cbs[i].apply(null, args);
+ }
+ } finally {
+ if (cbs.length > len) {
+ cbs.splice(0, len);
+ process.nextTick(function() {
+ RES.apply(null, args);
+ });
+ } else {
+ delete reqs[key];
+ }
+ }
+ });
+ }
+ function slice(args) {
+ var length = args.length;
+ var array = [];
+ for (var i = 0; i < length; i++)
+ array[i] = args[i];
+ return array;
+ }
+ }
+});
+
+// pnp:glob-npm-7.1.7-5698ad9c48-b61f48973b.zip/node_modules/glob/glob.js
+var require_glob = __commonJS({
+ "pnp:glob-npm-7.1.7-5698ad9c48-b61f48973b.zip/node_modules/glob/glob.js"(exports, module2) {
+ module2.exports = glob2;
+ var fs4 = require("fs");
+ var rp = require_fs();
+ var minimatch = require_minimatch();
+ var Minimatch = minimatch.Minimatch;
+ var inherits = require_inherits();
+ var EE = require("events").EventEmitter;
+ var path2 = require("path");
+ var assert = require("assert");
+ var isAbsolute = require_path_is_absolute();
+ var globSync = require_sync();
+ var common = require_common();
+ var setopts = common.setopts;
+ var ownProp = common.ownProp;
+ var inflight = require_inflight();
+ var util = require("util");
+ var childrenIgnored = common.childrenIgnored;
+ var isIgnored = common.isIgnored;
+ var once = require_once();
+ function glob2(pattern, options, cb) {
+ if (typeof options === "function")
+ cb = options, options = {};
+ if (!options)
+ options = {};
+ if (options.sync) {
+ if (cb)
+ throw new TypeError("callback provided to sync glob");
+ return globSync(pattern, options);
+ }
+ return new Glob2(pattern, options, cb);
+ }
+ glob2.sync = globSync;
+ var GlobSync = glob2.GlobSync = globSync.GlobSync;
+ glob2.glob = glob2;
+ function extend(origin, add) {
+ if (add === null || typeof add !== "object") {
+ return origin;
+ }
+ var keys = Object.keys(add);
+ var i = keys.length;
+ while (i--) {
+ origin[keys[i]] = add[keys[i]];
+ }
+ return origin;
+ }
+ glob2.hasMagic = function(pattern, options_) {
+ var options = extend({}, options_);
+ options.noprocess = true;
+ var g = new Glob2(pattern, options);
+ var set = g.minimatch.set;
+ if (!pattern)
+ return false;
+ if (set.length > 1)
+ return true;
+ for (var j = 0; j < set[0].length; j++) {
+ if (typeof set[0][j] !== "string")
+ return true;
+ }
+ return false;
+ };
+ glob2.Glob = Glob2;
+ inherits(Glob2, EE);
+ function Glob2(pattern, options, cb) {
+ if (typeof options === "function") {
+ cb = options;
+ options = null;
+ }
+ if (options && options.sync) {
+ if (cb)
+ throw new TypeError("callback provided to sync glob");
+ return new GlobSync(pattern, options);
+ }
+ if (!(this instanceof Glob2))
+ return new Glob2(pattern, options, cb);
+ setopts(this, pattern, options);
+ this._didRealPath = false;
+ var n = this.minimatch.set.length;
+ this.matches = new Array(n);
+ if (typeof cb === "function") {
+ cb = once(cb);
+ this.on("error", cb);
+ this.on("end", function(matches) {
+ cb(null, matches);
+ });
+ }
+ var self = this;
+ this._processing = 0;
+ this._emitQueue = [];
+ this._processQueue = [];
+ this.paused = false;
+ if (this.noprocess)
+ return this;
+ if (n === 0)
+ return done();
+ var sync = true;
+ for (var i = 0; i < n; i++) {
+ this._process(this.minimatch.set[i], i, false, done);
+ }
+ sync = false;
+ function done() {
+ --self._processing;
+ if (self._processing <= 0) {
+ if (sync) {
+ process.nextTick(function() {
+ self._finish();
+ });
+ } else {
+ self._finish();
+ }
+ }
+ }
+ }
+ Glob2.prototype._finish = function() {
+ assert(this instanceof Glob2);
+ if (this.aborted)
+ return;
+ if (this.realpath && !this._didRealpath)
+ return this._realpath();
+ common.finish(this);
+ this.emit("end", this.found);
+ };
+ Glob2.prototype._realpath = function() {
+ if (this._didRealpath)
+ return;
+ this._didRealpath = true;
+ var n = this.matches.length;
+ if (n === 0)
+ return this._finish();
+ var self = this;
+ for (var i = 0; i < this.matches.length; i++)
+ this._realpathSet(i, next);
+ function next() {
+ if (--n === 0)
+ self._finish();
+ }
+ };
+ Glob2.prototype._realpathSet = function(index, cb) {
+ var matchset = this.matches[index];
+ if (!matchset)
+ return cb();
+ var found = Object.keys(matchset);
+ var self = this;
+ var n = found.length;
+ if (n === 0)
+ return cb();
+ var set = this.matches[index] = Object.create(null);
+ found.forEach(function(p, i) {
+ p = self._makeAbs(p);
+ rp.realpath(p, self.realpathCache, function(er, real) {
+ if (!er)
+ set[real] = true;
+ else if (er.syscall === "stat")
+ set[p] = true;
+ else
+ self.emit("error", er);
+ if (--n === 0) {
+ self.matches[index] = set;
+ cb();
+ }
+ });
+ });
+ };
+ Glob2.prototype._mark = function(p) {
+ return common.mark(this, p);
+ };
+ Glob2.prototype._makeAbs = function(f) {
+ return common.makeAbs(this, f);
+ };
+ Glob2.prototype.abort = function() {
+ this.aborted = true;
+ this.emit("abort");
+ };
+ Glob2.prototype.pause = function() {
+ if (!this.paused) {
+ this.paused = true;
+ this.emit("pause");
+ }
+ };
+ Glob2.prototype.resume = function() {
+ if (this.paused) {
+ this.emit("resume");
+ this.paused = false;
+ if (this._emitQueue.length) {
+ var eq = this._emitQueue.slice(0);
+ this._emitQueue.length = 0;
+ for (var i = 0; i < eq.length; i++) {
+ var e = eq[i];
+ this._emitMatch(e[0], e[1]);
+ }
+ }
+ if (this._processQueue.length) {
+ var pq = this._processQueue.slice(0);
+ this._processQueue.length = 0;
+ for (var i = 0; i < pq.length; i++) {
+ var p = pq[i];
+ this._processing--;
+ this._process(p[0], p[1], p[2], p[3]);
+ }
+ }
+ }
+ };
+ Glob2.prototype._process = function(pattern, index, inGlobStar, cb) {
+ assert(this instanceof Glob2);
+ assert(typeof cb === "function");
+ if (this.aborted)
+ return;
+ this._processing++;
+ if (this.paused) {
+ this._processQueue.push([pattern, index, inGlobStar, cb]);
+ return;
+ }
+ var n = 0;
+ while (typeof pattern[n] === "string") {
+ n++;
+ }
+ var prefix;
+ switch (n) {
+ case pattern.length:
+ this._processSimple(pattern.join("/"), index, cb);
+ return;
+ case 0:
+ prefix = null;
+ break;
+ default:
+ prefix = pattern.slice(0, n).join("/");
+ break;
+ }
+ var remain = pattern.slice(n);
+ var read;
+ if (prefix === null)
+ read = ".";
+ else if (isAbsolute(prefix) || isAbsolute(pattern.join("/"))) {
+ if (!prefix || !isAbsolute(prefix))
+ prefix = "/" + prefix;
+ read = prefix;
+ } else
+ read = prefix;
+ var abs = this._makeAbs(read);
+ if (childrenIgnored(this, read))
+ return cb();
+ var isGlobStar = remain[0] === minimatch.GLOBSTAR;
+ if (isGlobStar)
+ this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);
+ else
+ this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
+ };
+ Glob2.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar, cb) {
+ var self = this;
+ this._readdir(abs, inGlobStar, function(er, entries) {
+ return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+ });
+ };
+ Glob2.prototype._processReaddir2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+ if (!entries)
+ return cb();
+ var pn = remain[0];
+ var negate = !!this.minimatch.negate;
+ var rawGlob = pn._glob;
+ var dotOk = this.dot || rawGlob.charAt(0) === ".";
+ var matchedEntries = [];
+ for (var i = 0; i < entries.length; i++) {
+ var e = entries[i];
+ if (e.charAt(0) !== "." || dotOk) {
+ var m;
+ if (negate && !prefix) {
+ m = !e.match(pn);
+ } else {
+ m = e.match(pn);
+ }
+ if (m)
+ matchedEntries.push(e);
+ }
+ }
+ var len = matchedEntries.length;
+ if (len === 0)
+ return cb();
+ if (remain.length === 1 && !this.mark && !this.stat) {
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null);
+ for (var i = 0; i < len; i++) {
+ var e = matchedEntries[i];
+ if (prefix) {
+ if (prefix !== "/")
+ e = prefix + "/" + e;
+ else
+ e = prefix + e;
+ }
+ if (e.charAt(0) === "/" && !this.nomount) {
+ e = path2.join(this.root, e);
+ }
+ this._emitMatch(index, e);
+ }
+ return cb();
+ }
+ remain.shift();
+ for (var i = 0; i < len; i++) {
+ var e = matchedEntries[i];
+ var newPattern;
+ if (prefix) {
+ if (prefix !== "/")
+ e = prefix + "/" + e;
+ else
+ e = prefix + e;
+ }
+ this._process([e].concat(remain), index, inGlobStar, cb);
+ }
+ cb();
+ };
+ Glob2.prototype._emitMatch = function(index, e) {
+ if (this.aborted)
+ return;
+ if (isIgnored(this, e))
+ return;
+ if (this.paused) {
+ this._emitQueue.push([index, e]);
+ return;
+ }
+ var abs = isAbsolute(e) ? e : this._makeAbs(e);
+ if (this.mark)
+ e = this._mark(e);
+ if (this.absolute)
+ e = abs;
+ if (this.matches[index][e])
+ return;
+ if (this.nodir) {
+ var c = this.cache[abs];
+ if (c === "DIR" || Array.isArray(c))
+ return;
+ }
+ this.matches[index][e] = true;
+ var st = this.statCache[abs];
+ if (st)
+ this.emit("stat", e, st);
+ this.emit("match", e);
+ };
+ Glob2.prototype._readdirInGlobStar = function(abs, cb) {
+ if (this.aborted)
+ return;
+ if (this.follow)
+ return this._readdir(abs, false, cb);
+ var lstatkey = "lstat\0" + abs;
+ var self = this;
+ var lstatcb = inflight(lstatkey, lstatcb_);
+ if (lstatcb)
+ fs4.lstat(abs, lstatcb);
+ function lstatcb_(er, lstat) {
+ if (er && er.code === "ENOENT")
+ return cb();
+ var isSym = lstat && lstat.isSymbolicLink();
+ self.symlinks[abs] = isSym;
+ if (!isSym && lstat && !lstat.isDirectory()) {
+ self.cache[abs] = "FILE";
+ cb();
+ } else
+ self._readdir(abs, false, cb);
+ }
+ };
+ Glob2.prototype._readdir = function(abs, inGlobStar, cb) {
+ if (this.aborted)
+ return;
+ cb = inflight("readdir\0" + abs + "\0" + inGlobStar, cb);
+ if (!cb)
+ return;
+ if (inGlobStar && !ownProp(this.symlinks, abs))
+ return this._readdirInGlobStar(abs, cb);
+ if (ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (!c || c === "FILE")
+ return cb();
+ if (Array.isArray(c))
+ return cb(null, c);
+ }
+ var self = this;
+ fs4.readdir(abs, readdirCb(this, abs, cb));
+ };
+ function readdirCb(self, abs, cb) {
+ return function(er, entries) {
+ if (er)
+ self._readdirError(abs, er, cb);
+ else
+ self._readdirEntries(abs, entries, cb);
+ };
+ }
+ Glob2.prototype._readdirEntries = function(abs, entries, cb) {
+ if (this.aborted)
+ return;
+ if (!this.mark && !this.stat) {
+ for (var i = 0; i < entries.length; i++) {
+ var e = entries[i];
+ if (abs === "/")
+ e = abs + e;
+ else
+ e = abs + "/" + e;
+ this.cache[e] = true;
+ }
+ }
+ this.cache[abs] = entries;
+ return cb(null, entries);
+ };
+ Glob2.prototype._readdirError = function(f, er, cb) {
+ if (this.aborted)
+ return;
+ switch (er.code) {
+ case "ENOTSUP":
+ case "ENOTDIR":
+ var abs = this._makeAbs(f);
+ this.cache[abs] = "FILE";
+ if (abs === this.cwdAbs) {
+ var error = new Error(er.code + " invalid cwd " + this.cwd);
+ error.path = this.cwd;
+ error.code = er.code;
+ this.emit("error", error);
+ this.abort();
+ }
+ break;
+ case "ENOENT":
+ case "ELOOP":
+ case "ENAMETOOLONG":
+ case "UNKNOWN":
+ this.cache[this._makeAbs(f)] = false;
+ break;
+ default:
+ this.cache[this._makeAbs(f)] = false;
+ if (this.strict) {
+ this.emit("error", er);
+ this.abort();
+ }
+ if (!this.silent)
+ console.error("glob error", er);
+ break;
+ }
+ return cb();
+ };
+ Glob2.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar, cb) {
+ var self = this;
+ this._readdir(abs, inGlobStar, function(er, entries) {
+ self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+ });
+ };
+ Glob2.prototype._processGlobStar2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+ if (!entries)
+ return cb();
+ var remainWithoutGlobStar = remain.slice(1);
+ var gspref = prefix ? [prefix] : [];
+ var noGlobStar = gspref.concat(remainWithoutGlobStar);
+ this._process(noGlobStar, index, false, cb);
+ var isSym = this.symlinks[abs];
+ var len = entries.length;
+ if (isSym && inGlobStar)
+ return cb();
+ for (var i = 0; i < len; i++) {
+ var e = entries[i];
+ if (e.charAt(0) === "." && !this.dot)
+ continue;
+ var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+ this._process(instead, index, true, cb);
+ var below = gspref.concat(entries[i], remain);
+ this._process(below, index, true, cb);
+ }
+ cb();
+ };
+ Glob2.prototype._processSimple = function(prefix, index, cb) {
+ var self = this;
+ this._stat(prefix, function(er, exists) {
+ self._processSimple2(prefix, index, er, exists, cb);
+ });
+ };
+ Glob2.prototype._processSimple2 = function(prefix, index, er, exists, cb) {
+ if (!this.matches[index])
+ this.matches[index] = Object.create(null);
+ if (!exists)
+ return cb();
+ if (prefix && isAbsolute(prefix) && !this.nomount) {
+ var trail = /[\/\\]$/.test(prefix);
+ if (prefix.charAt(0) === "/") {
+ prefix = path2.join(this.root, prefix);
+ } else {
+ prefix = path2.resolve(this.root, prefix);
+ if (trail)
+ prefix += "/";
+ }
+ }
+ if (process.platform === "win32")
+ prefix = prefix.replace(/\\/g, "/");
+ this._emitMatch(index, prefix);
+ cb();
+ };
+ Glob2.prototype._stat = function(f, cb) {
+ var abs = this._makeAbs(f);
+ var needDir = f.slice(-1) === "/";
+ if (f.length > this.maxLength)
+ return cb();
+ if (!this.stat && ownProp(this.cache, abs)) {
+ var c = this.cache[abs];
+ if (Array.isArray(c))
+ c = "DIR";
+ if (!needDir || c === "DIR")
+ return cb(null, c);
+ if (needDir && c === "FILE")
+ return cb();
+ }
+ var exists;
+ var stat = this.statCache[abs];
+ if (stat !== void 0) {
+ if (stat === false)
+ return cb(null, stat);
+ else {
+ var type = stat.isDirectory() ? "DIR" : "FILE";
+ if (needDir && type === "FILE")
+ return cb();
+ else
+ return cb(null, type, stat);
+ }
+ }
+ var self = this;
+ var statcb = inflight("stat\0" + abs, lstatcb_);
+ if (statcb)
+ fs4.lstat(abs, statcb);
+ function lstatcb_(er, lstat) {
+ if (lstat && lstat.isSymbolicLink()) {
+ return fs4.stat(abs, function(er2, stat2) {
+ if (er2)
+ self._stat2(f, abs, null, lstat, cb);
+ else
+ self._stat2(f, abs, er2, stat2, cb);
+ });
+ } else {
+ self._stat2(f, abs, er, lstat, cb);
+ }
+ }
+ };
+ Glob2.prototype._stat2 = function(f, abs, er, stat, cb) {
+ if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
+ this.statCache[abs] = false;
+ return cb();
+ }
+ var needDir = f.slice(-1) === "/";
+ this.statCache[abs] = stat;
+ if (abs.slice(-1) === "/" && stat && !stat.isDirectory())
+ return cb(null, false, stat);
+ var c = true;
+ if (stat)
+ c = stat.isDirectory() ? "DIR" : "FILE";
+ this.cache[abs] = this.cache[abs] || c;
+ if (needDir && c === "FILE")
+ return cb();
+ return cb(null, c, stat);
+ };
+ }
+});
+
+// pnp:/Users/style/Documents/Projects/juke-build/src/index.ts
+__export(exports, {
+ ExitCode: () => ExitCode,
+ Parameter: () => Parameter,
+ Target: () => Target,
+ chalk: () => chalk4,
+ chdir: () => chdir,
+ createParameter: () => createParameter,
+ createTarget: () => createTarget,
+ exec: () => exec,
+ glob: () => glob,
+ logger: () => logger,
+ rm: () => rm,
+ runner: () => runner,
+ setup: () => setup,
+ sleep: () => sleep
+});
+var import_chalk4 = __toModule(require_source());
+var import_module = __toModule(require("module"));
+
+// pnp:/Users/style/Documents/Projects/juke-build/package.json
+var version = "0.8.1";
+
+// pnp:/Users/style/Documents/Projects/juke-build/src/chdir.ts
+var import_fs = __toModule(require("fs"));
+var import_path = __toModule(require("path"));
+var import_url = __toModule(require("url"));
+var chdir = (directory, relativeTo) => {
+ if (relativeTo) {
+ if (relativeTo.startsWith("file://")) {
+ relativeTo = import_url.default.fileURLToPath(relativeTo);
+ }
+ try {
+ const stat = import_fs.default.statSync(relativeTo);
+ if (!stat.isDirectory()) {
+ relativeTo = import_path.default.dirname(relativeTo);
+ }
+ } catch {
+ relativeTo = import_path.default.dirname(relativeTo);
+ }
+ directory = import_path.default.resolve(relativeTo, directory);
+ }
+ process.chdir(directory);
+};
+
+// pnp:/Users/style/Documents/Projects/juke-build/src/exec.ts
+var import_chalk = __toModule(require_source());
+var import_child_process = __toModule(require("child_process"));
+var import_fs2 = __toModule(require("fs"));
+var import_path2 = __toModule(require("path"));
+var children = new Set();
+var killChildren = () => {
+ for (const child of children) {
+ child.kill("SIGTERM");
+ children.delete(child);
+ console.log("killed child process");
+ }
+};
+var trap = (signals, handler) => {
+ let readline;
+ if (process.platform === "win32") {
+ readline = require("readline").createInterface({
+ input: process.stdin,
+ output: process.stdout
+ });
+ }
+ for (const signal of signals) {
+ const handleSignal = () => handler(signal);
+ if (signal === "EXIT") {
+ process.on("exit", handleSignal);
+ continue;
+ }
+ if (readline) {
+ readline.on("SIG" + signal, handleSignal);
+ }
+ process.on("SIG" + signal, handleSignal);
+ }
+};
+var ExitCode = class extends Error {
+ constructor(code, signal) {
+ super("Process exited with code: " + code);
+ this.code = null;
+ this.signal = null;
+ this.code = code;
+ this.signal = signal || null;
+ }
+};
+var exec = (executable, args = [], options = {}) => {
+ const _a = options, {
+ silent = false,
+ throw: canThrow = true
+ } = _a, spawnOptions = __objRest(_a, [
+ "silent",
+ "throw"
+ ]);
+ return new Promise((resolve, reject) => {
+ if (import_fs2.default.existsSync(executable)) {
+ executable = (0, import_path2.resolve)(executable);
+ }
+ if (process.env.JUKE_DEBUG) {
+ console.log(import_chalk.default.grey("$", executable, ...args));
+ }
+ const child = (0, import_child_process.spawn)(executable, args, spawnOptions);
+ children.add(child);
+ let stdout = "";
+ let stderr = "";
+ let combined = "";
+ child.stdout.on("data", (data) => {
+ if (!silent) {
+ process.stdout.write(data);
+ }
+ stdout += data;
+ combined += data;
+ });
+ child.stderr.on("data", (data) => {
+ if (!silent) {
+ process.stderr.write(data);
+ }
+ stderr += data;
+ combined += data;
+ });
+ child.on("error", (err) => reject(err));
+ child.on("exit", (code, signal) => {
+ children.delete(child);
+ if (code !== 0 && canThrow) {
+ const error = new ExitCode(code);
+ error.code = code;
+ error.signal = signal;
+ reject(error);
+ return;
+ }
+ resolve({
+ code,
+ signal,
+ stdout,
+ stderr,
+ combined
+ });
+ });
+ });
+};
+
+// pnp:/Users/style/Documents/Projects/juke-build/src/logger.ts
+var import_chalk2 = __toModule(require_source());
+var logger = {
+ log: (...args) => {
+ console.log(...args);
+ },
+ error: (...args) => {
+ console.log(import_chalk2.default.bold(import_chalk2.default.redBright("=>"), import_chalk2.default.whiteBright(...args)));
+ },
+ action: (...args) => {
+ console.log(import_chalk2.default.bold(import_chalk2.default.greenBright("=>"), import_chalk2.default.whiteBright(...args)));
+ },
+ warn: (...args) => {
+ console.log(import_chalk2.default.bold(import_chalk2.default.yellowBright("=>"), import_chalk2.default.whiteBright(...args)));
+ },
+ info: (...args) => {
+ console.log(import_chalk2.default.bold(import_chalk2.default.blueBright("::"), import_chalk2.default.whiteBright(...args)));
+ },
+ debug: (...args) => {
+ if (process.env.JUKE_DEBUG) {
+ console.log(import_chalk2.default.gray(...args));
+ }
+ }
+};
+
+// pnp:/Users/style/Documents/Projects/juke-build/src/string.ts
+var import_stringcase = __toModule(require_lib());
+var toKebabCase = (str) => (0, import_stringcase.spinalcase)(str);
+var toCamelCase = (str) => (0, import_stringcase.camelcase)(str);
+var toConstCase = (str) => (0, import_stringcase.constcase)(str);
+
+// pnp:/Users/style/Documents/Projects/juke-build/src/parameter.ts
+var Parameter = class {
+ constructor(config) {
+ this.type = config.type;
+ this.name = config.name;
+ this.alias = config.alias;
+ }
+ isString() {
+ return this.type === "string" || this.type === "string[]";
+ }
+ isNumber() {
+ return this.type === "number" || this.type === "number[]";
+ }
+ isBoolean() {
+ return this.type === "boolean" || this.type === "boolean[]";
+ }
+ isArray() {
+ return this.type.endsWith("[]");
+ }
+ toKebabCase() {
+ if (!this.name)
+ return;
+ return toKebabCase(this.name);
+ }
+ toConstCase() {
+ if (!this.name)
+ return;
+ return toConstCase(this.name);
+ }
+ toCamelCase() {
+ if (!this.name)
+ return;
+ return toCamelCase(this.name);
+ }
+};
+var createParameter = (config) => new Parameter(config);
+
+// pnp:/Users/style/Documents/Projects/juke-build/src/runner.ts
+var import_chalk3 = __toModule(require_source());
+var import_events = __toModule(require("events"));
+
+// pnp:/Users/style/Documents/Projects/juke-build/src/argparse.ts
+var stringToBoolean = (str) => str !== void 0 && str !== null && str !== "false" && str !== "0" && str !== "null";
+var prepareArgs = (args, singleTarget = false) => {
+ let inGlobalContext = true;
+ const globalFlags = [];
+ const taskArgs = [];
+ let currentTaskArgs;
+ while (args.length !== 0) {
+ const arg = args.shift();
+ if (!arg) {
+ continue;
+ }
+ if (arg === "--") {
+ inGlobalContext = false;
+ continue;
+ }
+ if (arg.startsWith("-")) {
+ if (inGlobalContext) {
+ globalFlags.push(arg);
+ } else if (currentTaskArgs) {
+ currentTaskArgs.push(arg);
+ }
+ continue;
+ }
+ inGlobalContext = false;
+ if (singleTarget) {
+ if (!currentTaskArgs) {
+ currentTaskArgs = [arg];
+ } else {
+ currentTaskArgs.push(arg);
+ }
+ continue;
+ }
+ if (currentTaskArgs) {
+ taskArgs.push(currentTaskArgs);
+ }
+ currentTaskArgs = [arg];
+ }
+ if (currentTaskArgs) {
+ taskArgs.push(currentTaskArgs);
+ }
+ return { globalFlags, taskArgs };
+};
+var parseArgs = (args, parameters) => {
+ args = [...args];
+ const parameterMap = new Map();
+ const pushValue = (key, value) => {
+ const values = parameterMap.get(key);
+ if (!values) {
+ parameterMap.set(key, [value]);
+ return;
+ }
+ values.push(value);
+ };
+ let currentSet = [];
+ let currentSetType;
+ while (true) {
+ if (currentSet.length === 0) {
+ const arg2 = args.shift();
+ if (!arg2) {
+ break;
+ }
+ if (arg2.startsWith("--")) {
+ currentSet = [arg2.substr(2)];
+ currentSetType = "long";
+ } else if (arg2.startsWith("-")) {
+ currentSet = Array.from(arg2);
+ currentSetType = "short";
+ } else {
+ currentSet = [];
+ currentSetType = void 0;
+ }
+ }
+ const arg = currentSet.shift();
+ if (currentSetType === "short") {
+ const parameter = parameters.find((p) => p.alias === arg);
+ if (!parameter) {
+ continue;
+ }
+ if (parameter.isBoolean()) {
+ pushValue(parameter, true);
+ continue;
+ }
+ if (currentSet.length === 0) {
+ continue;
+ }
+ const string = currentSet.join("");
+ currentSet = [];
+ if (parameter.isNumber()) {
+ pushValue(parameter, parseFloat(string));
+ continue;
+ }
+ pushValue(parameter, string);
+ continue;
+ }
+ if (currentSetType === "long") {
+ const equalsIndex = arg.indexOf("=");
+ let name = arg;
+ let value = null;
+ if (equalsIndex >= 0) {
+ name = arg.substr(0, equalsIndex);
+ value = arg.substr(equalsIndex + 1);
+ if (value === "") {
+ value = null;
+ }
+ }
+ const parameter = parameters.find((p) => p.name === name || p.toKebabCase() === name || p.toCamelCase() === name);
+ if (!parameter) {
+ continue;
+ }
+ if (parameter.isBoolean()) {
+ const noEqualsSign = equalsIndex < 0;
+ pushValue(parameter, noEqualsSign || stringToBoolean(value));
+ continue;
+ }
+ if (value === null) {
+ continue;
+ }
+ if (parameter.isNumber()) {
+ pushValue(parameter, parseFloat(value));
+ continue;
+ }
+ pushValue(parameter, value);
+ continue;
+ }
+ }
+ for (const [key, value] of Object.entries(process.env)) {
+ const parameter = parameters.find((p) => p.name === key || p.toConstCase() === key);
+ if (!parameter || parameterMap.has(parameter)) {
+ continue;
+ }
+ let values = [];
+ if (value !== void 0) {
+ if (parameter.isArray()) {
+ values = value.split(",");
+ } else {
+ values = [value];
+ }
+ }
+ for (const value2 of values) {
+ if (parameter.isBoolean()) {
+ pushValue(parameter, stringToBoolean(value2));
+ continue;
+ }
+ if (value2 === "") {
+ continue;
+ }
+ if (parameter.isNumber()) {
+ pushValue(parameter, parseFloat(value2));
+ continue;
+ }
+ pushValue(parameter, value2);
+ continue;
+ }
+ }
+ return parameterMap;
+};
+
+// pnp:/Users/style/Documents/Projects/juke-build/src/fs.ts
+var import_fs3 = __toModule(require("fs"));
+var import_glob = __toModule(require_glob());
+var File = class {
+ constructor(path2) {
+ this.path = path2;
+ }
+ get stat() {
+ if (this._stat === void 0) {
+ try {
+ this._stat = import_fs3.default.statSync(this.path);
+ } catch {
+ this._stat = null;
+ }
+ }
+ return this._stat;
+ }
+ exists() {
+ return this.stat !== null;
+ }
+ get mtime() {
+ return this.stat && this.stat.mtime;
+ }
+ touch() {
+ const time = new Date();
+ try {
+ import_fs3.default.utimesSync(this.path, time, time);
+ } catch (err) {
+ import_fs3.default.closeSync(import_fs3.default.openSync(this.path, "w"));
+ }
+ }
+};
+var Glob = class {
+ constructor(path2) {
+ this.path = path2;
+ this.path = path2;
+ }
+ toFiles() {
+ const paths = import_glob.glob.sync(this.path, {
+ strict: false,
+ silent: true
+ });
+ return paths.map((path2) => new File(path2)).filter((file) => file.exists());
+ }
+};
+var compareFiles = (sources, targets) => {
+ let bestSource = null;
+ let bestTarget = null;
+ for (const file of sources) {
+ if (!bestSource || file.mtime > bestSource.mtime) {
+ bestSource = file;
+ }
+ }
+ for (const file of targets) {
+ if (!file.exists()) {
+ return `target '${file.path}' is missing`;
+ }
+ if (!bestTarget || file.mtime < bestTarget.mtime) {
+ bestTarget = file;
+ }
+ }
+ if (!bestSource) {
+ if (bestTarget) {
+ return false;
+ }
+ return "no known sources or targets";
+ }
+ if (!bestTarget) {
+ return "no targets were specified";
+ }
+ if (bestSource.mtime > bestTarget.mtime) {
+ return `source '${bestSource.path}' is newer than target '${bestTarget.path}'`;
+ }
+ return false;
+};
+var glob = (globPath) => {
+ const unsafePaths = import_glob.glob.sync(globPath, {
+ strict: false,
+ silent: true
+ });
+ const safePaths = [];
+ for (let path2 of unsafePaths) {
+ try {
+ import_fs3.default.lstatSync(path2);
+ safePaths.push(path2);
+ } catch {
+ }
+ }
+ return safePaths;
+};
+var rm = (path2, options = {}) => {
+ for (const p of glob(path2)) {
+ try {
+ if (options.recursive && import_fs3.default.rmSync) {
+ import_fs3.default.rmSync(p, options);
+ } else if (options.recursive) {
+ import_fs3.default.rmdirSync(p, { recursive: true });
+ } else {
+ import_fs3.default.unlinkSync(p);
+ }
+ } catch (err) {
+ if (!options.force) {
+ throw err;
+ }
+ }
+ }
+};
+
+// pnp:/Users/style/Documents/Projects/juke-build/src/runner.ts
+var runner = new class Runner {
+ constructor() {
+ this.config = {};
+ this.targets = [];
+ this.parameters = [];
+ this.workers = [];
+ }
+ configure(config) {
+ this.config = config;
+ this.targets = config.targets || [];
+ this.parameters = config.parameters || [];
+ }
+ async start() {
+ const startedAt = Date.now();
+ const { globalFlags, taskArgs } = prepareArgs(process.argv.slice(2), this.config.singleTarget);
+ const globalParameterMap = parseArgs(globalFlags, this.parameters);
+ const targetsToRun = new Map();
+ const showListOfTargets = () => {
+ logger.info("Available targets:");
+ for (const target of this.targets) {
+ logger.log(" - " + import_chalk3.default.cyan(target.name));
+ }
+ logger.info("Available parameters:");
+ for (const parameter of this.parameters) {
+ logger.log(" --" + parameter.name + (parameter.alias ? `, -${parameter.alias}` : "") + ` (type: ${parameter.type})`);
+ }
+ };
+ if (globalFlags.includes("-h") || globalFlags.includes("--help")) {
+ showListOfTargets();
+ process.exit(1);
+ }
+ for (const [taskName, ...args] of taskArgs) {
+ const target = this.targets.find((t) => t.name === taskName);
+ if (!target) {
+ const nameStr = import_chalk3.default.cyan(taskName);
+ logger.error(`Task '${nameStr}' was not found.`);
+ showListOfTargets();
+ process.exit(1);
+ }
+ targetsToRun.set(target, { args });
+ }
+ if (targetsToRun.size === 0) {
+ if (!this.config.default) {
+ logger.error(`No task was provided in arguments.`);
+ showListOfTargets();
+ process.exit(1);
+ }
+ targetsToRun.set(this.config.default, {
+ args: []
+ });
+ }
+ let toVisit = Array.from(targetsToRun.entries());
+ while (true) {
+ const node = toVisit.shift();
+ if (!node) {
+ break;
+ }
+ const [target, meta] = node;
+ if (!meta.context) {
+ const localParameterMap = parseArgs(meta.args, target.parameters);
+ meta.context = {
+ get: (parameter) => {
+ let value = localParameterMap.get(parameter);
+ if (value === void 0) {
+ value = globalParameterMap.get(parameter);
+ }
+ if (parameter.isArray()) {
+ return value || [];
+ } else {
+ const returnValue = value && value[0];
+ return returnValue !== void 0 ? returnValue : null;
+ }
+ },
+ args: meta.args
+ };
+ }
+ if (!meta.dependsOn) {
+ const optionalDependsOn = (typeof target.dependsOn === "function" ? await target.dependsOn(meta.context) : target.dependsOn) || [];
+ meta.dependsOn = optionalDependsOn.filter((dep) => typeof dep === "object" && dep !== null);
+ }
+ for (const dependency of meta.dependsOn) {
+ if (!targetsToRun.has(dependency)) {
+ const depMeta = { args: meta.args };
+ targetsToRun.set(dependency, depMeta);
+ toVisit.push([dependency, depMeta]);
+ } else {
+ logger.debug("Dropped a possible circular dependency", dependency);
+ }
+ }
+ }
+ for (const [target, meta] of targetsToRun.entries()) {
+ const context = meta.context;
+ const dependsOn = meta.dependsOn;
+ const spawnedWorker = new Worker(target, context, dependsOn);
+ this.workers.push(spawnedWorker);
+ spawnedWorker.onFinish(() => {
+ for (const worker of this.workers) {
+ if (worker === spawnedWorker) {
+ continue;
+ }
+ worker.resolveDependency(target);
+ }
+ });
+ spawnedWorker.onFail(() => {
+ for (const worker of this.workers) {
+ if (worker === spawnedWorker) {
+ continue;
+ }
+ worker.rejectDependency(target);
+ }
+ });
+ }
+ const resolutions = await Promise.all(this.workers.map((worker) => new Promise((resolve) => {
+ worker.onFinish(() => resolve(true));
+ worker.onFail(() => resolve(false));
+ worker.start();
+ })));
+ const hasFailedWorkers = resolutions.includes(false);
+ if (!hasFailedWorkers) {
+ const time = (Date.now() - startedAt) / 1e3 + "s";
+ const timeStr = import_chalk3.default.magenta(time);
+ logger.action(`Done in ${timeStr}`);
+ }
+ return Number(hasFailedWorkers);
+ }
+}();
+var Worker = class {
+ constructor(target, context, dependsOn) {
+ this.target = target;
+ this.context = context;
+ this.dependsOn = dependsOn;
+ this.emitter = new import_events.default();
+ this.hasFailed = false;
+ this.dependencies = new Set(dependsOn);
+ this.debugLog("ready");
+ }
+ resolveDependency(target) {
+ var _a;
+ this.dependencies.delete(target);
+ (_a = this.generator) == null ? void 0 : _a.next();
+ }
+ rejectDependency(target) {
+ var _a;
+ this.dependencies.delete(target);
+ this.hasFailed = true;
+ (_a = this.generator) == null ? void 0 : _a.next();
+ }
+ start() {
+ this.generator = this.process();
+ this.generator.next();
+ }
+ onFinish(fn) {
+ this.emitter.once("finish", fn);
+ }
+ onFail(fn) {
+ this.emitter.once("fail", fn);
+ }
+ debugLog(...args) {
+ logger.debug(`${this.target.name}:`, ...args);
+ }
+ async *process() {
+ const nameStr = import_chalk3.default.cyan(this.target.name);
+ this.debugLog("Waiting for dependencies");
+ while (true) {
+ if (this.dependencies.size === 0) {
+ break;
+ }
+ yield;
+ }
+ if (this.hasFailed) {
+ const nameStr2 = import_chalk3.default.cyan(this.target.name);
+ logger.error(`Target '${nameStr2}' failed`);
+ this.emitter.emit("fail");
+ return;
+ }
+ if (this.target.onlyWhen) {
+ const result = await this.target.onlyWhen(this.context);
+ if (!result) {
+ logger.info(`Skipping '${nameStr}' (condition unmet)`);
+ this.emitter.emit("finish");
+ return;
+ }
+ this.debugLog("Needs rebuild based on onlyWhen condition");
+ }
+ this.debugLog("Comparing inputs and outputs");
+ const fileMapper = async (fileIo) => {
+ const optionalPaths = (typeof fileIo === "function" ? await fileIo(this.context) : fileIo) || [];
+ const paths = optionalPaths.filter((path2) => typeof path2 === "string");
+ return paths.flatMap((path2) => path2.includes("*") ? new Glob(path2).toFiles() : new File(path2));
+ };
+ const inputs = await fileMapper(this.target.inputs);
+ const outputs = await fileMapper(this.target.outputs);
+ if (inputs.length > 0) {
+ const needsRebuild = compareFiles(inputs, outputs);
+ if (!needsRebuild) {
+ logger.info(`Skipping '${nameStr}' (up to date)`);
+ this.emitter.emit("finish");
+ return;
+ } else {
+ this.debugLog("Needs rebuild, reason:", needsRebuild);
+ }
+ } else {
+ this.debugLog("Nothing to compare");
+ }
+ if (this.hasFailed) {
+ const nameStr2 = import_chalk3.default.cyan(this.target.name);
+ logger.error(`Target '${nameStr2}' failed (at file comparison stage)`);
+ this.emitter.emit("fail");
+ return;
+ }
+ if (this.target.executes) {
+ logger.action(`Starting '${nameStr}'`);
+ const startedAt = Date.now();
+ try {
+ await this.target.executes(this.context);
+ } catch (err) {
+ const time2 = (Date.now() - startedAt) / 1e3 + "s";
+ const timeStr2 = import_chalk3.default.magenta(time2);
+ if (err instanceof ExitCode) {
+ const codeStr = import_chalk3.default.red(err.code);
+ logger.error(`Target '${nameStr}' failed in ${timeStr2}, exit code: ${codeStr}`);
+ } else {
+ logger.error(`Target '${nameStr}' failed in ${timeStr2}, unhandled exception:`);
+ console.error(err);
+ }
+ this.emitter.emit("fail");
+ return;
+ }
+ const time = (Date.now() - startedAt) / 1e3 + "s";
+ const timeStr = import_chalk3.default.magenta(time);
+ logger.action(`Finished '${nameStr}' in ${timeStr}`);
+ }
+ if (outputs.length > 0) {
+ for (const file of outputs) {
+ file.touch();
+ }
+ }
+ this.emitter.emit("finish");
+ }
+};
+
+// pnp:/Users/style/Documents/Projects/juke-build/src/target.ts
+var Target = class {
+ constructor(target) {
+ this.name = target.name;
+ this.dependsOn = target.dependsOn || [];
+ this.executes = target.executes;
+ this.inputs = target.inputs || [];
+ this.outputs = target.outputs || [];
+ this.parameters = target.parameters || [];
+ this.onlyWhen = target.onlyWhen;
+ }
+};
+var createTarget = (config) => new Target(config);
+
+// pnp:/Users/style/Documents/Projects/juke-build/src/index.ts
+var chalk4 = import_chalk4.default;
+var lastExitCode = null;
+var setup = async (config) => {
+ logger.info(`Juke Build version ${version}`);
+ if (!config.file) {
+ logger.error(`Field 'file' is required in Juke.setup()`);
+ process.exit(1);
+ }
+ let buildModule = await import(config.file);
+ const isCommonJs = Boolean((0, import_module.createRequire)(config.file).cache[config.file]);
+ if (isCommonJs) {
+ buildModule = buildModule.default;
+ }
+ const targets = [];
+ const parameters = [];
+ for (const name of Object.keys(buildModule)) {
+ if (name === "default") {
+ continue;
+ }
+ const obj = buildModule[name];
+ if (obj instanceof Target) {
+ if (!obj.name) {
+ obj.name = name !== "Target" ? toKebabCase(name.replace(/Target$/, "")) : "target";
+ }
+ targets.push(obj);
+ continue;
+ }
+ if (obj instanceof Parameter) {
+ if (!obj.name) {
+ obj.name = name !== "Parameter" ? toKebabCase(name.replace(/Parameter$/, "")) : "parameter";
+ }
+ parameters.push(obj);
+ continue;
+ }
+ }
+ const DefaultTarget = buildModule.default || buildModule.DefaultTarget || buildModule.Default;
+ if (DefaultTarget && !(DefaultTarget instanceof Target)) {
+ logger.error(`Default export is not a valid 'Target' object.`);
+ process.exit(1);
+ }
+ runner.configure({
+ parameters,
+ targets,
+ default: DefaultTarget,
+ singleTarget: config.singleTarget
+ });
+ return runner.start().then((code) => {
+ lastExitCode = code;
+ return code;
+ });
+};
+var sleep = (time) => new Promise((resolve) => setTimeout(resolve, time));
+trap(["EXIT", "BREAK", "HUP", "INT", "TERM"], (signal) => {
+ if (signal !== "EXIT") {
+ console.log("Received", signal);
+ }
+ killChildren();
+ if (signal !== "EXIT") {
+ process.exit(1);
+ } else if (lastExitCode !== null) {
+ process.exit(lastExitCode);
+ }
+});
+var exceptionHandler = (err) => {
+ console.log(err);
+ killChildren();
+ process.exit(1);
+};
+process.on("unhandledRejection", exceptionHandler);
+process.on("uncaughtException", exceptionHandler);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+ ExitCode,
+ Parameter,
+ Target,
+ chalk,
+ chdir,
+ createParameter,
+ createTarget,
+ exec,
+ glob,
+ logger,
+ rm,
+ runner,
+ setup,
+ sleep
+});
diff --git a/tools/build/juke/package.json b/tools/build/juke/package.json
new file mode 100644
index 0000000000..0fef86e339
--- /dev/null
+++ b/tools/build/juke/package.json
@@ -0,0 +1,4 @@
+{
+ "private": true,
+ "type": "commonjs"
+}
diff --git a/tools/build/lib/byond.js b/tools/build/lib/byond.js
new file mode 100644
index 0000000000..8b6abcf8fe
--- /dev/null
+++ b/tools/build/lib/byond.js
@@ -0,0 +1,209 @@
+import fs from 'fs';
+import path from 'path';
+import Juke from '../juke/index.js';
+import { regQuery } from './winreg.js';
+
+/**
+ * Cached path to DM compiler
+ */
+let dmPath;
+
+const getDmPath = async (namedVersion) => {
+ // Use specific named version
+ if(namedVersion) {
+ return getNamedByondVersionPath(namedVersion);
+ }
+ if (dmPath) {
+ return dmPath;
+ }
+ dmPath = await (async () => {
+ // Search in array of paths
+ const paths = [
+ ...((process.env.DM_EXE && process.env.DM_EXE.split(',')) || []),
+ ...getDefaultNamedByondVersionPath(),
+ 'C:\\Program Files\\BYOND\\bin\\dm.exe',
+ 'C:\\Program Files (x86)\\BYOND\\bin\\dm.exe',
+ ['reg', 'HKLM\\Software\\Dantom\\BYOND', 'installpath'],
+ ['reg', 'HKLM\\SOFTWARE\\WOW6432Node\\Dantom\\BYOND', 'installpath'],
+ ];
+ const isFile = path => {
+ try {
+ return fs.statSync(path).isFile();
+ }
+ catch (err) {
+ return false;
+ }
+ };
+ for (let path of paths) {
+ // Resolve a registry key
+ if (Array.isArray(path)) {
+ const [type, ...args] = path;
+ path = await regQuery(...args);
+ }
+ if (!path) {
+ continue;
+ }
+ // Check if path exists
+ if (isFile(path)) {
+ return path;
+ }
+ if (isFile(path + '/dm.exe')) {
+ return path + '/dm.exe';
+ }
+ if (isFile(path + '/bin/dm.exe')) {
+ return path + '/bin/dm.exe';
+ }
+ }
+ // Default paths
+ return (
+ process.platform === 'win32' && 'dm.exe'
+ || 'DreamMaker'
+ );
+ })();
+ return dmPath;
+};
+
+
+
+const getNamedByondVersionPath = (namedVersion) =>{
+ const all_entries = getAllNamedDmVersions(true)
+ const map_entry = all_entries.find(x => x.name === namedVersion);
+ if(map_entry === undefined){
+ Juke.logger.error(`No named byond version with name "${namedVersion}" found.`);
+ throw new Juke.ExitCode(1);
+ }
+ return map_entry.path;
+}
+
+const getDefaultNamedByondVersionPath = () =>{
+ const all_entries = getAllNamedDmVersions(false)
+ const map_entry = all_entries.find(x => x.default == true);
+ if(map_entry === undefined)
+ return []
+ return [map_entry.path];
+}
+
+
+/** @type {[{ name, path, default }]} */
+let namedDmVersionList;
+export const NamedVersionFile = "tools/build/dm_versions.json"
+
+const getAllNamedDmVersions = (throw_on_fail) => {
+ if(!namedDmVersionList){
+ if(!fs.existsSync(NamedVersionFile)){
+ if(throw_on_fail){
+ Juke.logger.error(`No byond version map file found.`);
+ throw new Juke.ExitCode(1);
+ }
+ namedDmVersionList = []
+ return namedDmVersionList;
+ }
+ try{
+ namedDmVersionList = JSON.parse(fs.readFileSync(NamedVersionFile));
+ }
+ catch(err){
+ if(throw_on_fail){
+ Juke.logger.error(`Failed to parse byond version map file. ${err}`);
+ throw new Juke.ExitCode(1);
+ }
+ namedDmVersionList = []
+ return namedDmVersionList;
+ }
+ }
+ return namedDmVersionList;
+}
+
+/**
+ * @param {string} dmeFile
+ * @param {{
+ * defines?: string[];
+ * warningsAsErrors?: boolean;
+ * namedDmVersion?: string;
+ * }} options
+ */
+export const DreamMaker = async (dmeFile, options = {}) => {
+ if(options.namedDmVersion !== null){
+ Juke.logger.info('Using named byond version:', options.namedDmVersion);
+ }
+ const dmPath = await getDmPath(options.namedDmVersion);
+ // Get project basename
+ const dmeBaseName = dmeFile.replace(/\.dme$/, '');
+ // Make sure output files are writable
+ const testOutputFile = (name) => {
+ try {
+ fs.closeSync(fs.openSync(name, 'r+'));
+ }
+ catch (err) {
+ if (err && err.code === 'ENOENT') {
+ return;
+ }
+ if (err && err.code === 'EBUSY') {
+ Juke.logger.error(`File '${name}' is locked by the DreamDaemon process.`);
+ Juke.logger.error(`Stop the currently running server and try again.`);
+ throw new Juke.ExitCode(1);
+ }
+ throw err;
+ }
+ };
+
+ const testDmVersion = async (dmPath) => {
+ const execReturn = await Juke.exec(dmPath, [], { silent: true, throw: false });
+ const version = execReturn.combined.match(`DM compiler version (\\d+)\\.(\\d+)`)
+ if(version == null){
+ Juke.logger.error(`Unexpected DreamMaker return, ensure "${dmPath}" is correct DM path.`)
+ throw new Juke.ExitCode(1);
+ }
+ const requiredMajorVersion = 515;
+ const requiredMinorVersion = 1597 // First with -D switch functionality
+ const major = Number(version[1]);
+ const minor = Number(version[2]);
+ if(major < requiredMajorVersion || major == requiredMajorVersion && minor < requiredMinorVersion){
+ Juke.logger.error(`${requiredMajorVersion}.${requiredMinorVersion} or later DM version required. Version ${major}.${minor} found at: ${dmPath}`)
+ throw new Juke.ExitCode(1);
+ }
+ }
+
+ await testDmVersion(dmPath);
+ testOutputFile(`${dmeBaseName}.dmb`);
+ testOutputFile(`${dmeBaseName}.rsc`);
+
+ const runWithWarningChecks = async (dmPath, args) => {
+ const execReturn = await Juke.exec(dmPath, args);
+ if(options.warningsAsErrors){
+ const ignoredWarningCodes = options.ignoreWarningCodes ?? [];
+ if(ignoredWarningCodes.length > 0 ){
+ Juke.logger.info('Ignored warning codes:', ignoredWarningCodes.join(', '));
+ }
+ const base_regex = '\\d+:warning( \\([a-z_]*\\))?:'
+ const with_ignores = `\\d+:warning( \\([a-z_]*\\))?:(?!(${ignoredWarningCodes.map(x => `.*${x}.*$`).join('|')}))`
+ const reg = ignoredWarningCodes.length > 0 ? new RegExp(with_ignores, "m") : new RegExp(base_regex,"m")
+ if (options.warningsAsErrors && execReturn.combined.match(reg)) {
+ Juke.logger.error(`Compile warnings treated as errors`);
+ throw new Juke.ExitCode(2);
+ }
+ }
+ return execReturn;
+ }
+ // Compile
+ const { defines } = options;
+ if (defines && defines.length > 0) {
+ Juke.logger.info('Using defines:', defines.join(', '));
+ }
+
+ await runWithWarningChecks(dmPath, [...defines.map(def => `-D${def}`), dmeFile]);
+};
+
+
+/**
+* @param {{
+* dmbFile: string;
+* namedDmVersion?: string;
+* }} options
+*/
+export const DreamDaemon = async (options, ...args) => {
+ const dmPath = await getDmPath(options.namedDmVersion);
+ const baseDir = path.dirname(dmPath);
+ const ddExeName = process.platform === 'win32' ? 'dreamdaemon.exe' : 'DreamDaemon';
+ const ddExePath = baseDir === '.' ? ddExeName : path.join(baseDir, ddExeName);
+ return Juke.exec(ddExePath, [options.dmbFile, ...args]);
+};
diff --git a/tools/build/lib/winreg.js b/tools/build/lib/winreg.js
new file mode 100644
index 0000000000..0916ea3a31
--- /dev/null
+++ b/tools/build/lib/winreg.js
@@ -0,0 +1,42 @@
+/**
+ * Tools for dealing with Windows Registry bullshit.
+ *
+ * Adapted from `tgui/packages/tgui-dev-server/winreg.js`.
+ *
+ * @file
+ * @copyright 2021 Aleksej Komarov
+ * @license MIT
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+export const regQuery = async (path, key) => {
+ if (process.platform !== 'win32') {
+ return null;
+ }
+ try {
+ const command = `reg query "${path}" /v ${key}`;
+ const { stdout } = await promisify(exec)(command);
+ const keyPattern = ` ${key} `;
+ const indexOfKey = stdout.indexOf(keyPattern);
+ if (indexOfKey === -1) {
+ return null;
+ }
+ const indexOfEol = stdout.indexOf('\r\n', indexOfKey);
+ if (indexOfEol === -1) {
+ return null;
+ }
+ const indexOfValue = stdout.indexOf(
+ ' ',
+ indexOfKey + keyPattern.length);
+ if (indexOfValue === -1) {
+ return null;
+ }
+ const value = stdout.substring(indexOfValue + 4, indexOfEol);
+ return value;
+ }
+ catch (err) {
+ return null;
+ }
+};
diff --git a/tools/build/lib/yarn.js b/tools/build/lib/yarn.js
new file mode 100644
index 0000000000..84b717001f
--- /dev/null
+++ b/tools/build/lib/yarn.js
@@ -0,0 +1,16 @@
+import Juke from '../juke/index.js';
+
+let yarnPath;
+
+export const yarn = (...args) => {
+ if (!yarnPath) {
+ yarnPath = Juke.glob('./tgui/.yarn/releases/*.cjs')[0]
+ .replace('/tgui/', '/');
+ }
+ return Juke.exec('node', [
+ yarnPath,
+ ...args.filter((arg) => typeof arg === 'string'),
+ ], {
+ cwd: './tgui',
+ });
+};
diff --git a/tools/build/package.json b/tools/build/package.json
new file mode 100644
index 0000000000..e986b24bba
--- /dev/null
+++ b/tools/build/package.json
@@ -0,0 +1,4 @@
+{
+ "private": true,
+ "type": "module"
+}
diff --git a/tools/icon_cutter/README.md b/tools/icon_cutter/README.md
new file mode 100644
index 0000000000..91edd1a406
--- /dev/null
+++ b/tools/icon_cutter/README.md
@@ -0,0 +1,23 @@
+# Hypnagogic
+
+## What is this?
+
+This folder will hold a set of cached versions of hypnagogic, our icon cutter. We autodownload the tagged version from github on build.
+
+## How is it used?
+
+The cutter works off 2 inputs. A file, typically a png, and a toml config file in the format `{filename}.{other input extension}.toml`
+
+The input resource is transformed by the cutter following a set of rules set out in the .toml file.
+Typically these are very basic. We have a set of templates in repo stored in [cutter_templates/](../../cutter_templates/) and most uses just copy from them.
+
+You can find more information about it in its repository, found [here](https://github.com/actioninja/hypnagogic), the examples subfolder in particular contains fully detailed explanations of all the config values for the different types of cutting (there are more then one)
+
+## How does it work?
+
+Anytime you build the game, CBT will check and see if any of the files that the cutter cares about have been modified
+If they have been, the cutter will perform a full runthrough, and compile all inputs down into typically dmis
+
+These dmis can then be committed, and badabing badaboom we have autocut sprites.
+
+If you want to change the cutter version we have a set of config values in [dependancies.sh](../../dependencies.sh) that control it.
diff --git a/tools/icon_cutter/cache/.gitignore b/tools/icon_cutter/cache/.gitignore
new file mode 100644
index 0000000000..038aa919d4
--- /dev/null
+++ b/tools/icon_cutter/cache/.gitignore
@@ -0,0 +1 @@
+hypnagogic*
diff --git a/tools/icon_cutter/check.py b/tools/icon_cutter/check.py
new file mode 100644
index 0000000000..568ec27243
--- /dev/null
+++ b/tools/icon_cutter/check.py
@@ -0,0 +1,133 @@
+import glob
+import os
+import re
+import sys
+import hashlib
+import platform
+import subprocess
+from PIL import Image
+import numpy as np
+import difflib
+
+BUF_SIZE = 65536 # lets read stuff in 64kb chunks!
+chop_filename = re.compile(r"^.*(\..+?)$", re.M)
+chop_extension = re.compile(r"^(.*)\..+?$", re.M)
+
+def reshape_split(image: np.ndarray, cut_to: tuple):
+ img_height, img_width, channels = image.shape
+
+ tile_height, tile_width = cut_to
+
+ tiled_array = image.reshape(img_height // tile_height,
+ tile_height,
+ img_width // tile_width,
+ tile_width,
+ channels)
+ tiled_array = tiled_array.swapaxes(1, 2)
+ tiled_array = tiled_array.reshape(tile_height, -1, channels)
+ return tiled_array
+
+def get_file_hash(path):
+ path_suffix = re.sub(chop_filename, r"\1", path, count = 1)
+ if path_suffix == ".dmi" or path_suffix == ".png":
+ return hash_dmi(path)
+ else:
+ return hash_file(path)
+
+def hash_dmi(path):
+ md5 = hashlib.md5()
+
+ dmi = Image.open(path)
+ dmi = dmi.convert('RGBA')
+ dmi.load() # Needed only for .png EXIF data (see citation above)
+ dmi_metadata = dmi.info['Description']
+ md5.update(dmi_metadata.encode('utf-8'))
+
+ readable_metadata = dict(
+ map(lambda entry: (entry[0], entry[1]),
+ map(lambda entry : (entry[0].strip(), entry[1].strip()),
+ filter(lambda entry: entry[0].strip() == 'width' or entry[0].strip() == 'height',
+ map(lambda entry : entry.split("="), dmi_metadata.split("\n"))))))
+
+ icon_hash = hashlib.md5()
+ divided_dmi = reshape_split(np.asarray(dmi), (int(readable_metadata['height']), int(readable_metadata['width'])))
+ for i in range(divided_dmi.shape[0]):
+ bytes = divided_dmi[1].tobytes()
+ md5.update(bytes)
+ icon_hash.update(bytes)
+ return (md5.hexdigest(), dmi_metadata, icon_hash.hexdigest())
+
+def hash_file(path):
+ md5 = hashlib.md5()
+
+ with open(path, 'rb') as f:
+ while True:
+ data = f.read(BUF_SIZE)
+ if not data:
+ break
+ md5.update(data)
+
+ return (md5.hexdigest(), None, None)
+
+path_to_us = os.path.realpath(os.path.dirname(__file__))
+pass_count = 0
+fail_count = 0
+output_hash = {}
+files = []
+if platform.system() == "Windows":
+ files = glob.glob(f"{path_to_us}\..\\..\\icons\\**\*.toml", recursive = True)
+else:
+ files = glob.glob(f"{path_to_us}/../../icons/**/*.toml", recursive = True)
+for cutter_template in files:
+ resource_name = re.sub(chop_extension, r"\1", cutter_template, count = 1)
+ if not os.path.isfile(resource_name):
+ print(f"::error template={cutter_template} exists but lacks a matching resource file ({resource_name})")
+ fail_count += 1
+ continue
+
+ output_name = re.sub(chop_extension, r"\1.dmi", resource_name, count = 1)
+ if not os.path.isfile(output_name):
+ print(f"::error template={cutter_template} and resource={resource_name} exist but they lack a matching output={output_name}. (Try rebuilding)")
+ fail_count += 1
+ continue
+
+ output_hash[output_name] = get_file_hash(output_name)
+
+# Execute cutter
+if platform.system() == "Windows":
+ subprocess.run(f"{path_to_us}\..\\build\\build.bat --force-recut --ci icon-cutter")
+else:
+ subprocess.run(f"{path_to_us}/../build/build --force-recut --ci icon-cutter", shell = True)
+
+for output_name in output_hash:
+ old_hash, old_metadata, old_icon_hash = output_hash[output_name]
+ new_hash, new_metadata, new_icon_hash = get_file_hash(output_name)
+ if old_hash == new_hash:
+ pass_count += 1
+ continue
+ if old_metadata != new_metadata:
+ print("Metadata differs!")
+ events = ""
+ current_op = None
+ working = ""
+ for index, op in enumerate(difflib.ndiff(old_metadata, new_metadata)):
+ in_nothing = False
+ if current_op == None:
+ current_op = op[0]
+ if current_op != op[0]:
+ events += f"{current_op*10}\n{working}\n"
+ current_op = op[0]
+ working = ""
+ if op[0]== ' ':
+ continue
+ working += f"{op[-1]}"
+ events += f"{current_op*10}\n{working}\n"
+ print(events, end="")
+ if old_icon_hash != new_icon_hash:
+ print("Icon hashes differ!")
+ fail_count += 1
+ print(f"::error output={output_name} and its templates all exist but were not comitted fully compiled")
+
+print(f"{len(output_hash)} templates checked, {pass_count} passed, {fail_count} failed", end="")
+if fail_count > 0:
+ sys.exit(1)