diff --git a/.github/ISSUE_TEMPLATE/1-bug-report.yml b/.github/ISSUE_TEMPLATE/1-bug-report.yml index b5200cc93ad5ba..bc2f78a46ac722 100644 --- a/.github/ISSUE_TEMPLATE/1-bug-report.yml +++ b/.github/ISSUE_TEMPLATE/1-bug-report.yml @@ -33,13 +33,19 @@ body: be run using `node` directly without installing third-party dependencies or downloading code from the internet (i.e. no ZIP archive, no GitHub repository, etc.). + validations: + required: true - type: textarea attributes: label: How often does it reproduce? Is there a required condition? + validations: + required: true - type: textarea attributes: label: What is the expected behavior? Why is that the expected behavior? description: If possible please provide textual output instead of screenshots. + validations: + required: true - type: textarea attributes: label: What do you see instead? diff --git a/.github/label-pr-config.yml b/.github/label-pr-config.yml index 4f2c8bbce7232a..b3aaa0bf2ce9b8 100644 --- a/.github/label-pr-config.yml +++ b/.github/label-pr-config.yml @@ -187,6 +187,7 @@ allJsSubSystems: - readline - repl - report + - sqlite - stream - string_decoder - timers diff --git a/.github/workflows/auto-start-ci.yml b/.github/workflows/auto-start-ci.yml index c5c29881c85c68..15b35cea97b723 100644 --- a/.github/workflows/auto-start-ci.yml +++ b/.github/workflows/auto-start-ci.yml @@ -59,11 +59,15 @@ jobs: - name: Setup @node-core/utils run: | - ncu-config set username ${{ secrets.JENKINS_USER }} - ncu-config set token "${{ secrets.GH_USER_TOKEN }}" - ncu-config set jenkins_token ${{ secrets.JENKINS_TOKEN }} + ncu-config set username "$USERNAME" + ncu-config set token "$GH_TOKEN" + ncu-config set jenkins_token "$JENKINS_TOKEN" ncu-config set owner "${{ github.repository_owner }}" ncu-config set repo "$(echo ${{ github.repository }} | cut -d/ -f2)" + env: + USERNAME: ${{ secrets.JENKINS_USER }} + GH_TOKEN: ${{ secrets.GH_USER_TOKEN }} + JENKINS_TOKEN: ${{ secrets.JENKINS_TOKEN }} - name: Start the CI run: ./tools/actions/start-ci.sh ${{ needs.get-prs-for-ci.outputs.numbers }} diff --git a/.github/workflows/commit-queue.yml b/.github/workflows/commit-queue.yml index 04c91cb40dc663..9517c52f62a589 100644 --- a/.github/workflows/commit-queue.yml +++ b/.github/workflows/commit-queue.yml @@ -86,11 +86,15 @@ jobs: run: | ncu-config set branch ${GITHUB_REF_NAME} ncu-config set upstream origin - ncu-config set username "${{ secrets.GH_USER_NAME }}" - ncu-config set token "${{ secrets.GH_USER_TOKEN }}" - ncu-config set jenkins_token "${{ secrets.JENKINS_TOKEN }}" + ncu-config set username "$USERNAME" + ncu-config set token "$GH_TOKEN" + ncu-config set jenkins_token "$JENKINS_TOKEN" ncu-config set repo "${REPOSITORY}" ncu-config set owner "${OWNER}" + env: + USERNAME: ${{ secrets.JENKINS_USER }} + GH_TOKEN: ${{ secrets.GH_USER_TOKEN }} + JENKINS_TOKEN: ${{ secrets.JENKINS_TOKEN }} - name: Start the Commit Queue run: ./tools/actions/commit-queue.sh ${{ env.OWNER }} ${{ env.REPOSITORY }} ${{ needs.get_mergeable_prs.outputs.numbers }} diff --git a/.github/workflows/coverage-linux-without-intl.yml b/.github/workflows/coverage-linux-without-intl.yml index d3dc4baf78e3d5..66c192c95d605b 100644 --- a/.github/workflows/coverage-linux-without-intl.yml +++ b/.github/workflows/coverage-linux-without-intl.yml @@ -12,6 +12,7 @@ on: - tools/gyp/** - tools/test.py - .github/workflows/coverage-linux-without-intl.yml + - codecov.yml push: branches: - main @@ -24,6 +25,7 @@ on: - tools/gyp/** - tools/test.py - .github/workflows/coverage-linux-without-intl.yml + - codecov.yml concurrency: group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} @@ -58,7 +60,7 @@ jobs: - name: Environment Information run: npx envinfo - name: Install gcovr - run: pip install gcovr==4.2 + run: pip install gcovr==7.2 - name: Build run: make build-ci -j4 V=1 CONFIG_FLAGS="--error-on-warn --coverage --without-intl" # TODO(bcoe): fix the couple tests that fail with the inspector enabled. @@ -70,7 +72,7 @@ jobs: env: NODE_OPTIONS: --max-old-space-size=8192 - name: Report C++ - run: cd out && gcovr --gcov-exclude='.*\b(deps|usr|out|obj|cctest|embedding)\b' -v -r Release/obj.target --xml -o ../coverage/coverage-cxx.xml --root=$(cd ../ && pwd) + run: gcovr --object-directory=out -v --filter src --xml -o ./coverage/coverage-cxx.xml --root=./ --gcov-executable="llvm-cov-18 gcov" # Clean temporary output from gcov and c8, so that it's not uploaded: - name: Clean tmp run: rm -rf coverage/tmp && rm -rf out diff --git a/.github/workflows/coverage-linux.yml b/.github/workflows/coverage-linux.yml index 79f1f89470d41a..030eaabbe25efa 100644 --- a/.github/workflows/coverage-linux.yml +++ b/.github/workflows/coverage-linux.yml @@ -12,6 +12,7 @@ on: - tools/gyp/** - tools/test.py - .github/workflows/coverage-linux.yml + - codecov.yml push: branches: - main @@ -24,6 +25,7 @@ on: - tools/gyp/** - tools/test.py - .github/workflows/coverage-linux.yml + - codecov.yml concurrency: group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} @@ -58,7 +60,7 @@ jobs: - name: Environment Information run: npx envinfo - name: Install gcovr - run: pip install gcovr==4.2 + run: pip install gcovr==7.2 - name: Build run: make build-ci -j4 V=1 CONFIG_FLAGS="--error-on-warn --coverage" # TODO(bcoe): fix the couple tests that fail with the inspector enabled. @@ -70,7 +72,7 @@ jobs: env: NODE_OPTIONS: --max-old-space-size=8192 - name: Report C++ - run: cd out && gcovr --gcov-exclude='.*\b(deps|usr|out|obj|cctest|embedding)\b' -v -r Release/obj.target --xml -o ../coverage/coverage-cxx.xml --root=$(cd ../ && pwd) + run: gcovr --object-directory=out -v --filter src --xml -o ./coverage/coverage-cxx.xml --root=./ --gcov-executable="llvm-cov-18 gcov" # Clean temporary output from gcov and c8, so that it's not uploaded: - name: Clean tmp run: rm -rf coverage/tmp && rm -rf out diff --git a/.github/workflows/coverage-windows.yml b/.github/workflows/coverage-windows.yml index 686748b5173612..cdaaa3563904fa 100644 --- a/.github/workflows/coverage-windows.yml +++ b/.github/workflows/coverage-windows.yml @@ -12,6 +12,7 @@ on: - tools/gyp/** - tools/test.py - .github/workflows/coverage-windows.yml + - codecov.yml push: branches: - main @@ -24,6 +25,7 @@ on: - tools/gyp/** - tools/test.py - .github/workflows/coverage-windows.yml + - codecov.yml concurrency: group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} diff --git a/.github/workflows/notify-on-push.yml b/.github/workflows/notify-on-push.yml index efb6bc1a173582..725c1c2dc5a639 100644 --- a/.github/workflows/notify-on-push.yml +++ b/.github/workflows/notify-on-push.yml @@ -60,7 +60,7 @@ jobs: env: SLACK_COLOR: '#DE512A' SLACK_ICON: https://github.com/nodejs.png?size=48 - SLACK_TITLE: Invalid commit was pushed to ${{ github.repository.default_branch }} + SLACK_TITLE: Invalid commit was pushed to ${{ github.ref }} SLACK_MESSAGE: | A commit with an invalid message was pushed to by . diff --git a/.github/workflows/test-asan.yml b/.github/workflows/test-asan.yml index 1d699e2846e6f8..f2767253aa4091 100644 --- a/.github/workflows/test-asan.yml +++ b/.github/workflows/test-asan.yml @@ -38,7 +38,7 @@ permissions: jobs: test-asan: - if: github.event.pull_request.draft == false + if: false # Temporarily disabled. References: https://github.com/nodejs/node/pull/52374, https://github.com/nodejs/node/pull/53651#issuecomment-2198510810 runs-on: ubuntu-20.04 env: CC: sccache clang diff --git a/.github/workflows/tools.yml b/.github/workflows/tools.yml index 891ab1e1bda6f4..bfefa3d36aab71 100644 --- a/.github/workflows/tools.yml +++ b/.github/workflows/tools.yml @@ -16,6 +16,7 @@ on: - acorn - acorn-walk - ada + - amaro - brotli - c-ares - cjs-module-lexer @@ -82,6 +83,14 @@ jobs: cat temp-output tail -n1 temp-output | grep "NEW_VERSION=" >> "$GITHUB_ENV" || true rm temp-output + - id: amaro + subsystem: deps + label: dependencies + run: | + ./tools/dep_updaters/update-amaro.sh > temp-output + cat temp-output + tail -n1 temp-output | grep "NEW_VERSION=" >> "$GITHUB_ENV" || true + rm temp-output - id: brotli subsystem: deps label: dependencies diff --git a/CHANGELOG.md b/CHANGELOG.md index d4a9746ce8927b..223e855578b550 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -38,7 +38,8 @@ release. -22.5.1
+22.6.0
+22.5.1
22.5.0
22.4.1
22.4.0
diff --git a/LICENSE b/LICENSE index 64b2e7f734b3f2..1daa041f0cf188 100644 --- a/LICENSE +++ b/LICENSE @@ -130,6 +130,31 @@ The externally maintained libraries used by Node.js are: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """ +- amaro, located at deps/amaro, is licensed as follows: + """ + MIT License + + Copyright (c) Marco Ippolito and Amaro contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in all + copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + SOFTWARE. + """ + - ICU, located at deps/icu-small, is licensed as follows: """ UNICODE LICENSE V3 @@ -2194,39 +2219,6 @@ The externally maintained libraries used by Node.js are: THE POSSIBILITY OF SUCH DAMAGE. """ -- highlight.js, located at doc/api_assets/highlight.pack.js, is licensed as follows: - """ - BSD 3-Clause License - - Copyright (c) 2006, Ivan Sagalaev. - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - * Neither the name of the copyright holder nor the names of its - contributors may be used to endorse or promote products derived from - this software without specific prior written permission. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" - AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE - FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, - OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE - OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - """ - - node-heapdump, located at src/heap_utils.cc, is licensed as follows: """ ISC License diff --git a/Makefile b/Makefile index f179fcbca79733..dba16e5e2e3fbd 100644 --- a/Makefile +++ b/Makefile @@ -175,7 +175,8 @@ with-code-cache test-code-cache: out/Makefile: config.gypi common.gypi common_node.gypi node.gyp \ deps/uv/uv.gyp deps/llhttp/llhttp.gyp deps/zlib/zlib.gyp \ deps/simdutf/simdutf.gyp deps/ada/ada.gyp deps/nbytes/nbytes.gyp \ - tools/v8_gypfiles/toolchain.gypi tools/v8_gypfiles/features.gypi \ + tools/v8_gypfiles/toolchain.gypi \ + tools/v8_gypfiles/features.gypi \ tools/v8_gypfiles/inspector.gypi tools/v8_gypfiles/v8.gyp $(PYTHON) tools/gyp_node.py -f make @@ -253,7 +254,7 @@ coverage: coverage-test ## Run the tests and generate a coverage report. .PHONY: coverage-build coverage-build: all -$(MAKE) coverage-build-js - if [ ! -d gcovr ]; then $(PYTHON) -m pip install -t gcovr gcovr==4.2; fi + if [ ! -d gcovr ]; then $(PYTHON) -m pip install -t gcovr gcovr==7.2; fi $(MAKE) .PHONY: coverage-build-js @@ -269,9 +270,10 @@ coverage-test: coverage-build -NODE_V8_COVERAGE=coverage/tmp \ TEST_CI_ARGS="$(TEST_CI_ARGS) --type=coverage" $(MAKE) $(COVTESTS) $(MAKE) coverage-report-js - -(cd out && PYTHONPATH=../gcovr $(PYTHON) -m gcovr \ - --gcov-exclude='.*\b(deps|usr|out|cctest|embedding)\b' -v \ - -r ../src/ --object-directory Release/obj.target \ + -(PYTHONPATH=./gcovr $(PYTHON) -m gcovr \ + --object-directory=out \ + --filter src -v \ + --root ./ \ --html --html-details -o ../coverage/cxxcoverage.html \ --gcov-executable="$(GCOV)") @printf "Javascript coverage %%: " diff --git a/README.md b/README.md index a248cda95d9d1f..59590f632725f1 100644 --- a/README.md +++ b/README.md @@ -164,14 +164,12 @@ For information about the governance of the Node.js project, see * [aduh95](https://github.com/aduh95) - **Antoine du Hamel** <> (he/him) -* [apapirovski](https://github.com/apapirovski) - - **Anatoli Papirovski** <> (he/him) +* [anonrig](https://github.com/anonrig) - + **Yagiz Nizipli** <> (he/him) * [benjamingr](https://github.com/benjamingr) - **Benjamin Gruenbaum** <> * [BridgeAR](https://github.com/BridgeAR) - **Ruben Bridgewater** <> (he/him) -* [GeoffreyBooth](https://github.com/geoffreybooth) - - **Geoffrey Booth** <> (he/him) * [gireeshpunathil](https://github.com/gireeshpunathil) - **Gireesh Punathil** <> (he/him) * [jasnell](https://github.com/jasnell) - @@ -205,8 +203,8 @@ For information about the governance of the Node.js project, see #### TSC regular members -* [anonrig](https://github.com/anonrig) - - **Yagiz Nizipli** <> (he/him) +* [apapirovski](https://github.com/apapirovski) - + **Anatoli Papirovski** <> (he/him) * [BethGriggs](https://github.com/BethGriggs) - **Beth Griggs** <> (she/her) * [bnoordhuis](https://github.com/bnoordhuis) - @@ -215,6 +213,8 @@ For information about the governance of the Node.js project, see **Colin Ihrig** <> (he/him) * [codebytere](https://github.com/codebytere) - **Shelley Vohr** <> (she/her) +* [GeoffreyBooth](https://github.com/GeoffreyBooth) - + **Geoffrey Booth** <> (he/him) * [Trott](https://github.com/Trott) - **Rich Trott** <> (he/him) @@ -329,7 +329,7 @@ For information about the governance of the Node.js project, see **Deokjin Kim** <> (he/him) * [edsadr](https://github.com/edsadr) - **Adrian Estrada** <> (he/him) -* [erickwendel](https://github.com/erickwendel) - +* [ErickWendel](https://github.com/ErickWendel) - **Erick Wendel** <> (he/him) * [Ethan-Arrowood](https://github.com/Ethan-Arrowood) - **Ethan Arrowood** <> (he/him) @@ -343,7 +343,7 @@ For information about the governance of the Node.js project, see **Gabriel Schulhof** <> * [gengjiawen](https://github.com/gengjiawen) - **Jiawen Geng** <> -* [GeoffreyBooth](https://github.com/geoffreybooth) - +* [GeoffreyBooth](https://github.com/GeoffreyBooth) - **Geoffrey Booth** <> (he/him) * [gireeshpunathil](https://github.com/gireeshpunathil) - **Gireesh Punathil** <> (he/him) @@ -355,6 +355,8 @@ For information about the governance of the Node.js project, see **Harshitha K P** <> (she/her) * [himself65](https://github.com/himself65) - **Zeyu "Alex" Yang** <> (he/him) +* [jakecastelli](https://github.com/jakecastelli) - + **Jake Yuesong Li** <> (he/him) * [JakobJingleheimer](https://github.com/JakobJingleheimer) - **Jacob Smith** <> (he/him) * [jasnell](https://github.com/jasnell) - @@ -379,7 +381,7 @@ For information about the governance of the Node.js project, see **Chengzhong Wu** <> (he/him) * [lemire](https://github.com/lemire) - **Daniel Lemire** <> -* [linkgoron](https://github.com/linkgoron) - +* [Linkgoron](https://github.com/Linkgoron) - **Nitzan Uziely** <> * [LiviaMedeiros](https://github.com/LiviaMedeiros) - **LiviaMedeiros** <> @@ -393,6 +395,8 @@ For information about the governance of the Node.js project, see **Marco Ippolito** <> (he/him) * [marsonya](https://github.com/marsonya) - **Akhil Marsonya** <> (he/him) +* [MattiasBuelens](https://github.com/MattiasBuelens) - + **Mattias Buelens** <> (he/him) * [mcollina](https://github.com/mcollina) - **Matteo Collina** <> (he/him) * [meixg](https://github.com/meixg) - @@ -443,7 +447,7 @@ For information about the governance of the Node.js project, see **Trivikram Kamat** <> * [Trott](https://github.com/Trott) - **Rich Trott** <> (he/him) -* [UlisesGascon](https://github.com/ulisesgascon) - +* [UlisesGascon](https://github.com/UlisesGascon) - **Ulises Gascón** <> (he/him) * [vmoroz](https://github.com/vmoroz) - **Vladimir Morozov** <> (he/him) diff --git a/benchmark/napi/property_keys/.gitignore b/benchmark/napi/property_keys/.gitignore new file mode 100644 index 00000000000000..567609b1234a9b --- /dev/null +++ b/benchmark/napi/property_keys/.gitignore @@ -0,0 +1 @@ +build/ diff --git a/benchmark/napi/property_keys/binding.cc b/benchmark/napi/property_keys/binding.cc new file mode 100644 index 00000000000000..258193f4b356a7 --- /dev/null +++ b/benchmark/napi/property_keys/binding.cc @@ -0,0 +1,111 @@ +#include +#include +#include + +#define NODE_API_CALL(call) \ + do { \ + napi_status status = call; \ + if (status != napi_ok) { \ + fprintf(stderr, #call " failed: %d\n", status); \ + abort(); \ + } \ + } while (0) + +#define ABORT_IF_FALSE(condition) \ + if (!(condition)) { \ + fprintf(stderr, #condition " failed\n"); \ + abort(); \ + } + +static napi_value Runner(napi_env env, + napi_callback_info info, + napi_value property_key) { + napi_value argv[2], undefined, js_array_length, start, end; + size_t argc = 2; + napi_valuetype val_type = napi_undefined; + bool is_array = false; + uint32_t array_length = 0; + napi_value* native_array; + + // Validate params and retrieve start and end function. + NODE_API_CALL(napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr)); + ABORT_IF_FALSE(argc == 2); + NODE_API_CALL(napi_typeof(env, argv[0], &val_type)); + ABORT_IF_FALSE(val_type == napi_object); + NODE_API_CALL(napi_is_array(env, argv[1], &is_array)); + ABORT_IF_FALSE(is_array); + NODE_API_CALL(napi_get_array_length(env, argv[1], &array_length)); + NODE_API_CALL(napi_get_named_property(env, argv[0], "start", &start)); + NODE_API_CALL(napi_typeof(env, start, &val_type)); + ABORT_IF_FALSE(val_type == napi_function); + NODE_API_CALL(napi_get_named_property(env, argv[0], "end", &end)); + NODE_API_CALL(napi_typeof(env, end, &val_type)); + ABORT_IF_FALSE(val_type == napi_function); + + NODE_API_CALL(napi_get_undefined(env, &undefined)); + NODE_API_CALL(napi_create_uint32(env, array_length, &js_array_length)); + + // Copy objects into a native array. + native_array = + static_cast(malloc(array_length * sizeof(napi_value))); + for (uint32_t idx = 0; idx < array_length; idx++) { + NODE_API_CALL(napi_get_element(env, argv[1], idx, &native_array[idx])); + } + + // Start the benchmark. + napi_call_function(env, argv[0], start, 0, nullptr, nullptr); + + for (uint32_t idx = 0; idx < array_length; idx++) { + NODE_API_CALL( + napi_set_property(env, native_array[idx], property_key, undefined)); + } + + // Conclude the benchmark. + NODE_API_CALL( + napi_call_function(env, argv[0], end, 1, &js_array_length, nullptr)); + + free(native_array); + + return undefined; +} + +static napi_value RunPropertyKey(napi_env env, napi_callback_info info) { + napi_value property_key; + NODE_API_CALL(node_api_create_property_key_utf16( + env, u"prop", NAPI_AUTO_LENGTH, &property_key)); + return Runner(env, info, property_key); +} + +static napi_value RunNormalString(napi_env env, napi_callback_info info) { + napi_value property_key; + NODE_API_CALL( + napi_create_string_utf16(env, u"prop", NAPI_AUTO_LENGTH, &property_key)); + return Runner(env, info, property_key); +} + +NAPI_MODULE_INIT() { + napi_property_descriptor props[] = { + {"RunPropertyKey", + nullptr, + RunPropertyKey, + nullptr, + nullptr, + nullptr, + static_cast(napi_writable | napi_configurable | + napi_enumerable), + nullptr}, + {"RunNormalString", + nullptr, + RunNormalString, + nullptr, + nullptr, + nullptr, + static_cast(napi_writable | napi_configurable | + napi_enumerable), + nullptr}, + }; + + NODE_API_CALL(napi_define_properties( + env, exports, sizeof(props) / sizeof(*props), props)); + return exports; +} diff --git a/benchmark/napi/property_keys/binding.gyp b/benchmark/napi/property_keys/binding.gyp new file mode 100644 index 00000000000000..0006991c5d1b7c --- /dev/null +++ b/benchmark/napi/property_keys/binding.gyp @@ -0,0 +1,9 @@ +{ + 'targets': [ + { + 'target_name': 'binding', + 'sources': [ 'binding.cc' ], + 'defines': [ 'NAPI_EXPERIMENTAL' ], + } + ] +} diff --git a/benchmark/napi/property_keys/index.js b/benchmark/napi/property_keys/index.js new file mode 100644 index 00000000000000..258c8aabdd116e --- /dev/null +++ b/benchmark/napi/property_keys/index.js @@ -0,0 +1,15 @@ +'use strict'; + +const common = require('../../common.js'); + +const binding = require(`./build/${common.buildType}/binding`); + +const bench = common.createBenchmark(main, { + n: [5e6], + implem: ['RunPropertyKey', 'RunNormalString'], +}); + +function main({ n, implem }) { + const objs = Array(n).fill(null).map((item) => new Object()); + binding[implem](bench, objs); +} diff --git a/benchmark/napi/ref/addon.c b/benchmark/napi/ref/addon.c index 2a7d3c8b2df23e..bced905cab8bc6 100644 --- a/benchmark/napi/ref/addon.c +++ b/benchmark/napi/ref/addon.c @@ -33,7 +33,7 @@ SetCount(napi_env env, napi_callback_info info) { return NULL; } -static void IncrementCounter(node_api_nogc_env env, void* data, void* hint) { +static void IncrementCounter(node_api_basic_env env, void* data, void* hint) { size_t* count = data; (*count) = (*count) + 1; } diff --git a/codecov.yml b/codecov.yml index 80ee32b360abce..05410f5c18957b 100644 --- a/codecov.yml +++ b/codecov.yml @@ -1,19 +1,19 @@ -# TODO(bcoe): re-enable coverage report comments, once we can figure out -# how to make them more accurate for the Node.js project, -# See: https://github.com/nodejs/node/issues/35759 -comment: false -# # Only show diff and files changed: -# layout: "diff, files" -# # Don't post if no changes in coverage: -# require_changes: true +comment: + # Only show diff and files changed: + layout: diff, files + # Don't post if no changes in coverage: + require_changes: true codecov: - branch: main notify: # Wait for all coverage builds: + # - coverage-linux.yml + # - coverage-windows.yml [manually disabled see #50489] + # - coverage-linux-without-intl.yml after_n_builds: 2 coverage: + # Useful for blocking Pull Requests that don't meet a particular coverage threshold. status: project: off patch: off diff --git a/common.gypi b/common.gypi index 637f8494dea889..32a298414b5392 100644 --- a/common.gypi +++ b/common.gypi @@ -36,7 +36,7 @@ # Reset this number to 0 on major V8 upgrades. # Increment by one for each non-official patch applied to deps/v8. - 'v8_embedder_string': '-node.16', + 'v8_embedder_string': '-node.18', ##### V8 defaults for Node.js ##### @@ -113,6 +113,7 @@ ['target_arch in "arm ia32 mips mipsel ppc"', { 'v8_enable_pointer_compression': 0, 'v8_enable_31bit_smis_on_64bit_arch': 0, + 'v8_enable_sandbox': 0 }], ['target_arch in "ppc64 s390x"', { 'v8_enable_backtrace': 1, diff --git a/configure.py b/configure.py index 379fb5bb06c413..9c6c0a56ccac6d 100755 --- a/configure.py +++ b/configure.py @@ -1306,6 +1306,9 @@ def host_arch_win(): return matchup.get(arch, 'ia32') +def set_configuration_variable(configs, name, release=None, debug=None): + configs['Release'][name] = release + configs['Debug'][name] = debug def configure_arm(o): if options.arm_float_abi: @@ -1620,7 +1623,9 @@ def configure_library(lib, output, pkgname=None): output['libraries'] += pkg_libs.split() -def configure_v8(o): +def configure_v8(o, configs): + set_configuration_variable(configs, 'v8_enable_v8_checks', release=1, debug=0) + o['variables']['v8_enable_webassembly'] = 0 if options.v8_lite_mode else 1 o['variables']['v8_enable_javascript_promise_hooks'] = 1 o['variables']['v8_enable_lite_mode'] = 1 if options.v8_lite_mode else 0 @@ -1635,10 +1640,10 @@ def configure_v8(o): o['variables']['v8_enable_maglev'] = B(not options.v8_disable_maglev and o['variables']['target_arch'] in maglev_enabled_architectures) o['variables']['v8_enable_pointer_compression'] = 1 if options.enable_pointer_compression else 0 + o['variables']['v8_enable_sandbox'] = 1 if options.enable_pointer_compression else 0 o['variables']['v8_enable_31bit_smis_on_64bit_arch'] = 1 if options.enable_pointer_compression else 0 o['variables']['v8_enable_shared_ro_heap'] = 0 if options.enable_pointer_compression or options.disable_shared_ro_heap else 1 o['variables']['v8_enable_extensible_ro_snapshot'] = 0 - o['variables']['v8_enable_v8_checks'] = 1 if options.debug else 0 o['variables']['v8_trace_maps'] = 1 if options.trace_maps else 0 o['variables']['node_use_v8_platform'] = b(not options.without_v8_platform) o['variables']['node_use_bundled_v8'] = b(not options.without_bundled_v8) @@ -2154,6 +2159,10 @@ def make_bin_override(): 'defines': [], 'cflags': [], } +configurations = { + 'Release': { 'variables': {} }, + 'Debug': { 'variables': {} }, +} # Print a warning when the compiler is too old. check_compiler(output) @@ -2181,7 +2190,7 @@ def make_bin_override(): configure_library('ngtcp2', output, pkgname='libngtcp2') configure_library('sqlite', output, pkgname='sqlite3') configure_library('uvwasi', output, pkgname='libuvwasi') -configure_v8(output) +configure_v8(output, configurations) configure_openssl(output) configure_intl(output) configure_static(output) @@ -2204,7 +2213,6 @@ def make_bin_override(): # move everything else to target_defaults variables = output['variables'] del output['variables'] -variables['is_debug'] = B(options.debug) # make_global_settings should be a root level element too if 'make_global_settings' in output: @@ -2213,6 +2221,9 @@ def make_bin_override(): else: make_global_settings = False +# Add configurations to target defaults +output['configurations'] = configurations + output = { 'variables': variables, 'target_defaults': output, @@ -2223,7 +2234,7 @@ def make_bin_override(): print_verbose(output) write('config.gypi', do_not_edit + - pprint.pformat(output, indent=2, width=1024) + '\n') + pprint.pformat(output, indent=2, width=128) + '\n') write('config.status', '#!/bin/sh\nset -x\nexec ./configure ' + ' '.join([shlex.quote(arg) for arg in original_argv]) + '\n') diff --git a/deps/amaro/LICENSE.md b/deps/amaro/LICENSE.md new file mode 100644 index 00000000000000..debb68feeb8aad --- /dev/null +++ b/deps/amaro/LICENSE.md @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Marco Ippolito and Amaro contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/deps/amaro/README.md b/deps/amaro/README.md new file mode 100644 index 00000000000000..0a22d289da9072 --- /dev/null +++ b/deps/amaro/README.md @@ -0,0 +1,53 @@ +# Amaro + +Amaro is a wrapper around `@swc/wasm-typescript`, a WebAssembly port of the SWC TypeScript parser. +It's currently used as an internal in Node.js for [Type Stripping](https://github.com/nodejs/loaders/issues/208), but in the future it will be possible to be upgraded separately by users. +The main goal of this package is to provide a stable API for TypeScript parser, which is unstable and subject to change. + +> Amaro means "bitter" in Italian. It's a reference to [Mount Amaro](https://en.wikipedia.org/wiki/Monte_Amaro_(Abruzzo)) on whose slopes this package was conceived. + +## How to Install + +To install Amaro, run: + +```shell +npm install amaro +``` + +## How to Use + +By default Amaro exports a `transformSync` function that performs type stripping. +Stack traces are preserved, by replacing removed types with white spaces. + +```javascript +const amaro = require('amaro'); +const { code } = amaro.transformSync("const foo: string = 'bar';"); +console.log(code); // "const foo = 'bar';" +``` + +### How to update SWC + +To update the SWC version, run: + +```shell +./tools/update-swc.sh +git add deps +git commit -m "chore: update swc to vX.Y.Z" +``` + +Once you have updated the rust source code we must build the wasm. +To build the wasm it is necessary to have Docker installed. + +```shell +node ./tools/build-wasm.js +git add lib +git commit -m "chore: build wasm from swc vX.Y.Z" +``` + +### TypeScript Version + +The supported TypeScript version is 5.5.4. + +## License (MIT) + +See [`LICENSE.md`](./LICENSE.md). diff --git a/deps/amaro/dist/index.js b/deps/amaro/dist/index.js new file mode 100644 index 00000000000000..a07a3bb8a8de04 --- /dev/null +++ b/deps/amaro/dist/index.js @@ -0,0 +1,666 @@ +(() => { // webpackBootstrap +var __webpack_modules__ = ({ +"230": (function (module, __unused_webpack_exports, __webpack_require__) { +let imports = {}; +imports['__wbindgen_placeholder__'] = module.exports; +let wasm; +const { TextDecoder, TextEncoder } = __webpack_require__(837); + +let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true }); + +cachedTextDecoder.decode(); + +let cachedUint8Memory0 = null; + +function getUint8Memory0() { + if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) { + cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8Memory0; +} + +function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len)); +} + +const heap = new Array(128).fill(undefined); + +heap.push(undefined, null, true, false); + +let heap_next = heap.length; + +function addHeapObject(obj) { + if (heap_next === heap.length) heap.push(heap.length + 1); + const idx = heap_next; + heap_next = heap[idx]; + + heap[idx] = obj; + return idx; +} + +function getObject(idx) { return heap[idx]; } + +let WASM_VECTOR_LEN = 0; + +let cachedTextEncoder = new TextEncoder('utf-8'); + +const encodeString = (typeof cachedTextEncoder.encodeInto === 'function' + ? function (arg, view) { + return cachedTextEncoder.encodeInto(arg, view); +} + : function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; +}); + +function passStringToWasm0(arg, malloc, realloc) { + + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length, 1) >>> 0; + getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len, 1) >>> 0; + + const mem = getUint8Memory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; + const view = getUint8Memory0().subarray(ptr + offset, ptr + len); + const ret = encodeString(arg, view); + + offset += ret.written; + ptr = realloc(ptr, len, offset, 1) >>> 0; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} + +function isLikeNone(x) { + return x === undefined || x === null; +} + +let cachedInt32Memory0 = null; + +function getInt32Memory0() { + if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) { + cachedInt32Memory0 = new Int32Array(wasm.memory.buffer); + } + return cachedInt32Memory0; +} + +function dropObject(idx) { + if (idx < 132) return; + heap[idx] = heap_next; + heap_next = idx; +} + +function takeObject(idx) { + const ret = getObject(idx); + dropObject(idx); + return ret; +} + + +let cachedDataView = null; +/** @returns {DataView} */ +function getDataView() { + if (cachedDataView === null || cachedDataView.buffer !== wasm.memory.buffer) { + cachedDataView = new DataView(wasm.memory.buffer); + } + return cachedDataView; +} + +let cachedFloat64Memory0 = null; + + +function getFloat64Memory0() { + if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) { + cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer); + } + return cachedFloat64Memory0; +} + +function debugString(val) { + // primitive types + const type = typeof val; + if (type == 'number' || type == 'boolean' || val == null) { + return `${val}`; + } + if (type == 'string') { + return `"${val}"`; + } + if (type == 'symbol') { + const description = val.description; + if (description == null) { + return 'Symbol'; + } else { + return `Symbol(${description})`; + } + } + if (type == 'function') { + const name = val.name; + if (typeof name == 'string' && name.length > 0) { + return `Function(${name})`; + } else { + return 'Function'; + } + } + // objects + if (Array.isArray(val)) { + const length = val.length; + let debug = '['; + if (length > 0) { + debug += debugString(val[0]); + } + for(let i = 1; i < length; i++) { + debug += ', ' + debugString(val[i]); + } + debug += ']'; + return debug; + } + // Test for built-in + const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); + let className; + if (builtInMatches.length > 1) { + className = builtInMatches[1]; + } else { + // Failed to match the standard '[object ClassName]' + return toString.call(val); + } + if (className == 'Object') { + // we're a user defined class or Object + // JSON.stringify avoids problems with cycles, and is generally much + // easier than looping through ownProperties of `val`. + try { + return 'Object(' + JSON.stringify(val) + ')'; + } catch (_) { + return 'Object'; + } + } + // errors + if (val instanceof Error) { + return `${val.name}: ${val.message}\n${val.stack}`; + } + // TODO we could test for more things here, like `Set`s and `Map`s. + return className; +} + +const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined') + ? { register: () => {}, unregister: () => {} } + : new FinalizationRegistry(state => { + wasm.__wbindgen_export_2.get(state.dtor)(state.a, state.b) +}); + +function makeMutClosure(arg0, arg1, dtor, f) { + const state = { a: arg0, b: arg1, cnt: 1, dtor }; + const real = (...args) => { + // First up with a closure we increment the internal reference + // count. This ensures that the Rust closure environment won't + // be deallocated while we're invoking it. + state.cnt++; + const a = state.a; + state.a = 0; + try { + return f(a, state.b, ...args); + } finally { + if (--state.cnt === 0) { + wasm.__wbindgen_export_2.get(state.dtor)(a, state.b); + CLOSURE_DTORS.unregister(state); + } else { + state.a = a; + } + } + }; + real.original = state; + CLOSURE_DTORS.register(real, state, state); + return real; +} +function __wbg_adapter_38(arg0, arg1, arg2) { + wasm.__wbindgen_export_3(arg0, arg1, addHeapObject(arg2)); +} + +/** +* @param {string} input +* @param {any} options +* @returns {Promise} +*/ +module.exports.transform = function(input, options) { + const ret = wasm.transform(addHeapObject(input), addHeapObject(options)); + return takeObject(ret); +}; + +/** +* @param {string} input +* @param {any} options +* @returns {any} +*/ +module.exports.transformSync = function(input, options) { + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + wasm.transformSync(retptr, addHeapObject(input), addHeapObject(options)); + var r0 = getDataView().getInt32(retptr + 4 * 0, true); + var r1 = getDataView().getInt32(retptr + 4 * 1, true); + var r2 = getDataView().getInt32(retptr + 4 * 2, true); + if (r2) { + throw takeObject(r1); + } + return takeObject(r0); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + } +}; + +function getCachedStringFromWasm0(ptr, len) { + if (ptr === 0) { + return getObject(len); + } else { + return getStringFromWasm0(ptr, len); + } +} + +function handleError(f, args) { + try { + return f.apply(this, args); + } catch (e) { + wasm.__wbindgen_export_4(addHeapObject(e)); + } +} +function __wbg_adapter_57(arg0, arg1, arg2, arg3) { + wasm.__wbindgen_export_5(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3)); +} + +module.exports.__wbindgen_string_new = function(arg0, arg1) { + const ret = getStringFromWasm0(arg0, arg1); + return addHeapObject(ret); +}; + +module.exports.__wbg_new_81740750da40724f = function(arg0, arg1) { + try { + var state0 = {a: arg0, b: arg1}; + var cb0 = (arg0, arg1) => { + const a = state0.a; + state0.a = 0; + try { + return __wbg_adapter_57(a, state0.b, arg0, arg1); + } finally { + state0.a = a; + } + }; + const ret = new Promise(cb0); + return addHeapObject(ret); + } finally { + state0.a = state0.b = 0; + } +}; + +module.exports.__wbindgen_is_falsy = function(arg0) { + const ret = !getObject(arg0); + return ret; +}; + +module.exports.__wbg_getwithrefkey_edc2c8960f0f1191 = function(arg0, arg1) { + const ret = getObject(arg0)[getObject(arg1)]; + return addHeapObject(ret); +}; + +module.exports.__wbg_length_cd7af8117672b8b8 = function(arg0) { + const ret = getObject(arg0).length; + return ret; +}; + +module.exports.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) { + const ret = getObject(arg0)[arg1 >>> 0]; + return addHeapObject(ret); +}; + +module.exports.__wbindgen_string_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof(obj) === 'string' ? obj : undefined; + var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1); + var len1 = WASM_VECTOR_LEN; + getDataView().setInt32(arg0 + 4 * 1, len1, true); + getDataView().setInt32(arg0 + 4 * 0, ptr1, true); +}; + +module.exports.__wbg_new_72fb9a18b5ae2624 = function() { + const ret = new Object(); + return addHeapObject(ret); +}; + +module.exports.__wbg_set_f975102236d3c502 = function(arg0, arg1, arg2) { + getObject(arg0)[takeObject(arg1)] = takeObject(arg2); +}; + +module.exports.__wbindgen_is_string = function(arg0) { + const ret = typeof(getObject(arg0)) === 'string'; + return ret; +}; + +module.exports.__wbindgen_is_object = function(arg0) { + const val = getObject(arg0); + const ret = typeof(val) === 'object' && val !== null; + return ret; +}; + +module.exports.__wbindgen_is_undefined = function(arg0) { + const ret = getObject(arg0) === undefined; + return ret; +}; + +module.exports.__wbindgen_in = function(arg0, arg1) { + const ret = getObject(arg0) in getObject(arg1); + return ret; +}; + +module.exports.__wbindgen_boolean_get = function(arg0) { + const v = getObject(arg0); + const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2; + return ret; +}; + +module.exports.__wbindgen_object_drop_ref = function(arg0) { + takeObject(arg0); +}; + +module.exports.__wbg_self_ce0dbfc45cf2f5be = function() { return handleError(function () { + const ret = self.self; + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_window_c6fb939a7f436783 = function() { return handleError(function () { + const ret = window.window; + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_globalThis_d1e6af4856ba331b = function() { return handleError(function () { + const ret = globalThis.globalThis; + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_global_207b558942527489 = function() { return handleError(function () { + const ret = global.global; + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_newnoargs_e258087cd0daa0ea = function(arg0, arg1) { + var v0 = getCachedStringFromWasm0(arg0, arg1); + const ret = new Function(v0); + return addHeapObject(ret); +}; + +module.exports.__wbg_call_27c0f87801dedf93 = function() { return handleError(function (arg0, arg1) { + const ret = getObject(arg0).call(getObject(arg1)); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_call_b3ca7c6051f9bec1 = function() { return handleError(function (arg0, arg1, arg2) { + const ret = getObject(arg0).call(getObject(arg1), getObject(arg2)); + return addHeapObject(ret); +}, arguments) }; + +module.exports.__wbg_length_c20a40f15020d68a = function(arg0) { + const ret = getObject(arg0).length; + return ret; +}; + +module.exports.__wbindgen_memory = function() { + const ret = wasm.memory; + return addHeapObject(ret); +}; + +module.exports.__wbg_buffer_12d079cc21e14bdb = function(arg0) { + const ret = getObject(arg0).buffer; + return addHeapObject(ret); +}; + +module.exports.__wbg_new_63b92bc8671ed464 = function(arg0) { + const ret = new Uint8Array(getObject(arg0)); + return addHeapObject(ret); +}; + +module.exports.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) { + getObject(arg0).set(getObject(arg1), arg2 >>> 0); +}; + +module.exports.__wbindgen_error_new = function(arg0, arg1) { + const ret = new Error(getStringFromWasm0(arg0, arg1)); + return addHeapObject(ret); +}; + +module.exports.__wbindgen_jsval_loose_eq = function(arg0, arg1) { + const ret = getObject(arg0) == getObject(arg1); + return ret; +}; + +module.exports.__wbindgen_number_get = function(arg0, arg1) { + const obj = getObject(arg1); + const ret = typeof(obj) === 'number' ? obj : undefined; + getDataView().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true); + getDataView().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true); +}; + +module.exports.__wbg_instanceof_Uint8Array_2b3bbecd033d19f6 = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof Uint8Array; + } catch (_) { + result = false; + } + const ret = result; + return ret; +}; + +module.exports.__wbg_instanceof_ArrayBuffer_836825be07d4c9d2 = function(arg0) { + let result; + try { + result = getObject(arg0) instanceof ArrayBuffer; + } catch (_) { + result = false; + } + const ret = result; + return ret; +}; + +module.exports.__wbg_entries_95cc2c823b285a09 = function(arg0) { + const ret = Object.entries(getObject(arg0)); + return addHeapObject(ret); +}; + +module.exports.__wbindgen_object_clone_ref = function(arg0) { + const ret = getObject(arg0); + return addHeapObject(ret); +}; + +module.exports.__wbindgen_debug_string = function(arg0, arg1) { + const ret = debugString(getObject(arg1)); + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1); + const len1 = WASM_VECTOR_LEN; + getDataView().setInt32(arg0 + 4 * 1, len1, true); + getDataView().setInt32(arg0 + 4 * 0, ptr1, true); +}; + +module.exports.__wbindgen_throw = function(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); +}; + +module.exports.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) { + const ret = getObject(arg0).queueMicrotask; + return addHeapObject(ret); +}; + +module.exports.__wbindgen_is_function = function(arg0) { + const ret = typeof(getObject(arg0)) === 'function'; + return ret; +}; + +module.exports.__wbg_resolve_b0083a7967828ec8 = function(arg0) { + const ret = Promise.resolve(getObject(arg0)); + return addHeapObject(ret); +}; + +module.exports.__wbindgen_cb_drop = function(arg0) { + const obj = takeObject(arg0).original; + if (obj.cnt-- == 1) { + obj.a = 0; + return true; + } + const ret = false; + return ret; +}; + +module.exports.__wbg_then_0c86a60e8fcfe9f6 = function(arg0, arg1) { + const ret = getObject(arg0).then(getObject(arg1)); + return addHeapObject(ret); +}; + +module.exports.__wbg_queueMicrotask_481971b0d87f3dd4 = function(arg0) { + queueMicrotask(getObject(arg0)); +}; + +module.exports.__wbindgen_closure_wrapper5954 = function(arg0, arg1, arg2) { + const ret = makeMutClosure(arg0, arg1, 524, __wbg_adapter_38); + return addHeapObject(ret); +}; + + + +const { Buffer } = __webpack_require__(254); +const bytes = Buffer.from('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', 'base64'); + +const wasmModule = new WebAssembly.Module(bytes); +const wasmInstance = new WebAssembly.Instance(wasmModule, imports); +wasm = wasmInstance.exports; +module.exports.__wasm = wasm; + + + +}), +"254": (function (module) { +"use strict"; +module.exports = require("node:buffer"); + +}), +"837": (function (module) { +"use strict"; +module.exports = require("util"); + +}), + +}); +/************************************************************************/ +// The module cache +var __webpack_module_cache__ = {}; + +// The require function +function __webpack_require__(moduleId) { + +// Check if module is in cache +var cachedModule = __webpack_module_cache__[moduleId]; +if (cachedModule !== undefined) { +return cachedModule.exports; +} +// Create a new module (and put it into the cache) +var module = (__webpack_module_cache__[moduleId] = { +exports: {} +}); +// Execute the module function +__webpack_modules__[moduleId](module, module.exports, __webpack_require__); + +// Return the exports of the module +return module.exports; + +} + +/************************************************************************/ +// webpack/runtime/compat_get_default_export +(() => { +// getDefaultExport function for compatibility with non-harmony modules +__webpack_require__.n = function (module) { + var getter = module && module.__esModule ? + function () { return module['default']; } : + function () { return module; }; + __webpack_require__.d(getter, { a: getter }); + return getter; +}; + + + + +})(); +// webpack/runtime/define_property_getters +(() => { +__webpack_require__.d = function(exports, definition) { + for(var key in definition) { + if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { + Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); + } + } +}; +})(); +// webpack/runtime/has_own_property +(() => { +__webpack_require__.o = function (obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); +}; + +})(); +// webpack/runtime/make_namespace_object +(() => { +// define __esModule on exports +__webpack_require__.r = function(exports) { + if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { + Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); + } + Object.defineProperty(exports, '__esModule', { value: true }); +}; + +})(); +/************************************************************************/ +var __webpack_exports__ = {}; +// This entry need to be wrapped in an IIFE because it need to be in strict mode. +(() => { +"use strict"; +__webpack_require__.r(__webpack_exports__); +__webpack_require__.d(__webpack_exports__, { + transformSync: function() { return transformSync; } +}); +/* harmony import */var _lib_wasm_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(230); +/* harmony import */var _lib_wasm_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_lib_wasm_js__WEBPACK_IMPORTED_MODULE_0__); + +const DEFAULT_OPTIONS = { + mode: "strip-only" +}; +function transformSync(source, options) { + return _lib_wasm_js__WEBPACK_IMPORTED_MODULE_0___default().transformSync(source, { + ...DEFAULT_OPTIONS, + ...options + }); +} + +})(); + +module.exports = __webpack_exports__; +})() +; \ No newline at end of file diff --git a/deps/amaro/package.json b/deps/amaro/package.json new file mode 100644 index 00000000000000..fb5553406ee901 --- /dev/null +++ b/deps/amaro/package.json @@ -0,0 +1,38 @@ +{ + "name": "amaro", + "version": "0.0.6", + "description": "Node.js TypeScript wrapper", + "license": "MIT", + "type": "commonjs", + "main": "dist/index.js", + "homepage": "https://github.com/nodejs/amaro#readme", + "bugs": { + "url": "https://github.com/nodejs/amaro/issues" + }, + "repository": { + "type": "git", + "url": "https://github.com/nodejs/amaro.git" + }, + "scripts": { + "clean": "rimraf dist", + "lint": "biome lint --write", + "format": "biome format --write", + "ci": "biome ci", + "ci:fix": "biome check --write", + "prepack": "npm run build", + "postpack": "npm run clean", + "build": "rspack build", + "typecheck": "tsc --noEmit", + "test": "node --test --experimental-test-snapshots **/*.test.js", + "test:regenerate": "node --test --experimental-test-snapshots --test-update-snapshots **/*.test.js" + }, + "devDependencies": { + "@biomejs/biome": "1.8.3", + "@rspack/cli": "^0.7.5", + "@rspack/core": "^0.7.5", + "@types/node": "^20.14.11", + "rimraf": "^6.0.1", + "typescript": "^5.5.3" + }, + "files": ["dist", "LICENSE.md"] +} diff --git a/deps/cares/CMakeLists.txt b/deps/cares/CMakeLists.txt index 9930566a70b106..2505967d352fc5 100644 --- a/deps/cares/CMakeLists.txt +++ b/deps/cares/CMakeLists.txt @@ -12,7 +12,7 @@ INCLUDE (CheckCSourceCompiles) INCLUDE (CheckStructHasMember) INCLUDE (CheckLibraryExists) -PROJECT (c-ares LANGUAGES C VERSION "1.32.1" ) +PROJECT (c-ares LANGUAGES C VERSION "1.32.3" ) # Set this version before release SET (CARES_VERSION "${PROJECT_VERSION}") @@ -30,7 +30,7 @@ INCLUDE (GNUInstallDirs) # include this *AFTER* PROJECT(), otherwise paths are w # For example, a version of 4:0:2 would generate output such as: # libname.so -> libname.so.2 # libname.so.2 -> libname.so.2.2.0 -SET (CARES_LIB_VERSIONINFO "19:1:17") +SET (CARES_LIB_VERSIONINFO "19:3:17") OPTION (CARES_STATIC "Build as a static library" OFF) diff --git a/deps/cares/RELEASE-NOTES.md b/deps/cares/RELEASE-NOTES.md index e016cc5097cf66..69e6a475799e7f 100644 --- a/deps/cares/RELEASE-NOTES.md +++ b/deps/cares/RELEASE-NOTES.md @@ -1,3 +1,53 @@ +## c-ares version 1.32.3 - July 24 2024 + +This is a bugfix release. + +Changes: +* Prevent complex recursion during query requeuing and connection cleanup for + stability. [e8b32b8](https://github.com/c-ares/c-ares/commit/e8b32b8) +* Better propagate error codes on requeue situations. + [a9bc0a2](https://github.com/c-ares/c-ares/commit/a9bc0a2) +* Try to prevent SIGPIPE from being generated and delivered to integrations. + [de01baa](https://github.com/c-ares/c-ares/commit/de01baa) + +Bugfixes: +* Missing manpage for `ares_dns_record_set_id()` + [aa462b3](https://github.com/c-ares/c-ares/commit/aa462b3) +* Memory leak in `ares__hosts_entry_to_hostent()` due to allocation strategy. + [PR #824](https://github.com/c-ares/c-ares/pull/824) +* UDP write failure detected via ICMP unreachable should trigger faster + failover. [PR #821](https://github.com/c-ares/c-ares/pull/821) +* Fix pycares test case regression due to wrong error code being returned. + Regression from 1.31.0. [PR #820](https://github.com/c-ares/c-ares/pull/820) +* Fix possible Windows crash during `ares_destroy()` when using event threads. + [5609bd4](https://github.com/c-ares/c-ares/commit/5609bd4) +* `ARES_OPT_MAXTIMEOUTMS` wasn't being honored in all cases. + [a649c60](https://github.com/c-ares/c-ares/commit/a649c60) + +## c-ares version 1.32.2 - July 15 2024 + +This is a bugfix release. + +Bugfixes: + +* Windows: rework EventThread AFD code for better stability. + [PR #811](https://github.com/c-ares/c-ares/pull/811) +* Windows: If an IP address was detected to have changed, it could lead to a + crash due to a bad pointer. Regression introduced in 1.31.0. + [59e3a1f4](https://github.com/c-ares/c-ares/commit/59e3a1f4) +* Windows: use `QueryPerformanceCounters()` instead of `GetTickCount64()` for + better time accuracy (~15ms -> ~1us). +* Windows 32bit config change callback needs to be tagged as `stdcall` otherwise + could result in a crash. + [5c2bab35](https://github.com/c-ares/c-ares/commit/5c2bab35) +* Tests that need accurate timing should not depend on internal symbols as there + are C++ equivalents in `std::chrono`. + [PR #809](https://github.com/c-ares/c-ares/pull/809) +* Kqueue (MacOS, \*BSD): If the open socket count exceeded 8 (unlikely), it + would try to allocate a new buffer that was too small. + [5aad7981](https://github.com/c-ares/c-ares/commit/5aad7981) + + ## c-ares version 1.32.1 - July 7 2024 This is a bugfix release. diff --git a/deps/cares/aminclude_static.am b/deps/cares/aminclude_static.am index 5eeeffd3349cb6..d542444c4e23c8 100644 --- a/deps/cares/aminclude_static.am +++ b/deps/cares/aminclude_static.am @@ -1,6 +1,6 @@ # aminclude_static.am generated automatically by Autoconf -# from AX_AM_MACROS_STATIC on Sun Jul 7 10:45:53 EDT 2024 +# from AX_AM_MACROS_STATIC on Wed Jul 24 05:40:58 EDT 2024 # Code coverage diff --git a/deps/cares/configure b/deps/cares/configure index 34e67aaf6aef87..f5fc16a49bf934 100755 --- a/deps/cares/configure +++ b/deps/cares/configure @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.72 for c-ares 1.32.1. +# Generated by GNU Autoconf 2.72 for c-ares 1.32.3. # # Report bugs to . # @@ -614,8 +614,8 @@ MAKEFLAGS= # Identity of this package. PACKAGE_NAME='c-ares' PACKAGE_TARNAME='c-ares' -PACKAGE_VERSION='1.32.1' -PACKAGE_STRING='c-ares 1.32.1' +PACKAGE_VERSION='1.32.3' +PACKAGE_STRING='c-ares 1.32.3' PACKAGE_BUGREPORT='c-ares mailing list: http://lists.haxx.se/listinfo/c-ares' PACKAGE_URL='' @@ -1415,7 +1415,7 @@ if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -'configure' configures c-ares 1.32.1 to adapt to many kinds of systems. +'configure' configures c-ares 1.32.3 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1486,7 +1486,7 @@ fi if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of c-ares 1.32.1:";; + short | recursive ) echo "Configuration of c-ares 1.32.3:";; esac cat <<\_ACEOF @@ -1623,7 +1623,7 @@ fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -c-ares configure 1.32.1 +c-ares configure 1.32.3 generated by GNU Autoconf 2.72 Copyright (C) 2023 Free Software Foundation, Inc. @@ -2267,7 +2267,7 @@ cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by c-ares $as_me 1.32.1, which was +It was created by c-ares $as_me 1.32.3, which was generated by GNU Autoconf 2.72. Invocation command line was $ $0$ac_configure_args_raw @@ -3259,7 +3259,7 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu -CARES_VERSION_INFO="19:1:17" +CARES_VERSION_INFO="19:3:17" @@ -5999,7 +5999,7 @@ fi # Define the identity of the package. PACKAGE='c-ares' - VERSION='1.32.1' + VERSION='1.32.3' printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h @@ -26339,7 +26339,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by c-ares $as_me 1.32.1, which was +This file was extended by c-ares $as_me 1.32.3, which was generated by GNU Autoconf 2.72. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -26407,7 +26407,7 @@ ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ -c-ares config.status 1.32.1 +c-ares config.status 1.32.3 configured by $0, generated by GNU Autoconf 2.72, with options \\"\$ac_cs_config\\" diff --git a/deps/cares/configure.ac b/deps/cares/configure.ac index d7a2cc43008bbc..7abf80f68bd716 100644 --- a/deps/cares/configure.ac +++ b/deps/cares/configure.ac @@ -2,10 +2,10 @@ dnl Copyright (C) The c-ares project and its contributors dnl SPDX-License-Identifier: MIT AC_PREREQ([2.69]) -AC_INIT([c-ares], [1.32.1], +AC_INIT([c-ares], [1.32.3], [c-ares mailing list: http://lists.haxx.se/listinfo/c-ares]) -CARES_VERSION_INFO="19:1:17" +CARES_VERSION_INFO="19:3:17" dnl This flag accepts an argument of the form current[:revision[:age]]. So, dnl passing -version-info 3:12:1 sets current to 3, revision to 12, and age to dnl 1. diff --git a/deps/cares/docs/Makefile.in b/deps/cares/docs/Makefile.in index 6abb0e7f6bd62f..0b44dbd8c53ba0 100644 --- a/deps/cares/docs/Makefile.in +++ b/deps/cares/docs/Makefile.in @@ -374,6 +374,7 @@ MANPAGES = ares_cancel.3 \ ares_dns_record_rr_del.3 \ ares_dns_record_rr_get.3 \ ares_dns_record_rr_get_const.3 \ + ares_dns_record_set_id.3 \ ares_dns_rec_type_fromstr.3 \ ares_dns_rec_type_tostr.3 \ ares_dns_rec_type_t.3 \ diff --git a/deps/cares/docs/Makefile.inc b/deps/cares/docs/Makefile.inc index 83d85ebf1d426e..46e30346cfb86a 100644 --- a/deps/cares/docs/Makefile.inc +++ b/deps/cares/docs/Makefile.inc @@ -36,6 +36,7 @@ MANPAGES = ares_cancel.3 \ ares_dns_record_rr_del.3 \ ares_dns_record_rr_get.3 \ ares_dns_record_rr_get_const.3 \ + ares_dns_record_set_id.3 \ ares_dns_rec_type_fromstr.3 \ ares_dns_rec_type_tostr.3 \ ares_dns_rec_type_t.3 \ diff --git a/deps/cares/docs/ares_dns_record.3 b/deps/cares/docs/ares_dns_record.3 index 11c59a64864ba9..47ca95b057a246 100644 --- a/deps/cares/docs/ares_dns_record.3 +++ b/deps/cares/docs/ares_dns_record.3 @@ -32,6 +32,9 @@ ares_dns_record_t *ares_dns_record_duplicate(const ares_dns_record_t *dnsrec); unsigned short ares_dns_record_get_id(const ares_dns_record_t *dnsrec); +ares_bool_t ares_dns_record_set_id(ares_dns_record_t *dnsrec, + unsigned short id); + unsigned short ares_dns_record_get_flags(const ares_dns_record_t *dnsrec); ares_dns_opcode_t ares_dns_record_get_opcode(const ares_dns_record_t *dnsrec); @@ -343,6 +346,14 @@ message id from the DNS record provided in the .IR dnsrec parameter. +The \fIares_dns_record_set_id(3)\fP function is used to set the DNS +message id in the +.IR id +parameter from the DNS record provided in the +.IR dnsrec +parameter. This id will be overwritten when passing the record to c-ares, +so mostly exists for external purposes. + The \fIares_dns_record_get_flags(3)\fP function is used to retrieve the DNS message flags from the DNS record provided in the .IR dnsrec @@ -428,12 +439,12 @@ is returned on out of memory, .B ARES_EFORMERR is returned on misuse. -\fIares_dns_record_get_id(3)\fP, \fIares_dns_record_get_flags(3)\fP, -\fIares_dns_record_get_opcode(3)\fP, \fIares_dns_record_get_rcode(3)\fP, and -\fIares_dns_record_query_cnt(3)\fP all returned their prescribed datatype -values and in general can't fail except for misuse cases, in which a 0 may -be returned, however 0 can also be a valid return value for most of these -functions. +\fIares_dns_record_get_id(3)\fP, \fIares_dns_record_set_id(3)\fP, +\fIares_dns_record_get_flags(3)\fP, \fIares_dns_record_get_opcode(3)\fP, +\fIares_dns_record_get_rcode(3)\fP, and \fIares_dns_record_query_cnt(3)\fP +all returned their prescribed datatype values and in general can't fail except +for misuse cases, in which a 0 may be returned, however 0 can also be a valid +return value for most of these functions. .SH AVAILABILITY diff --git a/deps/cares/docs/ares_dns_record_set_id.3 b/deps/cares/docs/ares_dns_record_set_id.3 new file mode 100644 index 00000000000000..4acc581d29789c --- /dev/null +++ b/deps/cares/docs/ares_dns_record_set_id.3 @@ -0,0 +1,3 @@ +.\" Copyright (C) 2023 The c-ares project and its contributors. +.\" SPDX-License-Identifier: MIT +.so man3/ares_dns_record.3 diff --git a/deps/cares/include/ares_version.h b/deps/cares/include/ares_version.h index 07cd989a386ae7..62541c31ba9f23 100644 --- a/deps/cares/include/ares_version.h +++ b/deps/cares/include/ares_version.h @@ -32,11 +32,11 @@ #define ARES_VERSION_MAJOR 1 #define ARES_VERSION_MINOR 32 -#define ARES_VERSION_PATCH 1 +#define ARES_VERSION_PATCH 3 #define ARES_VERSION \ ((ARES_VERSION_MAJOR << 16) | (ARES_VERSION_MINOR << 8) | \ (ARES_VERSION_PATCH)) -#define ARES_VERSION_STR "1.32.1" +#define ARES_VERSION_STR "1.32.3" #define CARES_HAVE_ARES_LIBRARY_INIT 1 #define CARES_HAVE_ARES_LIBRARY_CLEANUP 1 diff --git a/deps/cares/src/lib/Makefile.in b/deps/cares/src/lib/Makefile.in index 55853a8ebd1ac5..d1758eb8adb791 100644 --- a/deps/cares/src/lib/Makefile.in +++ b/deps/cares/src/lib/Makefile.in @@ -15,7 +15,7 @@ @SET_MAKE@ # aminclude_static.am generated automatically by Autoconf -# from AX_AM_MACROS_STATIC on Sun Jul 7 10:45:53 EDT 2024 +# from AX_AM_MACROS_STATIC on Wed Jul 24 05:40:58 EDT 2024 # Copyright (C) The c-ares project and its contributors # SPDX-License-Identifier: MIT diff --git a/deps/cares/src/lib/ares__close_sockets.c b/deps/cares/src/lib/ares__close_sockets.c index 8d7334b4c4dc11..33a030c9d23d48 100644 --- a/deps/cares/src/lib/ares__close_sockets.c +++ b/deps/cares/src/lib/ares__close_sockets.c @@ -28,7 +28,8 @@ #include "ares_private.h" #include -static void ares__requeue_queries(struct server_connection *conn) +static void ares__requeue_queries(struct server_connection *conn, + ares_status_t requeue_status) { struct query *query; ares_timeval_t now; @@ -36,11 +37,12 @@ static void ares__requeue_queries(struct server_connection *conn) ares__tvnow(&now); while ((query = ares__llist_first_val(conn->queries_to_conn)) != NULL) { - ares__requeue_query(query, &now); + ares__requeue_query(query, &now, requeue_status); } } -void ares__close_connection(struct server_connection *conn) +void ares__close_connection(struct server_connection *conn, + ares_status_t requeue_status) { struct server_state *server = conn->server; ares_channel_t *channel = server->channel; @@ -58,7 +60,7 @@ void ares__close_connection(struct server_connection *conn) } /* Requeue queries to other connections */ - ares__requeue_queries(conn); + ares__requeue_queries(conn, requeue_status); ares__llist_destroy(conn->queries_to_conn); @@ -74,45 +76,63 @@ void ares__close_sockets(struct server_state *server) while ((node = ares__llist_node_first(server->connections)) != NULL) { struct server_connection *conn = ares__llist_node_val(node); - ares__close_connection(conn); + ares__close_connection(conn, ARES_SUCCESS); } } -void ares__check_cleanup_conn(const ares_channel_t *channel, - struct server_connection *conn) +void ares__check_cleanup_conns(const ares_channel_t *channel) { - ares_bool_t do_cleanup = ARES_FALSE; + ares__slist_node_t *snode; - if (channel == NULL || conn == NULL) { + if (channel == NULL) { return; /* LCOV_EXCL_LINE: DefensiveCoding */ } - if (ares__llist_len(conn->queries_to_conn)) { - return; + /* Iterate across each server */ + for (snode = ares__slist_node_first(channel->servers); snode != NULL; + snode = ares__slist_node_next(snode)) { + + struct server_state *server = ares__slist_node_val(snode); + ares__llist_node_t *cnode; + + /* Iterate across each connection */ + cnode = ares__llist_node_first(server->connections); + while (cnode != NULL) { + ares__llist_node_t *next = ares__llist_node_next(cnode); + struct server_connection *conn = ares__llist_node_val(cnode); + ares_bool_t do_cleanup = ARES_FALSE; + cnode = next; + + /* Has connections, not eligible */ + if (ares__llist_len(conn->queries_to_conn)) { + continue; + } + + /* If we are configured not to stay open, close it out */ + if (!(channel->flags & ARES_FLAG_STAYOPEN)) { + do_cleanup = ARES_TRUE; + } + + /* If the associated server has failures, close it out. Resetting the + * connection (and specifically the source port number) can help resolve + * situations where packets are being dropped. + */ + if (conn->server->consec_failures > 0) { + do_cleanup = ARES_TRUE; + } + + /* If the udp connection hit its max queries, always close it */ + if (!conn->is_tcp && channel->udp_max_queries > 0 && + conn->total_queries >= channel->udp_max_queries) { + do_cleanup = ARES_TRUE; + } + + if (!do_cleanup) { + continue; + } + + /* Clean it up */ + ares__close_connection(conn, ARES_SUCCESS); + } } - - /* If we are configured not to stay open, close it out */ - if (!(channel->flags & ARES_FLAG_STAYOPEN)) { - do_cleanup = ARES_TRUE; - } - - /* If the associated server has failures, close it out. Resetting the - * connection (and specifically the source port number) can help resolve - * situations where packets are being dropped. - */ - if (conn->server->consec_failures > 0) { - do_cleanup = ARES_TRUE; - } - - /* If the udp connection hit its max queries, always close it */ - if (!conn->is_tcp && channel->udp_max_queries > 0 && - conn->total_queries >= channel->udp_max_queries) { - do_cleanup = ARES_TRUE; - } - - if (!do_cleanup) { - return; - } - - ares__close_connection(conn); } diff --git a/deps/cares/src/lib/ares__hosts_file.c b/deps/cares/src/lib/ares__hosts_file.c index 271386e7b2524d..ae9c071d7aa90b 100644 --- a/deps/cares/src/lib/ares__hosts_file.c +++ b/deps/cares/src/lib/ares__hosts_file.c @@ -767,126 +767,6 @@ ares_status_t ares__hosts_search_host(ares_channel_t *channel, return ARES_SUCCESS; } -ares_status_t ares__hosts_entry_to_hostent(const ares_hosts_entry_t *entry, - int family, struct hostent **hostent) -{ - ares_status_t status; - size_t naliases; - ares__llist_node_t *node; - size_t idx; - - *hostent = ares_malloc_zero(sizeof(**hostent)); - if (*hostent == NULL) { - status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */ - goto fail; /* LCOV_EXCL_LINE: OutOfMemory */ - } - - (*hostent)->h_addrtype = (HOSTENT_ADDRTYPE_TYPE)family; - - /* Copy IP addresses that match the address family */ - idx = 0; - for (node = ares__llist_node_first(entry->ips); node != NULL; - node = ares__llist_node_next(node)) { - struct ares_addr addr; - const void *ptr = NULL; - size_t ptr_len = 0; - const char *ipaddr = ares__llist_node_val(node); - char **temp = NULL; - - memset(&addr, 0, sizeof(addr)); - - addr.family = family; - ptr = ares_dns_pton(ipaddr, &addr, &ptr_len); - if (ptr == NULL) { - continue; - } - - /* If family == AF_UNSPEC, then we want to inherit this for future - * conversions as we can only support a single address class */ - if (family == AF_UNSPEC) { - family = addr.family; - (*hostent)->h_addrtype = (HOSTENT_ADDRTYPE_TYPE)addr.family; - } - - temp = ares_realloc_zero((*hostent)->h_addr_list, - (idx + 1) * sizeof(*(*hostent)->h_addr_list), - (idx + 2) * sizeof(*(*hostent)->h_addr_list)); - if (temp == NULL) { - status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */ - goto fail; /* LCOV_EXCL_LINE: OutOfMemory */ - } - - (*hostent)->h_addr_list = temp; - - (*hostent)->h_addr_list[idx] = ares_malloc(ptr_len); - if ((*hostent)->h_addr_list[idx] == NULL) { - status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */ - goto fail; /* LCOV_EXCL_LINE: OutOfMemory */ - } - - memcpy((*hostent)->h_addr_list[idx], ptr, ptr_len); - idx++; - (*hostent)->h_length = (HOSTENT_LENGTH_TYPE)ptr_len; - } - - /* entry didn't match address class */ - if (idx == 0) { - status = ARES_ENOTFOUND; - goto fail; - } - - /* Copy main hostname */ - (*hostent)->h_name = ares_strdup(ares__llist_first_val(entry->hosts)); - if ((*hostent)->h_name == NULL) { - status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */ - goto fail; /* LCOV_EXCL_LINE: OutOfMemory */ - } - - /* Copy aliases */ - naliases = ares__llist_len(entry->hosts) - 1; - - /* Cap at 100, some people use https://github.com/StevenBlack/hosts and we - * don't need 200k+ aliases */ - if (naliases > 100) { - naliases = 100; /* LCOV_EXCL_LINE: DefensiveCoding */ - } - - (*hostent)->h_aliases = - ares_malloc_zero((naliases + 1) * sizeof(*(*hostent)->h_aliases)); - if ((*hostent)->h_aliases == NULL) { - status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */ - goto fail; /* LCOV_EXCL_LINE: OutOfMemory */ - } - - /* Copy all entries to the alias except the first */ - idx = 0; - node = ares__llist_node_first(entry->hosts); - node = ares__llist_node_next(node); - while (node != NULL) { - (*hostent)->h_aliases[idx] = ares_strdup(ares__llist_node_val(node)); - if ((*hostent)->h_aliases[idx] == NULL) { - status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */ - goto fail; /* LCOV_EXCL_LINE: OutOfMemory */ - } - idx++; - - /* Break out if artificially capped */ - if (idx == naliases) { - break; - } - node = ares__llist_node_next(node); - } - - return ARES_SUCCESS; - -/* LCOV_EXCL_START: defensive coding */ -fail: - ares_free_hostent(*hostent); - *hostent = NULL; - return status; - /* LCOV_EXCL_STOP */ -} - static ares_status_t ares__hosts_ai_append_cnames(const ares_hosts_entry_t *entry, struct ares_addrinfo_cname **cnames_out) @@ -980,10 +860,12 @@ ares_status_t ares__hosts_entry_to_addrinfo(const ares_hosts_entry_t *entry, return ARES_EBADFAMILY; /* LCOV_EXCL_LINE: DefensiveCoding */ } - ai->name = ares_strdup(name); - if (ai->name == NULL) { - status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */ - goto done; /* LCOV_EXCL_LINE: OutOfMemory */ + if (name != NULL) { + ai->name = ares_strdup(name); + if (ai->name == NULL) { + status = ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */ + goto done; /* LCOV_EXCL_LINE: OutOfMemory */ + } } for (node = ares__llist_node_first(entry->ips); node != NULL; @@ -1031,3 +913,35 @@ ares_status_t ares__hosts_entry_to_addrinfo(const ares_hosts_entry_t *entry, return status; } + +ares_status_t ares__hosts_entry_to_hostent(const ares_hosts_entry_t *entry, + int family, struct hostent **hostent) +{ + ares_status_t status; + struct ares_addrinfo *ai = ares_malloc_zero(sizeof(*ai)); + + *hostent = NULL; + + if (ai == NULL) { + return ARES_ENOMEM; + } + + status = ares__hosts_entry_to_addrinfo(entry, NULL, family, 0, ARES_TRUE, ai); + if (status != ARES_SUCCESS) { + goto done; + } + + status = ares__addrinfo2hostent(ai, family, hostent); + if (status != ARES_SUCCESS) { + goto done; + } + +done: + ares_freeaddrinfo(ai); + if (status != ARES_SUCCESS) { + ares_free_hostent(*hostent); + *hostent = NULL; + } + + return status; +} diff --git a/deps/cares/src/lib/ares__socket.c b/deps/cares/src/lib/ares__socket.c index 7796ab2cbef9d4..3db19f7e8232f4 100644 --- a/deps/cares/src/lib/ares__socket.c +++ b/deps/cares/src/lib/ares__socket.c @@ -184,6 +184,14 @@ static int configure_socket(ares_socket_t s, struct server_state *server) } #endif + /* No need to emit SIGPIPE on socket errors */ +#if defined(SO_NOSIGPIPE) + { + int opt = 1; + setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, (void *)&opt, sizeof(opt)); + } +#endif + /* Set the socket's send and receive buffer sizes. */ if ((channel->socket_send_buffer_size > 0) && setsockopt(s, SOL_SOCKET, SO_SNDBUF, diff --git a/deps/cares/src/lib/ares__timeval.c b/deps/cares/src/lib/ares__timeval.c index 9c175a82a061fa..66d07441c80a31 100644 --- a/deps/cares/src/lib/ares__timeval.c +++ b/deps/cares/src/lib/ares__timeval.c @@ -30,11 +30,24 @@ void ares__tvnow(ares_timeval_t *now) { - /* GetTickCount64() is available on Windows Vista and higher */ - ULONGLONG milliseconds = GetTickCount64(); + /* QueryPerformanceCounters() has been around since Windows 2000, though + * significant fixes were made in later versions. Documentation states + * 1 microsecond or better resolution with a rollover not less than 100 years. + * This differs from GetTickCount{64}() which has a resolution between 10 and + * 16 ms. */ + LARGE_INTEGER freq; + LARGE_INTEGER current; - now->sec = (ares_int64_t)milliseconds / 1000; - now->usec = (unsigned int)(milliseconds % 1000) * 1000; + /* Not sure how long it takes to get the frequency, I see it recommended to + * cache it */ + QueryPerformanceFrequency(&freq); + QueryPerformanceCounter(¤t); + + now->sec = current.QuadPart / freq.QuadPart; + /* We want to prevent overflows so we get the remainder, then multiply to + * microseconds before dividing */ + now->usec = (unsigned int)(((current.QuadPart % freq.QuadPart) * 1000000) / + freq.QuadPart); } #elif defined(HAVE_CLOCK_GETTIME_MONOTONIC) diff --git a/deps/cares/src/lib/ares_cancel.c b/deps/cares/src/lib/ares_cancel.c index c47bdd8a2b7988..4312b5e188e567 100644 --- a/deps/cares/src/lib/ares_cancel.c +++ b/deps/cares/src/lib/ares_cancel.c @@ -60,28 +60,26 @@ void ares_cancel(ares_channel_t *channel) node = ares__llist_node_first(list_copy); while (node != NULL) { struct query *query; - struct server_connection *conn; /* Cache next since this node is being deleted */ next = ares__llist_node_next(node); query = ares__llist_node_claim(node); - conn = query->conn; query->node_all_queries = NULL; /* NOTE: its possible this may enqueue new queries */ query->callback(query->arg, ARES_ECANCELLED, 0, NULL); ares__free_query(query); - /* See if the connection should be cleaned up */ - ares__check_cleanup_conn(channel, conn); - node = next; } ares__llist_destroy(list_copy); } + /* See if the connections should be cleaned up */ + ares__check_cleanup_conns(channel); + ares_queue_notify_empty(channel); done: diff --git a/deps/cares/src/lib/ares_destroy.c b/deps/cares/src/lib/ares_destroy.c index ade986df6fdfc2..1be42b1dec1b0f 100644 --- a/deps/cares/src/lib/ares_destroy.c +++ b/deps/cares/src/lib/ares_destroy.c @@ -38,7 +38,17 @@ void ares_destroy(ares_channel_t *channel) return; } - /* Disable configuration change monitoring */ + /* Mark as being shutdown */ + ares__channel_lock(channel); + channel->sys_up = ARES_FALSE; + ares__channel_unlock(channel); + + /* Disable configuration change monitoring. We can't hold a lock because + * some cleanup routines, such as on Windows, are synchronous operations. + * What we've observed is a system config change event was triggered right + * at shutdown time and it tries to take the channel lock and the destruction + * waits for that event to complete before it continues so we get a channel + * lock deadlock at shutdown if we hold a lock during this process. */ if (channel->optmask & ARES_OPT_EVENT_THREAD) { ares_event_thread_t *e = channel->sock_state_cb_data; if (e && e->configchg) { @@ -47,14 +57,16 @@ void ares_destroy(ares_channel_t *channel) } } - /* Wait for reinit thread to exit if there was one pending */ + /* Wait for reinit thread to exit if there was one pending, can't be + * holding a lock as the thread may take locks. */ if (channel->reinit_thread != NULL) { void *rv; ares__thread_join(channel->reinit_thread, &rv); channel->reinit_thread = NULL; } - /* Lock because callbacks will be triggered */ + /* Lock because callbacks will be triggered, and any system-generated + * callbacks need to hold a channel lock. */ ares__channel_lock(channel); /* Destroy all queries */ diff --git a/deps/cares/src/lib/ares_dns_private.h b/deps/cares/src/lib/ares_dns_private.h index c82fb6a9abe23f..2dd468a5559d06 100644 --- a/deps/cares/src/lib/ares_dns_private.h +++ b/deps/cares/src/lib/ares_dns_private.h @@ -26,6 +26,8 @@ #ifndef __ARES_DNS_PRIVATE_H #define __ARES_DNS_PRIVATE_H +ares_status_t ares_dns_record_duplicate_ex(ares_dns_record_t **dest, + const ares_dns_record_t *src); ares_bool_t ares_dns_rec_type_allow_name_compression(ares_dns_rec_type_t type); ares_bool_t ares_dns_opcode_isvalid(ares_dns_opcode_t opcode); ares_bool_t ares_dns_rcode_isvalid(ares_dns_rcode_t rcode); diff --git a/deps/cares/src/lib/ares_dns_record.c b/deps/cares/src/lib/ares_dns_record.c index 0131743e4621d8..8545abecf74602 100644 --- a/deps/cares/src/lib/ares_dns_record.c +++ b/deps/cares/src/lib/ares_dns_record.c @@ -296,6 +296,7 @@ ares_status_t ares_dns_record_query_set_name(ares_dns_record_t *dnsrec, if (dnsrec == NULL || idx >= dnsrec->qdcount || name == NULL) { return ARES_EFORMERR; } + orig_name = dnsrec->qd[idx].name; dnsrec->qd[idx].name = ares_strdup(name); if (dnsrec->qd[idx].name == NULL) { @@ -1622,26 +1623,34 @@ ares_status_t return status; } -ares_dns_record_t *ares_dns_record_duplicate(const ares_dns_record_t *dnsrec) +ares_status_t ares_dns_record_duplicate_ex(ares_dns_record_t **dest, + const ares_dns_record_t *src) { unsigned char *data = NULL; size_t data_len = 0; - ares_dns_record_t *out = NULL; ares_status_t status; - if (dnsrec == NULL) { - return NULL; + if (dest == NULL || src == NULL) { + return ARES_EFORMERR; } - status = ares_dns_write(dnsrec, &data, &data_len); + *dest = NULL; + + status = ares_dns_write(src, &data, &data_len); if (status != ARES_SUCCESS) { - return NULL; + return status; } - status = ares_dns_parse(data, data_len, 0, &out); + status = ares_dns_parse(data, data_len, 0, dest); ares_free(data); - if (status != ARES_SUCCESS) { - return NULL; - } - return out; + + return status; +} + +ares_dns_record_t *ares_dns_record_duplicate(const ares_dns_record_t *dnsrec) +{ + ares_dns_record_t *dest = NULL; + + ares_dns_record_duplicate_ex(&dest, dnsrec); + return dest; } diff --git a/deps/cares/src/lib/ares_event_configchg.c b/deps/cares/src/lib/ares_event_configchg.c index efdfc0409d6be9..1d5d026ba3995a 100644 --- a/deps/cares/src/lib/ares_event_configchg.c +++ b/deps/cares/src/lib/ares_event_configchg.c @@ -237,9 +237,10 @@ void ares_event_configchg_destroy(ares_event_configchg_t *configchg) # ifndef __WATCOMC__ -static void ares_event_configchg_ip_cb(PVOID CallerContext, - PMIB_IPINTERFACE_ROW Row, - MIB_NOTIFICATION_TYPE NotificationType) +static void NETIOAPI_API_ + ares_event_configchg_ip_cb(PVOID CallerContext, + PMIB_IPINTERFACE_ROW Row, + MIB_NOTIFICATION_TYPE NotificationType) { ares_event_configchg_t *configchg = CallerContext; (void)Row; @@ -303,8 +304,8 @@ ares_status_t ares_event_configchg_init(ares_event_configchg_t **configchg, * that didn't get triggered either. */ if (NotifyIpInterfaceChange( - AF_UNSPEC, (PIPINTERFACE_CHANGE_CALLBACK)ares_event_configchg_ip_cb, - *configchg, FALSE, &c->ifchg_hnd) != NO_ERROR) { + AF_UNSPEC, ares_event_configchg_ip_cb, + c, FALSE, &c->ifchg_hnd) != NO_ERROR) { status = ARES_ESERVFAIL; goto done; } diff --git a/deps/cares/src/lib/ares_event_kqueue.c b/deps/cares/src/lib/ares_event_kqueue.c index 585033e05ae9ac..aedd99ec42d4d4 100644 --- a/deps/cares/src/lib/ares_event_kqueue.c +++ b/deps/cares/src/lib/ares_event_kqueue.c @@ -93,7 +93,7 @@ static ares_bool_t ares_evsys_kqueue_init(ares_event_thread_t *e) kq->nchanges_alloc = 8; kq->changelist = - ares_malloc_zero(sizeof(*kq->changelist) * kq->nchanges_alloc); + ares_malloc_zero(kq->nchanges_alloc * sizeof(*kq->changelist)); if (kq->changelist == NULL) { ares_evsys_kqueue_destroy(e); return ARES_FALSE; @@ -123,8 +123,11 @@ static void ares_evsys_kqueue_enqueue(ares_evsys_kqueue_t *kq, int fd, if (kq->nchanges > kq->nchanges_alloc) { kq->nchanges_alloc <<= 1; - kq->changelist = ares_realloc_zero(kq->changelist, kq->nchanges_alloc >> 1, - kq->nchanges_alloc); + kq->changelist = ares_realloc_zero( + kq->changelist, + (kq->nchanges_alloc >> 1) * sizeof(*kq->changelist), + kq->nchanges_alloc * sizeof(*kq->changelist) + ); } EV_SET(&kq->changelist[idx], fd, filter, flags, 0, 0, 0); diff --git a/deps/cares/src/lib/ares_event_select.c b/deps/cares/src/lib/ares_event_select.c index 980652002c3372..e1266ea99056a3 100644 --- a/deps/cares/src/lib/ares_event_select.c +++ b/deps/cares/src/lib/ares_event_select.c @@ -81,12 +81,14 @@ static size_t ares_evsys_select_wait(ares_event_thread_t *e, size_t i; fd_set read_fds; fd_set write_fds; + fd_set except_fds; int nfds = 0; struct timeval tv; struct timeval *tout = NULL; FD_ZERO(&read_fds); FD_ZERO(&write_fds); + FD_ZERO(&except_fds); for (i = 0; i < num_fds; i++) { const ares_event_t *ev = @@ -97,6 +99,7 @@ static size_t ares_evsys_select_wait(ares_event_thread_t *e, if (ev->flags & ARES_EVENT_FLAG_WRITE) { FD_SET(ev->fd, &write_fds); } + FD_SET(ev->fd, &except_fds); if (ev->fd + 1 > nfds) { nfds = ev->fd + 1; } @@ -108,7 +111,7 @@ static size_t ares_evsys_select_wait(ares_event_thread_t *e, tout = &tv; } - rv = select(nfds, &read_fds, &write_fds, NULL, tout); + rv = select(nfds, &read_fds, &write_fds, &except_fds, tout); if (rv > 0) { for (i = 0; i < num_fds; i++) { ares_event_t *ev; @@ -119,7 +122,7 @@ static size_t ares_evsys_select_wait(ares_event_thread_t *e, continue; /* LCOV_EXCL_LINE: DefensiveCoding */ } - if (FD_ISSET(fdlist[i], &read_fds)) { + if (FD_ISSET(fdlist[i], &read_fds) || FD_ISSET(fdlist[i], &except_fds)) { flags |= ARES_EVENT_FLAG_READ; } diff --git a/deps/cares/src/lib/ares_event_thread.c b/deps/cares/src/lib/ares_event_thread.c index 48aacdedd57589..63d8aa2218afd2 100644 --- a/deps/cares/src/lib/ares_event_thread.c +++ b/deps/cares/src/lib/ares_event_thread.c @@ -262,6 +262,35 @@ static void ares_event_process_updates(ares_event_thread_t *e) } } +static void ares_event_thread_cleanup(ares_event_thread_t *e) +{ + /* Manually free any updates that weren't processed */ + if (e->ev_updates != NULL) { + ares__llist_node_t *node; + + while ((node = ares__llist_node_first(e->ev_updates)) != NULL) { + ares_event_destroy_cb(ares__llist_node_claim(node)); + } + ares__llist_destroy(e->ev_updates); + e->ev_updates = NULL; + } + + if (e->ev_sock_handles != NULL) { + ares__htable_asvp_destroy(e->ev_sock_handles); + e->ev_sock_handles = NULL; + } + + if (e->ev_cust_handles != NULL) { + ares__htable_vpvp_destroy(e->ev_cust_handles); + e->ev_cust_handles = NULL; + } + + if (e->ev_sys != NULL && e->ev_sys->destroy != NULL) { + e->ev_sys->destroy(e); + e->ev_sys = NULL; + } +} + static void *ares_event_thread(void *arg) { ares_event_thread_t *e = arg; @@ -296,14 +325,16 @@ static void *ares_event_thread(void *arg) ares__thread_mutex_lock(e->mutex); } + /* Lets cleanup while we're in the thread itself */ + ares_event_thread_cleanup(e); + ares__thread_mutex_unlock(e->mutex); + return NULL; } static void ares_event_thread_destroy_int(ares_event_thread_t *e) { - ares__llist_node_t *node; - /* Wake thread and tell it to shutdown if it exists */ ares__thread_mutex_lock(e->mutex); if (e->isup) { @@ -314,26 +345,14 @@ static void ares_event_thread_destroy_int(ares_event_thread_t *e) /* Wait for thread to shutdown */ if (e->thread) { - ares__thread_join(e->thread, NULL); + void *rv = NULL; + ares__thread_join(e->thread, &rv); e->thread = NULL; } - /* Manually free any updates that weren't processed */ - while ((node = ares__llist_node_first(e->ev_updates)) != NULL) { - ares_event_destroy_cb(ares__llist_node_claim(node)); - } - ares__llist_destroy(e->ev_updates); - e->ev_updates = NULL; - - ares__htable_asvp_destroy(e->ev_sock_handles); - e->ev_sock_handles = NULL; - - ares__htable_vpvp_destroy(e->ev_cust_handles); - e->ev_cust_handles = NULL; - - if (e->ev_sys && e->ev_sys->destroy) { - e->ev_sys->destroy(e); - } + /* If the event thread ever got to the point of starting, this is a no-op + * as it runs this same cleanup when it shuts down */ + ares_event_thread_cleanup(e); ares__thread_mutex_destroy(e->mutex); e->mutex = NULL; @@ -350,6 +369,8 @@ void ares_event_thread_destroy(ares_channel_t *channel) } ares_event_thread_destroy_int(e); + channel->sock_state_cb_data = NULL; + channel->sock_state_cb = NULL; } static const ares_event_sys_t *ares_event_fetch_sys(ares_evsys_t evsys) diff --git a/deps/cares/src/lib/ares_event_win32.c b/deps/cares/src/lib/ares_event_win32.c index 4e4b9c53c3389f..173d0ca9c9d1a9 100644 --- a/deps/cares/src/lib/ares_event_win32.c +++ b/deps/cares/src/lib/ares_event_win32.c @@ -52,103 +52,111 @@ * which means we can hook in non-socket related events. * * The information for this implementation was gathered from "wepoll" and - * "libuv" which both use slight variants on this, but this implementation - * doesn't directly follow either methodology. + * "libuv" which both use slight variants on this. We originally went with + * an implementation methodology more similar to "libuv", but we had a few + * user reports of crashes during shutdown and memory leaks due to some + * events not being delivered for cleanup of closed sockets. * * Initialization: - * 1. Dynamically load the NtDeviceIoControlFile and NtCancelIoFileEx internal - * symbols from ntdll.dll. These functions are used to submit the AFD POLL - * request and to cancel a prior request, respectively. + * 1. Dynamically load the NtDeviceIoControlFile, NtCreateFile, and + * NtCancelIoFileEx internal symbols from ntdll.dll. (Don't believe + * Microsoft's documentation for NtCancelIoFileEx as it documents an + * invalid prototype). These functions are to open a reference to the + * Ancillary Function Driver (AFD), and to submit and cancel POLL + * requests. * 2. Create an IO Completion Port base handle via CreateIoCompletionPort() * that all socket events will be delivered through. - * 3. Create a callback to be used to be able to interrupt waiting for IOCP + * 3. Create a list of AFD Handles and track the number of poll requests + * per AFD handle. When we exceed a pre-determined limit of poll requests + * for a handle (128), we will automatically create a new handle. The + * reason behind this is NtCancelIoFileEx uses a horrible algorithm for + * issuing cancellations. See: + * https://github.com/python-trio/trio/issues/52#issuecomment-548215128 + * 4. Create a callback to be used to be able to interrupt waiting for IOCP * events, this may be called for allowing enqueuing of additional socket * events or removing socket events. PostQueuedCompletionStatus() is the - * obvious choice. Use the same container structure as used with a Socket - * but tagged indicating it is not as the CompletionKey (important!). + * obvious choice. We can use the same container format, the event + * delivered won't have an OVERLAPPED pointer so we can differentiate from + * socket events. Use the container as the completion key. * * Socket Add: - * 1. Create/Allocate a container for holding metadata about a socket: + * 1. Create/Allocate a container for holding metadata about a socket + * including: * - SOCKET base_socket; - * - SOCKET peer_socket; - * - OVERLAPPED overlapped; -- Used by AFD POLL + * - IO_STATUS_BLOCK iosb; -- Used by AFD POLL, returned as OVERLAPPED * - AFD_POLL_INFO afd_poll_info; -- Used by AFD POLL + * - afd list node -- for tracking which AFD handle a POLL request was + * submitted to. * 2. Call WSAIoctl(..., SIO_BASE_HANDLE, ...) to unwrap the SOCKET and get * the "base socket" we can use for polling. It appears this may fail so * we should call WSAIoctl(..., SIO_BSP_HANDLE_POLL, ...) as a fallback. - * 3. The SOCKET handle we have is most likely not capable of supporting - * OVERLAPPED, and we need to have a way to unbind a socket from IOCP - * (which is done via a simple closesocket()) so we need to duplicate the - * "base socket" using WSADuplicateSocketW() followed by - * WSASocketW(..., WSA_FLAG_OVERLAPPED) to create this "peer socket" for - * submitting AFD POLL requests. - * 4. Bind to IOCP using CreateIoCompletionPort() referencing the "peer - * socket" and the base IOCP handle from "Initialization". Use the - * pointer to the socket container as the "CompletionKey" which will be - * returned when an event occurs. - * 5. Submit AFD POLL request (see "AFD POLL Request" section) + * 3. Submit AFD POLL request (see "AFD POLL Request" section) + * 4. Record a mapping between the "IO Status Block" and the socket container + * so when events are delivered we can dereference. * * Socket Delete: - * 1. Call "AFD Poll Cancel" (see Section of same name) - * 2. If a cancel was requested (not bypassed due to no events, etc), tag the - * "container" for the socket as pending delete, and when the next IOCP - * event for the socket is dequeued, cleanup. - * 3. Otherwise, call closesocket(peer_socket) then free() the container - * which will officially delete it. - * NOTE: Deferring delete may be completely unnecessary. In theory closing - * the peer_socket() should guarantee no additional events will be - * delivered. But maybe if there's a pending event that hasn't been - * read yet but already trigggered it would be an issue, so this is - * "safer" unless we can prove its not necessary. + * 1. Call + * NtCancelIoFileEx(afd, iosb, &temp_iosb); + * to cancel any pending operations. + * 2. Tag the socket container as being queued for deletion + * 3. Wait for an event to be delivered for the socket (cancel isn't + * immediate, it delivers an event to know its complete). Delete only once + * that event has been delivered. If we don't do this we could try to + * access free()'d memory at a later point. * * Socket Modify: - * 1. Call "AFD Poll Cancel" (see Section of same name) - * 2. If a cancel was not enqueued because there is no pending request, - * submit AFD POLL request (see "AFD POLL Request" section), otherwise - * defer until next socket event. + * 1. Call + * NtCancelIoFileEx(afd, iosb, &temp_iosb) + * to cancel any pending operation. + * 2. When the event comes through that the cancel is complete, enqueue + * another "AFD Poll Request" for the desired events. * * Event Wait: * 1. Call GetQueuedCompletionStatusEx() with the base IOCP handle, a * stack allocated array of OVERLAPPED_ENTRY's, and an appropriate * timeout. - * 2. Iterate across returned events, the CompletionKey is a pointer to the - * container registered with CreateIoCompletionPort() or - * PostQueuedCompletionStatus() - * 3. If object indicates it is pending delete, go ahead and - * closesocket(peer_socket) and free() the container. Go to the next event. - * 4. Submit AFD POLL Request (see "AFD POLL Request"). We must re-enable - * the request each time we receive a response, it is not persistent. - * 5. Notify of any events received as indicated in the AFD_POLL_INFO - * Handles[0].Events (NOTE: check NumberOfHandles first, make sure it is - * > 0, otherwise we might not have events such as if our last request - * was cancelled). + * 2. Iterate across returned events, if the lpOverlapped is NULL, then the + * the CompletionKey is a pointer to the container registered via + * PostQueuedCompletionStatus(), otherwise it is the "IO Status Block" + * registered with the "AFD Poll Request" which needs to be dereferenced + * to the "socket container". + * 3. If it is a "socket container", disassociate it from the afd list node + * it was previously submitted to. + * 4. If it is a "socket container" check to see if we are cleaning up, if so, + * clean it up. + * 5. If it is a "socket container" that is still valid, Submit an + * AFD POLL Request (see "AFD POLL Request"). We must re-enable the request + * each time we receive a response, it is not persistent. + * 6. Notify of any events received as indicated in the AFD_POLL_INFO + * Handles[0].Events (NOTE: check NumberOfHandles > 0, and the status in + * the IO_STATUS_BLOCK. If we received an AFD_POLL_LOCAL_CLOSE, clean up + * the connection like the integrator requested it to be cleaned up. * * AFD Poll Request: - * 1. Initialize the AFD_POLL_INFO structure: - * Exclusive = TRUE; // Auto cancel duplicates for same socket + * 1. Find an afd poll handle in the list that has fewer pending requests than + * the limit. + * 2. If an afd poll handle was not associated (e.g. due to all being over + * limit), create a new afd poll handle by calling NtCreateFile() + * with path \Device\Afd , then add the AFD handle to the IO Completion + * Port. We can leave the completion key as blank since events for + * multiple sockets will be delivered through this and we need to + * differentiate via the OVERLAPPED member returned. Add the new AFD + * handle to the list of handles. + * 3. Initialize the AFD_POLL_INFO structure: + * Exclusive = FALSE; // allow multiple requests * NumberOfHandles = 1; * Timeout.QuadPart = LLONG_MAX; * Handles[0].Handle = (HANDLE)base_socket; * Handles[0].Status = 0; - * Handles[0].Events = ... set as appropriate AFD_POLL_RECEIVE, etc; - * 2. Zero out the OVERLAPPED structure - * 3. Create an IO_STATUS_BLOCK pointer (iosb) and set it to the address of - * the OVERLAPPED "Internal" member. - * 4. Set the "Status" member of IO_STATUS_BLOCK to STATUS_PENDING - * 5. Call - * NtDeviceIoControlFile((HANDLE)peer_socket, NULL, NULL, &overlapped, - * iosb, IOCTL_AFD_POLL + * Handles[0].Events = AFD_POLL_LOCAL_CLOSE + additional events to wait for + * such as AFD_POLL_RECEIVE, etc; + * 4. Zero out the IO_STATUS_BLOCK structures + * 5. Set the "Status" member of IO_STATUS_BLOCK to STATUS_PENDING + * 6. Call + * NtDeviceIoControlFile(afd, NULL, NULL, &iosb, + * &iosb, IOCTL_AFD_POLL * &afd_poll_info, sizeof(afd_poll_info), * &afd_poll_info, sizeof(afd_poll_info)); - * NOTE: Its not clear to me if the IO_STATUS_BLOCK pointing to OVERLAPPED - * is for efficiency or if its a requirement for AFD. This is what - * libuv does, so I'm doing it here too. - * - * AFD Poll Cancel: - * 1. Check to see if the IO_STATUS_BLOCK "Status" member for the socket - * is still STATUS_PENDING, if not, no cancel request is necessary. - * 2. Call - * NtCancelIoFileEx((HANDLE)peer_socket, iosb, &temp_iosb); * * * References: @@ -156,38 +164,102 @@ * - https://github.com/libuv/libuv/ */ +/* Cap the number of outstanding AFD poll requests per AFD handle due to known + * slowdowns with large lists and NtCancelIoFileEx() */ +# define AFD_POLL_PER_HANDLE 128 + +# include + +/* # define CARES_DEBUG 1 */ + +# ifdef __GNUC__ +# define CARES_PRINTF_LIKE(fmt, args) \ + __attribute__((format(printf, fmt, args))) +# else +# define CARES_PRINTF_LIKE(fmt, args) +# endif + +static void CARES_DEBUG_LOG(const char *fmt, ...) CARES_PRINTF_LIKE(1, 2); + +static void CARES_DEBUG_LOG(const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); +# ifdef CARES_DEBUG + vfprintf(stderr, fmt, ap); + fflush(stderr); +# endif + va_end(ap); +} + typedef struct { /* Dynamically loaded symbols */ + NtCreateFile_t NtCreateFile; NtDeviceIoControlFile_t NtDeviceIoControlFile; NtCancelIoFileEx_t NtCancelIoFileEx; /* Implementation details */ + ares__slist_t *afd_handles; HANDLE iocp_handle; + + /* IO_STATUS_BLOCK * -> ares_evsys_win32_eventdata_t * mapping. There is + * no completion key passed to IOCP with this method so we have to look + * up based on the lpOverlapped returned (which is mapped to IO_STATUS_BLOCK) + */ + ares__htable_vpvp_t *sockets; + + /* Flag about whether or not we are shutting down */ + ares_bool_t is_shutdown; } ares_evsys_win32_t; +typedef enum { + POLL_STATUS_NONE = 0, + POLL_STATUS_PENDING = 1, + POLL_STATUS_CANCEL = 2, + POLL_STATUS_DESTROY = 3 +} poll_status_t; + typedef struct { /*! Pointer to parent event container */ - ares_event_t *event; + ares_event_t *event; /*! Socket passed in to monitor */ - SOCKET socket; + SOCKET socket; /*! Base socket derived from provided socket */ - SOCKET base_socket; - /*! New socket (duplicate base_socket handle) supporting OVERLAPPED operation - */ - SOCKET peer_socket; + SOCKET base_socket; /*! Structure for submitting AFD POLL requests (Internals!) */ - AFD_POLL_INFO afd_poll_info; - /*! Overlapped structure submitted with AFD POLL requests and returned with - * IOCP results */ - OVERLAPPED overlapped; + AFD_POLL_INFO afd_poll_info; + /*! Status of current polling operation */ + poll_status_t poll_status; + /*! IO Status Block structure submitted with AFD POLL requests and returned + * with IOCP results as lpOverlapped (even though its a different structure) + */ + IO_STATUS_BLOCK iosb; + /*! AFD handle node an outstanding poll request is associated with */ + ares__slist_node_t *afd_handle_node; + /* Lock is only for PostQueuedCompletionStatus() to prevent multiple + * signals. Tracking via POLL_STATUS_PENDING/POLL_STATUS_NONE */ + ares__thread_mutex_t *lock; } ares_evsys_win32_eventdata_t; -static void ares_iocpevent_signal(const ares_event_t *event) +static size_t ares_evsys_win32_wait(ares_event_thread_t *e, + unsigned long timeout_ms); + +static void ares_iocpevent_signal(const ares_event_t *event) { - ares_event_thread_t *e = event->e; - ares_evsys_win32_t *ew = e->ev_sys_data; + ares_event_thread_t *e = event->e; + ares_evsys_win32_t *ew = e->ev_sys_data; + ares_evsys_win32_eventdata_t *ed = event->data; + ares_bool_t queue_event = ARES_FALSE; - if (e == NULL) { + ares__thread_mutex_lock(ed->lock); + if (ed->poll_status != POLL_STATUS_PENDING) { + ed->poll_status = POLL_STATUS_PENDING; + queue_event = ARES_TRUE; + } + ares__thread_mutex_unlock(ed->lock); + + if (!queue_event) { return; } @@ -197,10 +269,13 @@ static void ares_iocpevent_signal(const ares_event_t *event) static void ares_iocpevent_cb(ares_event_thread_t *e, ares_socket_t fd, void *data, ares_event_flags_t flags) { + ares_evsys_win32_eventdata_t *ed = data; (void)e; - (void)data; (void)fd; (void)flags; + ares__thread_mutex_lock(ed->lock); + ed->poll_status = POLL_STATUS_NONE; + ares__thread_mutex_unlock(ed->lock); } static ares_event_t *ares_iocpevent_create(ares_event_thread_t *e) @@ -226,24 +301,142 @@ static void ares_evsys_win32_destroy(ares_event_thread_t *e) return; } + CARES_DEBUG_LOG("** Win32 Event Destroy\n"); + ew = e->ev_sys_data; if (ew == NULL) { return; } + ew->is_shutdown = ARES_TRUE; + CARES_DEBUG_LOG(" ** waiting on %lu remaining sockets to be destroyed\n", + (unsigned long)ares__htable_vpvp_num_keys(ew->sockets)); + while (ares__htable_vpvp_num_keys(ew->sockets)) { + ares_evsys_win32_wait(e, 0); + } + CARES_DEBUG_LOG(" ** all sockets cleaned up\n"); + + if (ew->iocp_handle != NULL) { CloseHandle(ew->iocp_handle); } + ares__slist_destroy(ew->afd_handles); + + ares__htable_vpvp_destroy(ew->sockets); + ares_free(ew); e->ev_sys_data = NULL; } +typedef struct { + size_t poll_cnt; + HANDLE afd_handle; +} ares_afd_handle_t; + +static void ares_afd_handle_destroy(void *arg) +{ + ares_afd_handle_t *hnd = arg; + if (hnd != NULL && hnd->afd_handle != NULL) { + CloseHandle(hnd->afd_handle); + } + ares_free(hnd); +} + +static int ares_afd_handle_cmp(const void *data1, const void *data2) +{ + const ares_afd_handle_t *hnd1 = data1; + const ares_afd_handle_t *hnd2 = data2; + + if (hnd1->poll_cnt > hnd2->poll_cnt) { + return 1; + } + if (hnd1->poll_cnt < hnd2->poll_cnt) { + return -1; + } + return 0; +} + +static void fill_object_attributes(OBJECT_ATTRIBUTES *attr, + UNICODE_STRING *name, ULONG attributes) +{ + memset(attr, 0, sizeof(*attr)); + attr->Length = sizeof(*attr); + attr->ObjectName = name; + attr->Attributes = attributes; +} + +# define UNICODE_STRING_CONSTANT(s) \ + { (sizeof(s) - 1) * sizeof(wchar_t), sizeof(s) * sizeof(wchar_t), L##s } + +static ares__slist_node_t *ares_afd_handle_create(ares_evsys_win32_t *ew) +{ + UNICODE_STRING afd_device_name = UNICODE_STRING_CONSTANT("\\Device\\Afd"); + OBJECT_ATTRIBUTES afd_attributes; + NTSTATUS status; + IO_STATUS_BLOCK iosb; + ares_afd_handle_t *afd = ares_malloc_zero(sizeof(*afd)); + ares__slist_node_t *node = NULL; + if (afd == NULL) { + goto fail; + } + + /* Open a handle to the AFD subsystem */ + fill_object_attributes(&afd_attributes, &afd_device_name, 0); + memset(&iosb, 0, sizeof(iosb)); + iosb.Status = STATUS_PENDING; + status = ew->NtCreateFile(&afd->afd_handle, SYNCHRONIZE, &afd_attributes, + &iosb, NULL, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, + FILE_OPEN, 0, NULL, 0); + if (status != STATUS_SUCCESS) { + CARES_DEBUG_LOG("** Failed to create AFD endpoint\n"); + goto fail; + } + + if (CreateIoCompletionPort(afd->afd_handle, ew->iocp_handle, + 0 /* CompletionKey */, 0) == NULL) { + goto fail; + } + + if (!SetFileCompletionNotificationModes(afd->afd_handle, + FILE_SKIP_SET_EVENT_ON_HANDLE)) { + goto fail; + } + + node = ares__slist_insert(ew->afd_handles, afd); + if (node == NULL) { + goto fail; + } + + return node; + +fail: + + ares_afd_handle_destroy(afd); + return NULL; +} + +/* Fetch the lowest poll count entry, but if it exceeds the limit, create a + * new one and return that */ +static ares__slist_node_t *ares_afd_handle_fetch(ares_evsys_win32_t *ew) +{ + ares__slist_node_t *node = ares__slist_node_first(ew->afd_handles); + ares_afd_handle_t *afd = ares__slist_node_val(node); + + if (afd != NULL && afd->poll_cnt < AFD_POLL_PER_HANDLE) { + return node; + } + + return ares_afd_handle_create(ew); +} + static ares_bool_t ares_evsys_win32_init(ares_event_thread_t *e) { ares_evsys_win32_t *ew = NULL; HMODULE ntdll; + CARES_DEBUG_LOG("** Win32 Event Init\n"); + ew = ares_malloc_zero(sizeof(*ew)); if (ew == NULL) { return ARES_FALSE; @@ -258,29 +451,31 @@ static ares_bool_t ares_evsys_win32_init(ares_event_thread_t *e) goto fail; } -#ifdef __GNUC__ -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wpedantic" +# ifdef __GNUC__ +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wpedantic" /* Without the (void *) cast we get: - * warning: cast between incompatible function types from 'FARPROC' {aka 'long long int (*)()'} to 'NTSTATUS (*)(...)'} [-Wcast-function-type] - * but with it we get: - * warning: ISO C forbids conversion of function pointer to object pointer type [-Wpedantic] - * look unsolvable short of killing the warning. + * warning: cast between incompatible function types from 'FARPROC' {aka 'long + * long int (*)()'} to 'NTSTATUS (*)(...)'} [-Wcast-function-type] but with it + * we get: warning: ISO C forbids conversion of function pointer to object + * pointer type [-Wpedantic] look unsolvable short of killing the warning. */ -#endif - +# endif /* Load Internal symbols not typically accessible */ + ew->NtCreateFile = + (NtCreateFile_t)(void *)GetProcAddress(ntdll, "NtCreateFile"); ew->NtDeviceIoControlFile = (NtDeviceIoControlFile_t)(void *)GetProcAddress( ntdll, "NtDeviceIoControlFile"); ew->NtCancelIoFileEx = (NtCancelIoFileEx_t)(void *)GetProcAddress(ntdll, "NtCancelIoFileEx"); -#ifdef __GNUC__ -# pragma GCC diagnostic pop -#endif +# ifdef __GNUC__ +# pragma GCC diagnostic pop +# endif - if (ew->NtCancelIoFileEx == NULL || ew->NtDeviceIoControlFile == NULL) { + if (ew->NtCreateFile == NULL || ew->NtCancelIoFileEx == NULL || + ew->NtDeviceIoControlFile == NULL) { goto fail; } @@ -289,11 +484,28 @@ static ares_bool_t ares_evsys_win32_init(ares_event_thread_t *e) goto fail; } + ew->afd_handles = ares__slist_create( + e->channel->rand_state, ares_afd_handle_cmp, ares_afd_handle_destroy); + if (ew->afd_handles == NULL) { + goto fail; + } + + /* Create at least the first afd handle, so we know of any critical system + * issues during startup */ + if (ares_afd_handle_create(ew) == NULL) { + goto fail; + } + e->ev_signal = ares_iocpevent_create(e); if (e->ev_signal == NULL) { goto fail; } + ew->sockets = ares__htable_vpvp_create(NULL, NULL); + if (ew->sockets == NULL) { + goto fail; + } + return ARES_TRUE; fail: @@ -348,20 +560,33 @@ static ares_bool_t ares_evsys_win32_afd_enqueue(ares_event_t *event, ares_event_thread_t *e = event->e; ares_evsys_win32_t *ew = e->ev_sys_data; ares_evsys_win32_eventdata_t *ed = event->data; + ares_afd_handle_t *afd; NTSTATUS status; - IO_STATUS_BLOCK *iosb_ptr; if (e == NULL || ed == NULL || ew == NULL) { return ARES_FALSE; } + /* Misuse */ + if (ed->poll_status != POLL_STATUS_NONE) { + return ARES_FALSE; + } + + ed->afd_handle_node = ares_afd_handle_fetch(ew); + /* System resource issue? */ + if (ed->afd_handle_node == NULL) { + return ARES_FALSE; + } + + afd = ares__slist_node_val(ed->afd_handle_node); + /* Enqueue AFD Poll */ - ed->afd_poll_info.Exclusive = TRUE; + ed->afd_poll_info.Exclusive = FALSE; ed->afd_poll_info.NumberOfHandles = 1; ed->afd_poll_info.Timeout.QuadPart = LLONG_MAX; ed->afd_poll_info.Handles[0].Handle = (HANDLE)ed->base_socket; ed->afd_poll_info.Handles[0].Status = 0; - ed->afd_poll_info.Handles[0].Events = 0; + ed->afd_poll_info.Handles[0].Events = AFD_POLL_LOCAL_CLOSE; if (flags & ARES_EVENT_FLAG_READ) { ed->afd_poll_info.Handles[0].Events |= @@ -376,42 +601,65 @@ static ares_bool_t ares_evsys_win32_afd_enqueue(ares_event_t *event, ed->afd_poll_info.Handles[0].Events |= AFD_POLL_DISCONNECT; } - memset(&ed->overlapped, 0, sizeof(ed->overlapped)); - iosb_ptr = (IO_STATUS_BLOCK *)&ed->overlapped.Internal; - iosb_ptr->Status = STATUS_PENDING; + memset(&ed->iosb, 0, sizeof(ed->iosb)); + ed->iosb.Status = STATUS_PENDING; status = ew->NtDeviceIoControlFile( - (HANDLE)ed->peer_socket, NULL, NULL, &ed->overlapped, iosb_ptr, - IOCTL_AFD_POLL, &ed->afd_poll_info, sizeof(ed->afd_poll_info), - &ed->afd_poll_info, sizeof(ed->afd_poll_info)); + afd->afd_handle, NULL, NULL, &ed->iosb, &ed->iosb, IOCTL_AFD_POLL, + &ed->afd_poll_info, sizeof(ed->afd_poll_info), &ed->afd_poll_info, + sizeof(ed->afd_poll_info)); if (status != STATUS_SUCCESS && status != STATUS_PENDING) { + CARES_DEBUG_LOG("** afd_enqueue ed=%p FAILED\n", (void *)ed); + ed->afd_handle_node = NULL; return ARES_FALSE; } + /* Record that we submitted a poll request to this handle and tell it to + * re-sort the node since we changed its sort value */ + afd->poll_cnt++; + ares__slist_node_reinsert(ed->afd_handle_node); + + ed->poll_status = POLL_STATUS_PENDING; + CARES_DEBUG_LOG("++ afd_enqueue ed=%p flags=%X\n", (void *)ed, + (unsigned int)flags); return ARES_TRUE; } static ares_bool_t ares_evsys_win32_afd_cancel(ares_evsys_win32_eventdata_t *ed) { - IO_STATUS_BLOCK *iosb_ptr; IO_STATUS_BLOCK cancel_iosb; ares_evsys_win32_t *ew; NTSTATUS status; + ares_afd_handle_t *afd; - /* Detached due to destroy */ - if (ed->event == NULL) { + ew = ed->event->e->ev_sys_data; + + /* Misuse */ + if (ed->poll_status != POLL_STATUS_PENDING) { return ARES_FALSE; } - iosb_ptr = (IO_STATUS_BLOCK *)&ed->overlapped.Internal; - /* Not pending, nothing to do */ - if (iosb_ptr->Status != STATUS_PENDING) { + afd = ares__slist_node_val(ed->afd_handle_node); + + /* Misuse */ + if (afd == NULL) { return ARES_FALSE; } - ew = ed->event->e->ev_sys_data; - status = - ew->NtCancelIoFileEx((HANDLE)ed->peer_socket, iosb_ptr, &cancel_iosb); + ed->poll_status = POLL_STATUS_CANCEL; + + /* Not pending, nothing to do. Most likely that means there is a pending + * event that hasn't yet been delivered otherwise it would be re-armed + * already */ + if (ed->iosb.Status != STATUS_PENDING) { + CARES_DEBUG_LOG("** cancel not needed for ed=%p\n", (void *)ed); + return ARES_FALSE; + } + + status = ew->NtCancelIoFileEx(afd->afd_handle, &ed->iosb, &cancel_iosb); + + CARES_DEBUG_LOG("** Enqueued cancel for ed=%p, status = %lX\n", (void *)ed, + status); /* NtCancelIoFileEx() may return STATUS_NOT_FOUND if the operation completed * just before calling NtCancelIoFileEx(), but we have not yet received the @@ -423,14 +671,23 @@ static ares_bool_t ares_evsys_win32_afd_cancel(ares_evsys_win32_eventdata_t *ed) return ARES_FALSE; } -static void ares_evsys_win32_eventdata_destroy(ares_evsys_win32_eventdata_t *ed) +static void ares_evsys_win32_eventdata_destroy(ares_evsys_win32_t *ew, + ares_evsys_win32_eventdata_t *ed) { - if (ed == NULL) { + if (ew == NULL || ed == NULL) { return; } + CARES_DEBUG_LOG("-- deleting ed=%p (%s)\n", (void *)ed, + (ed->socket == ARES_SOCKET_BAD) ? "data" : "socket"); + /* These type of handles are deferred destroy. Update tracking. */ + if (ed->socket != ARES_SOCKET_BAD) { + ares__htable_vpvp_remove(ew->sockets, &ed->iosb); + } - if (ed->peer_socket != ARES_SOCKET_BAD) { - closesocket(ed->peer_socket); + ares__thread_mutex_destroy(ed->lock); + + if (ed->event != NULL) { + ed->event->data = NULL; } ares_free(ed); @@ -441,85 +698,77 @@ static ares_bool_t ares_evsys_win32_event_add(ares_event_t *event) ares_event_thread_t *e = event->e; ares_evsys_win32_t *ew = e->ev_sys_data; ares_evsys_win32_eventdata_t *ed; - WSAPROTOCOL_INFOW protocol_info; + ares_bool_t rc = ARES_FALSE; ed = ares_malloc_zero(sizeof(*ed)); ed->event = event; ed->socket = event->fd; ed->base_socket = ARES_SOCKET_BAD; - ed->peer_socket = ARES_SOCKET_BAD; + event->data = ed; + + CARES_DEBUG_LOG("++ add ed=%p (%s) flags=%X\n", (void *)ed, + (ed->socket == ARES_SOCKET_BAD) ? "data" : "socket", + (unsigned int)event->flags); /* Likely a signal event, not something we will directly handle. We create * the ares_evsys_win32_eventdata_t as the placeholder to use as the * IOCP Completion Key */ if (ed->socket == ARES_SOCKET_BAD) { - event->data = ed; - return ARES_TRUE; + ed->lock = ares__thread_mutex_create(); + if (ed->lock == NULL) { + goto done; + } + rc = ARES_TRUE; + goto done; } ed->base_socket = ares_evsys_win32_basesocket(ed->socket); if (ed->base_socket == ARES_SOCKET_BAD) { - ares_evsys_win32_eventdata_destroy(ed); - return ARES_FALSE; + goto done; } - /* Create a peer socket that supports OVERLAPPED so we can use IOCP on the - * socket handle */ - if (WSADuplicateSocketW(ed->base_socket, GetCurrentProcessId(), - &protocol_info) != 0) { - ares_evsys_win32_eventdata_destroy(ed); - return ARES_FALSE; + if (!ares__htable_vpvp_insert(ew->sockets, &ed->iosb, ed)) { + goto done; } - ed->peer_socket = - WSASocketW(protocol_info.iAddressFamily, protocol_info.iSocketType, - protocol_info.iProtocol, &protocol_info, 0, WSA_FLAG_OVERLAPPED); - if (ed->peer_socket == ARES_SOCKET_BAD) { - ares_evsys_win32_eventdata_destroy(ed); - return ARES_FALSE; - } - - SetHandleInformation((HANDLE)ed->peer_socket, HANDLE_FLAG_INHERIT, 0); - - if (CreateIoCompletionPort((HANDLE)ed->peer_socket, ew->iocp_handle, - (ULONG_PTR)ed, 0) == NULL) { - ares_evsys_win32_eventdata_destroy(ed); - return ARES_FALSE; + if (!ares_evsys_win32_afd_enqueue(event, event->flags)) { + goto done; } - event->data = ed; + rc = ARES_TRUE; - if (!ares_evsys_win32_afd_enqueue(event, event->flags)) { +done: + if (!rc) { + ares_evsys_win32_eventdata_destroy(ew, ed); event->data = NULL; - ares_evsys_win32_eventdata_destroy(ed); - return ARES_FALSE; } - - return ARES_TRUE; + return rc; } static void ares_evsys_win32_event_del(ares_event_t *event) { ares_evsys_win32_eventdata_t *ed = event->data; - ares_event_thread_t *e = event->e; - if (event->fd == ARES_SOCKET_BAD || !e->isup || ed == NULL || - !ares_evsys_win32_afd_cancel(ed)) { - /* Didn't need to enqueue a cancellation, for one of these reasons: - * - Not an IOCP socket - * - This is during shutdown of the event thread, no more signals can be - * delivered. - * - It has been determined there is no AFD POLL queued currently for the - * socket. - */ - ares_evsys_win32_eventdata_destroy(ed); - event->data = NULL; + /* Already cleaned up, likely a LOCAL_CLOSE */ + if (ed == NULL) { + return; + } + + CARES_DEBUG_LOG("-- DELETE requested for ed=%p (%s)\n", (void *)ed, + (ed->socket != ARES_SOCKET_BAD) ? "socket" : "data"); + + /* + * Cancel pending AFD Poll operation. + */ + if (ed->socket != ARES_SOCKET_BAD) { + ares_evsys_win32_afd_cancel(ed); + ed->poll_status = POLL_STATUS_DESTROY; + ed->event = NULL; } else { - /* Detach from event, so when the cancel event comes through, - * it will clean up */ - ed->event = NULL; - event->data = NULL; + ares_evsys_win32_eventdata_destroy(event->e->ev_sys_data, ed); } + + event->data = NULL; } static void ares_evsys_win32_event_mod(ares_event_t *event, @@ -532,11 +781,123 @@ static void ares_evsys_win32_event_mod(ares_event_t *event, return; } - /* Try to cancel any current outstanding poll, if one is not running, - * go ahead and queue it up */ - if (!ares_evsys_win32_afd_cancel(ed)) { - ares_evsys_win32_afd_enqueue(event, new_flags); + CARES_DEBUG_LOG("** mod ed=%p new_flags=%X\n", (void *)ed, + (unsigned int)new_flags); + + /* All we need to do is cancel the pending operation. When the event gets + * delivered for the cancellation, it will automatically re-enqueue a new + * event */ + ares_evsys_win32_afd_cancel(ed); +} + +static ares_bool_t ares_evsys_win32_process_other_event( + ares_evsys_win32_t *ew, ares_evsys_win32_eventdata_t *ed, size_t i) +{ + ares_event_t *event; + + /* NOTE: do NOT dereference 'ed' if during shutdown as this could be an + * invalid pointer if the signal handle was cleaned up, but there was still a + * pending event! */ + + if (ew->is_shutdown) { + CARES_DEBUG_LOG("\t\t** i=%lu, skip non-socket handle during shutdown\n", + (unsigned long)i); + return ARES_FALSE; + } + + event = ed->event; + CARES_DEBUG_LOG("\t\t** i=%lu, ed=%p (data)\n", (unsigned long)i, (void *)ed); + + event->cb(event->e, event->fd, event->data, ARES_EVENT_FLAG_OTHER); + return ARES_TRUE; +} + +static ares_bool_t ares_evsys_win32_process_socket_event( + ares_evsys_win32_t *ew, ares_evsys_win32_eventdata_t *ed, size_t i) +{ + ares_event_flags_t flags = 0; + ares_event_t *event = NULL; + ares_afd_handle_t *afd = NULL; + + /* Shouldn't be possible */ + if (ed == NULL) { + CARES_DEBUG_LOG("\t\t** i=%lu, Invalid handle.\n", (unsigned long)i); + return ARES_FALSE; + } + + event = ed->event; + + CARES_DEBUG_LOG("\t\t** i=%lu, ed=%p (socket)\n", (unsigned long)i, + (void *)ed); + + /* Process events */ + if (ed->poll_status == POLL_STATUS_PENDING && + ed->iosb.Status == STATUS_SUCCESS && + ed->afd_poll_info.NumberOfHandles > 0) { + if (ed->afd_poll_info.Handles[0].Events & + (AFD_POLL_RECEIVE | AFD_POLL_DISCONNECT | AFD_POLL_ACCEPT | + AFD_POLL_ABORT)) { + flags |= ARES_EVENT_FLAG_READ; + } + if (ed->afd_poll_info.Handles[0].Events & + (AFD_POLL_SEND | AFD_POLL_CONNECT_FAIL)) { + flags |= ARES_EVENT_FLAG_WRITE; + } + if (ed->afd_poll_info.Handles[0].Events & AFD_POLL_LOCAL_CLOSE) { + CARES_DEBUG_LOG("\t\t** ed=%p LOCAL CLOSE\n", (void *)ed); + ed->poll_status = POLL_STATUS_DESTROY; + } + } + + CARES_DEBUG_LOG("\t\t** ed=%p, iosb status=%lX, poll_status=%d, flags=%X\n", + (void *)ed, (unsigned long)ed->iosb.Status, + (int)ed->poll_status, (unsigned int)flags); + + /* Decrement poll count for AFD handle then resort, also disassociate + * with socket */ + afd = ares__slist_node_val(ed->afd_handle_node); + afd->poll_cnt--; + ares__slist_node_reinsert(ed->afd_handle_node); + ed->afd_handle_node = NULL; + + /* Pending destroy, go ahead and kill it */ + if (ed->poll_status == POLL_STATUS_DESTROY) { + ares_evsys_win32_eventdata_destroy(ew, ed); + return ARES_FALSE; + } + + ed->poll_status = POLL_STATUS_NONE; + + /* Mask flags against current desired flags. We could have an event + * queued that is outdated. */ + flags &= event->flags; + + /* Don't actually do anything with the event that was delivered as we are + * in a shutdown/cleanup process. Mostly just handling the delayed + * destruction of sockets */ + if (ew->is_shutdown) { + return ARES_FALSE; + } + + /* Re-enqueue so we can get more events on the socket, we either + * received a real event, or a cancellation notice. Both cases we + * re-queue using the current configured event flags. + * + * If we can't re-enqueue, that likely means the socket has been + * closed, so we want to kill our reference to it + */ + if (!ares_evsys_win32_afd_enqueue(event, event->flags)) { + ares_evsys_win32_eventdata_destroy(ew, ed); + return ARES_FALSE; } + + /* No events we recognize to deliver */ + if (flags == 0) { + return ARES_FALSE; + } + + event->cb(event->e, event->fd, event->data, flags); + return ARES_TRUE; } static size_t ares_evsys_win32_wait(ares_event_thread_t *e, @@ -544,60 +905,55 @@ static size_t ares_evsys_win32_wait(ares_event_thread_t *e, { ares_evsys_win32_t *ew = e->ev_sys_data; OVERLAPPED_ENTRY entries[16]; - ULONG nentries = sizeof(entries) / sizeof(*entries); + ULONG maxentries = sizeof(entries) / sizeof(*entries); + ULONG nentries; BOOL status; size_t i; - size_t cnt = 0; - - status = GetQueuedCompletionStatusEx( - ew->iocp_handle, entries, nentries, &nentries, - (timeout_ms == 0) ? INFINITE : (DWORD)timeout_ms, FALSE); - - if (!status) { - return 0; - } - - for (i = 0; i < (size_t)nentries; i++) { - ares_event_flags_t flags = 0; - ares_evsys_win32_eventdata_t *ed = - (ares_evsys_win32_eventdata_t *)entries[i].lpCompletionKey; - ares_event_t *event = ed->event; - - if (ed->socket == ARES_SOCKET_BAD) { - /* Some sort of signal event */ - flags = ARES_EVENT_FLAG_OTHER; - } else { - /* Process events */ - if (ed->afd_poll_info.NumberOfHandles > 0) { - if (ed->afd_poll_info.Handles[0].Events & - (AFD_POLL_RECEIVE | AFD_POLL_DISCONNECT | AFD_POLL_ACCEPT | - AFD_POLL_ABORT)) { - flags |= ARES_EVENT_FLAG_READ; - } - if (ed->afd_poll_info.Handles[0].Events & - (AFD_POLL_SEND | AFD_POLL_CONNECT_FAIL)) { - flags |= ARES_EVENT_FLAG_WRITE; - } - - /* XXX: Handle ed->afd_poll_info.Handles[0].Events & - * AFD_POLL_LOCAL_CLOSE */ - } + size_t cnt = 0; + DWORD tout = (timeout_ms == 0) ? INFINITE : (DWORD)timeout_ms; + + CARES_DEBUG_LOG("** Wait Enter\n"); + /* Process in a loop for as long as it fills the entire entries buffer, and + * on subsequent attempts, ensure the timeout is 0 */ + do { + nentries = maxentries; + status = GetQueuedCompletionStatusEx(ew->iocp_handle, entries, nentries, + &nentries, tout, FALSE); + + /* Next loop around, we want to return instantly if there are no events to + * be processed */ + tout = 0; + + if (!status) { + break; + } - if (event == NULL) { - /* This means we need to cleanup the private event data as we've been - * detached */ - ares_evsys_win32_eventdata_destroy(ed); + CARES_DEBUG_LOG("\t** GetQueuedCompletionStatusEx returned %lu entries\n", + (unsigned long)nentries); + for (i = 0; i < (size_t)nentries; i++) { + ares_evsys_win32_eventdata_t *ed = NULL; + ares_bool_t rc; + + /* For things triggered via PostQueuedCompletionStatus() we have an + * lpCompletionKey we can just use. Otherwise we need to dereference the + * pointer returned in lpOverlapped to determine the referenced + * socket */ + if (entries[i].lpCompletionKey) { + ed = (ares_evsys_win32_eventdata_t *)entries[i].lpCompletionKey; + rc = ares_evsys_win32_process_other_event(ew, ed, i); } else { - /* Re-enqueue so we can get more events on the socket */ - ares_evsys_win32_afd_enqueue(event, event->flags); + ed = ares__htable_vpvp_get_direct(ew->sockets, entries[i].lpOverlapped); + rc = ares_evsys_win32_process_socket_event(ew, ed, i); } - } - if (event != NULL && flags != 0) { - cnt++; - event->cb(e, event->fd, event->data, flags); + /* We processed actual events */ + if (rc) { + cnt++; + } } - } + } while (nentries == maxentries); + + CARES_DEBUG_LOG("** Wait Exit\n"); return cnt; } diff --git a/deps/cares/src/lib/ares_event_win32.h b/deps/cares/src/lib/ares_event_win32.h index 99cd5c90f359c8..5d0274cd85cd61 100644 --- a/deps/cares/src/lib/ares_event_win32.h +++ b/deps/cares/src/lib/ares_event_win32.h @@ -67,17 +67,53 @@ typedef VOID(NTAPI *PIO_APC_ROUTINE)(PVOID ApcContext, # define STATUS_CANCELLED ((NTSTATUS)0xC0000120L) # define STATUS_NOT_FOUND ((NTSTATUS)0xC0000225L) +typedef struct _UNICODE_STRING { + USHORT Length; + USHORT MaximumLength; + LPCWSTR Buffer; +} UNICODE_STRING, *PUNICODE_STRING; + +typedef struct _OBJECT_ATTRIBUTES { + ULONG Length; + HANDLE RootDirectory; + PUNICODE_STRING ObjectName; + ULONG Attributes; + PVOID SecurityDescriptor; + PVOID SecurityQualityOfService; +} OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES; + +# ifndef FILE_OPEN +# define FILE_OPEN 0x00000001UL +# endif + /* Not sure what headers might have these */ # define IOCTL_AFD_POLL 0x00012024 -# define AFD_POLL_RECEIVE 0x0001 -# define AFD_POLL_RECEIVE_EXPEDITED 0x0002 -# define AFD_POLL_SEND 0x0004 -# define AFD_POLL_DISCONNECT 0x0008 -# define AFD_POLL_ABORT 0x0010 -# define AFD_POLL_LOCAL_CLOSE 0x0020 -# define AFD_POLL_ACCEPT 0x0080 -# define AFD_POLL_CONNECT_FAIL 0x0100 +# define AFD_POLL_RECEIVE_BIT 0 +# define AFD_POLL_RECEIVE (1 << AFD_POLL_RECEIVE_BIT) +# define AFD_POLL_RECEIVE_EXPEDITED_BIT 1 +# define AFD_POLL_RECEIVE_EXPEDITED (1 << AFD_POLL_RECEIVE_EXPEDITED_BIT) +# define AFD_POLL_SEND_BIT 2 +# define AFD_POLL_SEND (1 << AFD_POLL_SEND_BIT) +# define AFD_POLL_DISCONNECT_BIT 3 +# define AFD_POLL_DISCONNECT (1 << AFD_POLL_DISCONNECT_BIT) +# define AFD_POLL_ABORT_BIT 4 +# define AFD_POLL_ABORT (1 << AFD_POLL_ABORT_BIT) +# define AFD_POLL_LOCAL_CLOSE_BIT 5 +# define AFD_POLL_LOCAL_CLOSE (1 << AFD_POLL_LOCAL_CLOSE_BIT) +# define AFD_POLL_CONNECT_BIT 6 +# define AFD_POLL_CONNECT (1 << AFD_POLL_CONNECT_BIT) +# define AFD_POLL_ACCEPT_BIT 7 +# define AFD_POLL_ACCEPT (1 << AFD_POLL_ACCEPT_BIT) +# define AFD_POLL_CONNECT_FAIL_BIT 8 +# define AFD_POLL_CONNECT_FAIL (1 << AFD_POLL_CONNECT_FAIL_BIT) +# define AFD_POLL_QOS_BIT 9 +# define AFD_POLL_QOS (1 << AFD_POLL_QOS_BIT) +# define AFD_POLL_GROUP_QOS_BIT 10 +# define AFD_POLL_GROUP_QOS (1 << AFD_POLL_GROUP_QOS_BIT) + +# define AFD_NUM_POLL_EVENTS 11 +# define AFD_POLL_ALL ((1 << AFD_NUM_POLL_EVENTS) - 1) typedef struct _AFD_POLL_HANDLE_INFO { HANDLE Handle; @@ -101,6 +137,12 @@ typedef NTSTATUS(NTAPI *NtDeviceIoControlFile_t)( PIO_STATUS_BLOCK IoStatusBlock, ULONG IoControlCode, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength); +typedef NTSTATUS(NTAPI *NtCreateFile_t)( + PHANDLE FileHandle, ACCESS_MASK DesiredAccess, + POBJECT_ATTRIBUTES ObjectAttributes, PIO_STATUS_BLOCK IoStatusBlock, + PLARGE_INTEGER AllocationSize, ULONG FileAttributes, ULONG ShareAccess, + ULONG CreateDisposition, ULONG CreateOptions, PVOID EaBuffer, ULONG EaLength); + /* On UWP/Windows Store, these definitions aren't there for some reason */ # ifndef SIO_BSP_HANDLE_POLL # define SIO_BSP_HANDLE_POLL 0x4800001D diff --git a/deps/cares/src/lib/ares_init.c b/deps/cares/src/lib/ares_init.c index 5456444ae492df..cc7b85d783ee84 100644 --- a/deps/cares/src/lib/ares_init.c +++ b/deps/cares/src/lib/ares_init.c @@ -280,6 +280,9 @@ int ares_init_options(ares_channel_t **channelptr, return ARES_ENOMEM; } + /* We are in a good state */ + channel->sys_up = ARES_TRUE; + /* One option where zero is valid, so set default value here */ channel->ndots = 1; @@ -437,8 +440,9 @@ ares_status_t ares_reinit(ares_channel_t *channel) ares__channel_lock(channel); - /* If a reinit is already in process, lets not do it again */ - if (channel->reinit_pending) { + /* If a reinit is already in process, lets not do it again. Or if we are + * shutting down, skip. */ + if (!channel->sys_up || channel->reinit_pending) { ares__channel_unlock(channel); return ARES_SUCCESS; } diff --git a/deps/cares/src/lib/ares_metrics.c b/deps/cares/src/lib/ares_metrics.c index 4b40677239fdbe..78f93bc1b7d649 100644 --- a/deps/cares/src/lib/ares_metrics.c +++ b/deps/cares/src/lib/ares_metrics.c @@ -211,7 +211,7 @@ size_t ares_metrics_server_timeout(const struct server_state *server, const ares_channel_t *channel = server->channel; ares_server_bucket_t i; size_t timeout_ms = 0; - + size_t max_timeout_ms; for (i = 0; i < ARES_METRIC_COUNT; i++) { time_t ts = ares_metric_timestamp(i, now, ARES_FALSE); @@ -252,10 +252,9 @@ size_t ares_metrics_server_timeout(const struct server_state *server, } /* don't go above upper bounds */ - if (channel->maxtimeout && timeout_ms > channel->maxtimeout) { - timeout_ms = channel->maxtimeout; - } else if (timeout_ms > MAX_TIMEOUT_MS) { - timeout_ms = MAX_TIMEOUT_MS; + max_timeout_ms = channel->maxtimeout?channel->maxtimeout:MAX_TIMEOUT_MS; + if (timeout_ms > max_timeout_ms) { + timeout_ms = max_timeout_ms; } return timeout_ms; diff --git a/deps/cares/src/lib/ares_private.h b/deps/cares/src/lib/ares_private.h index 3b5f627bd16d66..5506416d8efefb 100644 --- a/deps/cares/src/lib/ares_private.h +++ b/deps/cares/src/lib/ares_private.h @@ -385,6 +385,12 @@ struct ares_channeldata { * exit. */ ares_bool_t reinit_pending; ares__thread_t *reinit_thread; + + /* Whether the system is up or not. This is mainly to prevent deadlocks + * and access violations during the cleanup process. Some things like + * system config changes might get triggered and we need a flag to make + * sure we don't take action. */ + ares_bool_t sys_up; }; /* Does the domain end in ".onion" or ".onion."? Case-insensitive. */ @@ -404,7 +410,8 @@ ares_bool_t ares__timedout(const ares_timeval_t *now, /* Returns one of the normal ares status codes like ARES_SUCCESS */ ares_status_t ares__send_query(struct query *query, const ares_timeval_t *now); ares_status_t ares__requeue_query(struct query *query, - const ares_timeval_t *now); + const ares_timeval_t *now, + ares_status_t status); /*! Retrieve a list of names to use for searching. The first successful * query in the list wins. This function also uses the HOSTSALIASES file @@ -432,10 +439,10 @@ void *ares__dnsrec_convert_arg(ares_callback callback, void *arg); void ares__dnsrec_convert_cb(void *arg, ares_status_t status, size_t timeouts, const ares_dns_record_t *dnsrec); -void ares__close_connection(struct server_connection *conn); +void ares__close_connection(struct server_connection *conn, + ares_status_t requeue_status); void ares__close_sockets(struct server_state *server); -void ares__check_cleanup_conn(const ares_channel_t *channel, - struct server_connection *conn); +void ares__check_cleanup_conns(const ares_channel_t *channel); void ares__free_query(struct query *query); ares_rand_state *ares__init_rand_state(void); diff --git a/deps/cares/src/lib/ares_process.c b/deps/cares/src/lib/ares_process.c index 562d6b5e1b1e3c..01d9e6a49d3431 100644 --- a/deps/cares/src/lib/ares_process.c +++ b/deps/cares/src/lib/ares_process.c @@ -58,7 +58,8 @@ static ares_status_t process_answer(ares_channel_t *channel, struct server_connection *conn, ares_bool_t tcp, const ares_timeval_t *now); static void handle_conn_error(struct server_connection *conn, - ares_bool_t critical_failure); + ares_bool_t critical_failure, + ares_status_t failure_status); static ares_bool_t same_questions(const struct query *query, const ares_dns_record_t *arec); @@ -68,6 +69,17 @@ static void end_query(ares_channel_t *channel, struct server_state *server, struct query *query, ares_status_t status, const ares_dns_record_t *dnsrec); + +static void ares__query_disassociate_from_conn(struct query *query) +{ + /* If its not part of a connection, it can't be tracked for timeouts either */ + ares__slist_node_destroy(query->node_queries_by_timeout); + ares__llist_node_destroy(query->node_queries_to_conn); + query->node_queries_by_timeout = NULL; + query->node_queries_to_conn = NULL; + query->conn = NULL; +} + /* Invoke the server state callback after a success or failure */ static void invoke_server_state_cb(const struct server_state *server, ares_bool_t success, int flags) @@ -202,6 +214,8 @@ static void processfds(ares_channel_t *channel, fd_set *read_fds, /* Write last as the other 2 operations might have triggered writes */ write_tcp_data(channel, write_fds, write_fd); + /* See if any connections should be cleaned up */ + ares__check_cleanup_conns(channel); ares__channel_unlock(channel); } @@ -301,7 +315,7 @@ static void write_tcp_data(ares_channel_t *channel, fd_set *write_fds, count = ares__socket_write(channel, server->tcp_conn->fd, data, data_len); if (count <= 0) { if (!try_again(SOCKERRNO)) { - handle_conn_error(server->tcp_conn, ARES_TRUE); + handle_conn_error(server->tcp_conn, ARES_TRUE, ARES_ECONNREFUSED); } continue; } @@ -334,7 +348,7 @@ static void read_tcp_data(ares_channel_t *channel, ptr = ares__buf_append_start(server->tcp_parser, &ptr_len); if (ptr == NULL) { - handle_conn_error(conn, ARES_FALSE /* not critical to connection */); + handle_conn_error(conn, ARES_FALSE /* not critical to connection */, ARES_SUCCESS); return; /* bail out on malloc failure. TODO: make this function return error codes */ } @@ -344,7 +358,7 @@ static void read_tcp_data(ares_channel_t *channel, if (count <= 0) { ares__buf_append_finish(server->tcp_parser, 0); if (!(count == -1 && try_again(SOCKERRNO))) { - handle_conn_error(conn, ARES_TRUE); + handle_conn_error(conn, ARES_TRUE, ARES_ECONNREFUSED); } return; } @@ -388,15 +402,13 @@ static void read_tcp_data(ares_channel_t *channel, /* We finished reading this answer; process it */ status = process_answer(channel, data, data_len, conn, ARES_TRUE, now); if (status != ARES_SUCCESS) { - handle_conn_error(conn, ARES_TRUE); + handle_conn_error(conn, ARES_TRUE, status); return; } /* Since we processed the answer, clear the tag so space can be reclaimed */ ares__buf_tag_clear(server->tcp_parser); } - - ares__check_cleanup_conn(channel, conn); } static int socket_list_append(ares_socket_t **socketlist, ares_socket_t fd, @@ -503,7 +515,7 @@ static void read_udp_packets_fd(ares_channel_t *channel, break; } - handle_conn_error(conn, ARES_TRUE); + handle_conn_error(conn, ARES_TRUE, ARES_ECONNREFUSED); return; #ifdef HAVE_RECVFROM } else if (!same_address(&from.sa, &conn->server->addr)) { @@ -520,8 +532,6 @@ static void read_udp_packets_fd(ares_channel_t *channel, /* Try to read again only if *we* set up the socket, otherwise it may be * a blocking socket and would cause recvfrom to hang. */ } while (read_len >= 0 && channel->sock_funcs == NULL); - - ares__check_cleanup_conn(channel, conn); } static void read_packets(ares_channel_t *channel, fd_set *read_fds, @@ -594,28 +604,26 @@ static void read_packets(ares_channel_t *channel, fd_set *read_fds, /* If any queries have timed out, note the timeout and move them on. */ static void process_timeouts(ares_channel_t *channel, const ares_timeval_t *now) { - ares__slist_node_t *node = - ares__slist_node_first(channel->queries_by_timeout); - while (node != NULL) { + ares__slist_node_t *node; + + /* Just keep popping off the first as this list will re-sort as things come + * and go. We don't want to try to rely on 'next' as some operation might + * cause a cleanup of that pointer and would become invalid */ + while ((node = ares__slist_node_first(channel->queries_by_timeout)) != NULL) { struct query *query = ares__slist_node_val(node); - /* Node might be removed, cache next */ - ares__slist_node_t *next = ares__slist_node_next(node); struct server_connection *conn; + /* Since this is sorted, as soon as we hit a query that isn't timed out, * break */ if (!ares__timedout(now, &query->timeout)) { break; } - query->error_status = ARES_ETIMEOUT; query->timeouts++; conn = query->conn; server_increment_failures(conn->server, query->using_tcp); - ares__requeue_query(query, now); - ares__check_cleanup_conn(channel, conn); - - node = next; + ares__requeue_query(query, now, ARES_ETIMEOUT); } } @@ -733,20 +741,20 @@ static ares_status_t process_answer(ares_channel_t *channel, rcode == ARES_RCODE_REFUSED) { switch (rcode) { case ARES_RCODE_SERVFAIL: - query->error_status = ARES_ESERVFAIL; + status = ARES_ESERVFAIL; break; case ARES_RCODE_NOTIMP: - query->error_status = ARES_ENOTIMP; + status = ARES_ENOTIMP; break; case ARES_RCODE_REFUSED: - query->error_status = ARES_EREFUSED; + status = ARES_EREFUSED; break; default: break; } server_increment_failures(server, query->using_tcp); - ares__requeue_query(query, now); + ares__requeue_query(query, now, status); /* Should any of these cause a connection termination? * Maybe SERVER_FAILURE? */ @@ -776,7 +784,8 @@ static ares_status_t process_answer(ares_channel_t *channel, } static void handle_conn_error(struct server_connection *conn, - ares_bool_t critical_failure) + ares_bool_t critical_failure, + ares_status_t failure_status) { struct server_state *server = conn->server; @@ -787,17 +796,23 @@ static void handle_conn_error(struct server_connection *conn, } /* This will requeue any connections automatically */ - ares__close_connection(conn); + ares__close_connection(conn, failure_status); } ares_status_t ares__requeue_query(struct query *query, - const ares_timeval_t *now) + const ares_timeval_t *now, + ares_status_t status) { ares_channel_t *channel = query->channel; size_t max_tries = ares__slist_len(channel->servers) * channel->tries; - query->try_count++; + ares__query_disassociate_from_conn(query); + if (status != ARES_SUCCESS) { + query->error_status = status; + } + + query->try_count++; if (query->try_count < max_tries && !query->no_retries) { return ares__send_query(query, now); } @@ -947,7 +962,14 @@ static ares_status_t ares__write_udpbuf(ares_channel_t *channel, } if (ares__socket_write(channel, fd, qbuf, qbuf_len) == -1) { - status = ARES_ESERVFAIL; + if (try_again(SOCKERRNO)) { + status = ARES_ESERVFAIL; + } else { + /* UDP is connection-less, but we might receive an ICMP unreachable which + * means we can't talk to the remote host at all and that will be + * reflected here */ + status = ARES_ECONNREFUSED; + } } else { status = ARES_SUCCESS; } @@ -1018,8 +1040,6 @@ ares_status_t ares__send_query(struct query *query, const ares_timeval_t *now) ares_status_t status; ares_bool_t new_connection = ARES_FALSE; - query->conn = NULL; - /* Choose the server to send the query to */ if (channel->rotate) { /* Pull random server */ @@ -1052,8 +1072,7 @@ ares_status_t ares__send_query(struct query *query, const ares_timeval_t *now) case ARES_ECONNREFUSED: case ARES_EBADFAMILY: server_increment_failures(server, query->using_tcp); - query->error_status = status; - return ares__requeue_query(query, now); + return ares__requeue_query(query, now, status); /* Anything else is not retryable, likely ENOMEM */ default: @@ -1073,7 +1092,7 @@ ares_status_t ares__send_query(struct query *query, const ares_timeval_t *now) /* Only safe to kill connection if it was new, otherwise it should be * cleaned up by another process later */ if (new_connection) { - ares__close_connection(conn); + ares__close_connection(conn, status); } return status; } @@ -1111,8 +1130,7 @@ ares_status_t ares__send_query(struct query *query, const ares_timeval_t *now) case ARES_ECONNREFUSED: case ARES_EBADFAMILY: server_increment_failures(server, query->using_tcp); - query->error_status = status; - return ares__requeue_query(query, now); + return ares__requeue_query(query, now, status); /* Anything else is not retryable, likely ENOMEM */ default: @@ -1132,14 +1150,27 @@ ares_status_t ares__send_query(struct query *query, const ares_timeval_t *now) return status; } - /* FIXME: Handle EAGAIN here since it likely can happen. */ + if (status == ARES_ECONNREFUSED) { + handle_conn_error(conn, ARES_TRUE, status); + + /* This query wasn't yet bound to the connection, need to manually + * requeue it and return an appropriate error */ + status = ares__requeue_query(query, now, status); + if (status == ARES_ETIMEOUT) { + status = ARES_ECONNREFUSED; + } + return status; + } + + /* FIXME: Handle EAGAIN here since it likely can happen. Right now we + * just requeue to a different server/connection. */ server_increment_failures(server, query->using_tcp); - status = ares__requeue_query(query, now); + status = ares__requeue_query(query, now, status); /* Only safe to kill connection if it was new, otherwise it should be * cleaned up by another process later */ if (new_connection) { - ares__close_connection(conn); + ares__close_connection(conn, status); } return status; @@ -1162,7 +1193,7 @@ ares_status_t ares__send_query(struct query *query, const ares_timeval_t *now) /* Only safe to kill connection if it was new, otherwise it should be * cleaned up by another process later */ if (new_connection) { - ares__close_connection(conn); + ares__close_connection(conn, ARES_SUCCESS); } return ARES_ENOMEM; /* LCOV_EXCL_STOP */ @@ -1180,7 +1211,7 @@ ares_status_t ares__send_query(struct query *query, const ares_timeval_t *now) /* Only safe to kill connection if it was new, otherwise it should be * cleaned up by another process later */ if (new_connection) { - ares__close_connection(conn); + ares__close_connection(conn, ARES_SUCCESS); } return ARES_ENOMEM; /* LCOV_EXCL_STOP */ @@ -1283,12 +1314,9 @@ static ares_bool_t same_address(const struct sockaddr *sa, static void ares_detach_query(struct query *query) { /* Remove the query from all the lists in which it is linked */ + ares__query_disassociate_from_conn(query); ares__htable_szvp_remove(query->channel->queries_by_qid, query->qid); - ares__slist_node_destroy(query->node_queries_by_timeout); - ares__llist_node_destroy(query->node_queries_to_conn); ares__llist_node_destroy(query->node_all_queries); - query->node_queries_by_timeout = NULL; - query->node_queries_to_conn = NULL; query->node_all_queries = NULL; } diff --git a/deps/cares/src/lib/ares_send.c b/deps/cares/src/lib/ares_send.c index 94e7e12b42d0ce..e07ef5b51feafe 100644 --- a/deps/cares/src/lib/ares_send.c +++ b/deps/cares/src/lib/ares_send.c @@ -145,11 +145,11 @@ ares_status_t ares_send_nolock(ares_channel_t *channel, query->using_tcp = (channel->flags & ARES_FLAG_USEVC)?ARES_TRUE:ARES_FALSE; /* Duplicate Query */ - query->query = ares_dns_record_duplicate(dnsrec); - if (query->query == NULL) { + status = ares_dns_record_duplicate_ex(&query->query, dnsrec); + if (status != ARES_SUCCESS) { ares_free(query); - callback(arg, ARES_ENOMEM, 0, NULL); - return ARES_ENOMEM; + callback(arg, status, 0, NULL); + return status; } ares_dns_record_set_id(query->query, id); diff --git a/deps/cares/src/lib/ares_sysconfig_win.c b/deps/cares/src/lib/ares_sysconfig_win.c index 5ca7ccb50cf18d..ce2a261cec82bb 100644 --- a/deps/cares/src/lib/ares_sysconfig_win.c +++ b/deps/cares/src/lib/ares_sysconfig_win.c @@ -356,10 +356,11 @@ static ares_bool_t get_DNS_Windows(char **outptr) * compute the resulting total metric, just as Windows routing will do. * Then, sort all the addresses found by the metric. */ - for (ipaDNSAddr = ipaaEntry->FirstDnsServerAddress; ipaDNSAddr; + for (ipaDNSAddr = ipaaEntry->FirstDnsServerAddress; ipaDNSAddr != NULL; ipaDNSAddr = ipaDNSAddr->Next) { char ipaddr[INET6_ADDRSTRLEN] = ""; - namesrvr.sa = ipaDNSAddr->Address.lpSockaddr; + + namesrvr.sa = ipaDNSAddr->Address.lpSockaddr; if (namesrvr.sa->sa_family == AF_INET) { if ((namesrvr.sa4->sin_addr.S_un.S_addr == INADDR_ANY) || diff --git a/deps/cares/src/tools/CMakeLists.txt b/deps/cares/src/tools/CMakeLists.txt index 0016ca4c0b1a0a..e23d0f23c781f7 100644 --- a/deps/cares/src/tools/CMakeLists.txt +++ b/deps/cares/src/tools/CMakeLists.txt @@ -32,6 +32,9 @@ IF (CARES_BUILD_TOOLS) # Build adig ADD_EXECUTABLE (adig adig.c ${SAMPLESOURCES}) + # Don't build adig and ahost in parallel. This is to prevent a Windows MSVC + # build error due to them both using the same source files. + ADD_DEPENDENCIES(adig ahost) TARGET_INCLUDE_DIRECTORIES (adig PUBLIC "$" "$" diff --git a/deps/corepack/CHANGELOG.md b/deps/corepack/CHANGELOG.md index 1621a5b04ddb1d..a7b01aa8fb10bf 100644 --- a/deps/corepack/CHANGELOG.md +++ b/deps/corepack/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## [0.29.3](https://github.com/nodejs/corepack/compare/v0.29.2...v0.29.3) (2024-07-21) + + +### Bug Fixes + +* fallback to `shasum` when `integrity` is not defined ([#542](https://github.com/nodejs/corepack/issues/542)) ([eb63873](https://github.com/nodejs/corepack/commit/eb63873c6c617a2f8ac7106e26ccfe8aa3ae1fb9)) +* make `DEBUG=corepack` more useful ([#538](https://github.com/nodejs/corepack/issues/538)) ([6019d7b](https://github.com/nodejs/corepack/commit/6019d7b56e85bd8b7b58a1a487922c707e70e30e)) + ## [0.29.2](https://github.com/nodejs/corepack/compare/v0.29.1...v0.29.2) (2024-07-13) diff --git a/deps/corepack/dist/lib/corepack.cjs b/deps/corepack/dist/lib/corepack.cjs index 2714690cac4fe7..12df55126256e5 100644 --- a/deps/corepack/dist/lib/corepack.cjs +++ b/deps/corepack/dist/lib/corepack.cjs @@ -12,8 +12,8 @@ var __commonJS = (cb, mod) => function __require() { return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; }; var __export = (target, all) => { - for (var name in all) - __defProp(target, name, { get: all[name], enumerable: true }); + for (var name2 in all) + __defProp(target, name2, { get: all[name2], enumerable: true }); }; var __copyProps = (to, from, except, desc) => { if (from && typeof from === "object" || typeof from === "function") { @@ -1037,18 +1037,71 @@ var init_lib = __esm({ } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/internal/debug.js +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/platform/node.js +var require_node = __commonJS({ + ".yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/platform/node.js"(exports2) { + "use strict"; + Object.defineProperty(exports2, "__esModule", { value: true }); + var tty2 = require("tty"); + function _interopDefaultLegacy(e) { + return e && typeof e === "object" && "default" in e ? e : { "default": e }; + } + var tty__default = /* @__PURE__ */ _interopDefaultLegacy(tty2); + function getDefaultColorDepth2() { + if (tty__default["default"] && `getColorDepth` in tty__default["default"].WriteStream.prototype) + return tty__default["default"].WriteStream.prototype.getColorDepth(); + if (process.env.FORCE_COLOR === `0`) + return 1; + if (process.env.FORCE_COLOR === `1`) + return 8; + if (typeof process.stdout !== `undefined` && process.stdout.isTTY) + return 8; + return 1; + } + var gContextStorage; + function getCaptureActivator2(context) { + let contextStorage = gContextStorage; + if (typeof contextStorage === `undefined`) { + if (context.stdout === process.stdout && context.stderr === process.stderr) + return null; + const { AsyncLocalStorage: LazyAsyncLocalStorage } = require("async_hooks"); + contextStorage = gContextStorage = new LazyAsyncLocalStorage(); + const origStdoutWrite = process.stdout._write; + process.stdout._write = function(chunk, encoding, cb) { + const context2 = contextStorage.getStore(); + if (typeof context2 === `undefined`) + return origStdoutWrite.call(this, chunk, encoding, cb); + return context2.stdout.write(chunk, encoding, cb); + }; + const origStderrWrite = process.stderr._write; + process.stderr._write = function(chunk, encoding, cb) { + const context2 = contextStorage.getStore(); + if (typeof context2 === `undefined`) + return origStderrWrite.call(this, chunk, encoding, cb); + return context2.stderr.write(chunk, encoding, cb); + }; + } + return (fn2) => { + return contextStorage.run(context, fn2); + }; + } + exports2.getCaptureActivator = getCaptureActivator2; + exports2.getDefaultColorDepth = getDefaultColorDepth2; + } +}); + +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/internal/debug.js var require_debug = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/internal/debug.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/internal/debug.js"(exports2, module2) { var debug2 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => { }; module2.exports = debug2; } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/internal/constants.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/internal/constants.js var require_constants = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/internal/constants.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/internal/constants.js"(exports2, module2) { var SEMVER_SPEC_VERSION = "2.0.0"; var MAX_LENGTH = 256; var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */ @@ -1077,9 +1130,9 @@ var require_constants = __commonJS({ } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/internal/re.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/internal/re.js var require_re = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/internal/re.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/internal/re.js"(exports2, module2) { var { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, @@ -1104,11 +1157,11 @@ var require_re = __commonJS({ } return value; }; - var createToken = (name, value, isGlobal) => { + var createToken = (name2, value, isGlobal) => { const safe = makeSafeRegex(value); const index = R++; - debug2(name, index, value); - t[name] = index; + debug2(name2, index, value); + t[name2] = index; src[index] = value; re[index] = new RegExp(value, isGlobal ? "g" : void 0); safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0); @@ -1162,9 +1215,9 @@ var require_re = __commonJS({ } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/internal/parse-options.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/internal/parse-options.js var require_parse_options = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/internal/parse-options.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/internal/parse-options.js"(exports2, module2) { var looseOption = Object.freeze({ loose: true }); var emptyOpts = Object.freeze({}); var parseOptions = (options) => { @@ -1180,9 +1233,9 @@ var require_parse_options = __commonJS({ } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/internal/identifiers.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/internal/identifiers.js var require_identifiers = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/internal/identifiers.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/internal/identifiers.js"(exports2, module2) { var numeric = /^[0-9]+$/; var compareIdentifiers = (a, b) => { const anum = numeric.test(a); @@ -1201,40 +1254,40 @@ var require_identifiers = __commonJS({ } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/classes/semver.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/classes/semver.js var require_semver = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/classes/semver.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/classes/semver.js"(exports2, module2) { var debug2 = require_debug(); var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants(); var { safeRe: re, t } = require_re(); var parseOptions = require_parse_options(); var { compareIdentifiers } = require_identifiers(); var SemVer3 = class _SemVer { - constructor(version2, options) { + constructor(version3, options) { options = parseOptions(options); - if (version2 instanceof _SemVer) { - if (version2.loose === !!options.loose && version2.includePrerelease === !!options.includePrerelease) { - return version2; + if (version3 instanceof _SemVer) { + if (version3.loose === !!options.loose && version3.includePrerelease === !!options.includePrerelease) { + return version3; } else { - version2 = version2.version; + version3 = version3.version; } - } else if (typeof version2 !== "string") { - throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version2}".`); + } else if (typeof version3 !== "string") { + throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version3}".`); } - if (version2.length > MAX_LENGTH) { + if (version3.length > MAX_LENGTH) { throw new TypeError( `version is longer than ${MAX_LENGTH} characters` ); } - debug2("SemVer", version2, options); + debug2("SemVer", version3, options); this.options = options; this.loose = !!options.loose; this.includePrerelease = !!options.includePrerelease; - const m = version2.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]); + const m = version3.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]); if (!m) { - throw new TypeError(`Invalid Version: ${version2}`); + throw new TypeError(`Invalid Version: ${version3}`); } - this.raw = version2; + this.raw = version3; this.major = +m[1]; this.minor = +m[2]; this.patch = +m[3]; @@ -1443,34 +1496,34 @@ var require_semver = __commonJS({ } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/compare.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/compare.js var require_compare = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/compare.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/compare.js"(exports2, module2) { var SemVer3 = require_semver(); var compare = (a, b, loose) => new SemVer3(a, loose).compare(new SemVer3(b, loose)); module2.exports = compare; } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/rcompare.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/rcompare.js var require_rcompare = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/rcompare.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/rcompare.js"(exports2, module2) { var compare = require_compare(); var rcompare = (a, b, loose) => compare(b, a, loose); module2.exports = rcompare; } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/parse.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/parse.js var require_parse = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/parse.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/parse.js"(exports2, module2) { var SemVer3 = require_semver(); - var parse = (version2, options, throwErrors = false) => { - if (version2 instanceof SemVer3) { - return version2; + var parse5 = (version3, options, throwErrors = false) => { + if (version3 instanceof SemVer3) { + return version3; } try { - return new SemVer3(version2, options); + return new SemVer3(version3, options); } catch (er) { if (!throwErrors) { return null; @@ -1478,25 +1531,25 @@ var require_parse = __commonJS({ throw er; } }; - module2.exports = parse; + module2.exports = parse5; } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/valid.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/valid.js var require_valid = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/valid.js"(exports2, module2) { - var parse = require_parse(); - var valid = (version2, options) => { - const v = parse(version2, options); + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/valid.js"(exports2, module2) { + var parse5 = require_parse(); + var valid = (version3, options) => { + const v = parse5(version3, options); return v ? v.version : null; }; module2.exports = valid; } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/internal/lrucache.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/internal/lrucache.js var require_lrucache = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/internal/lrucache.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/internal/lrucache.js"(exports2, module2) { var LRUCache = class { constructor() { this.max = 1e3; @@ -1531,63 +1584,63 @@ var require_lrucache = __commonJS({ } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/eq.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/eq.js var require_eq = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/eq.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/eq.js"(exports2, module2) { var compare = require_compare(); var eq = (a, b, loose) => compare(a, b, loose) === 0; module2.exports = eq; } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/neq.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/neq.js var require_neq = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/neq.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/neq.js"(exports2, module2) { var compare = require_compare(); var neq = (a, b, loose) => compare(a, b, loose) !== 0; module2.exports = neq; } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/gt.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/gt.js var require_gt = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/gt.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/gt.js"(exports2, module2) { var compare = require_compare(); var gt = (a, b, loose) => compare(a, b, loose) > 0; module2.exports = gt; } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/gte.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/gte.js var require_gte = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/gte.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/gte.js"(exports2, module2) { var compare = require_compare(); var gte = (a, b, loose) => compare(a, b, loose) >= 0; module2.exports = gte; } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/lt.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/lt.js var require_lt = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/lt.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/lt.js"(exports2, module2) { var compare = require_compare(); var lt = (a, b, loose) => compare(a, b, loose) < 0; module2.exports = lt; } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/lte.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/lte.js var require_lte = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/lte.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/lte.js"(exports2, module2) { var compare = require_compare(); var lte = (a, b, loose) => compare(a, b, loose) <= 0; module2.exports = lte; } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/cmp.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/cmp.js var require_cmp = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/cmp.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/cmp.js"(exports2, module2) { var eq = require_eq(); var neq = require_neq(); var gt = require_gt(); @@ -1634,9 +1687,9 @@ var require_cmp = __commonJS({ } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/classes/comparator.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/classes/comparator.js var require_comparator = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/classes/comparator.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/classes/comparator.js"(exports2, module2) { var ANY = Symbol("SemVer ANY"); var Comparator = class _Comparator { static get ANY() { @@ -1682,19 +1735,19 @@ var require_comparator = __commonJS({ toString() { return this.value; } - test(version2) { - debug2("Comparator.test", version2, this.options.loose); - if (this.semver === ANY || version2 === ANY) { + test(version3) { + debug2("Comparator.test", version3, this.options.loose); + if (this.semver === ANY || version3 === ANY) { return true; } - if (typeof version2 === "string") { + if (typeof version3 === "string") { try { - version2 = new SemVer3(version2, this.options); + version3 = new SemVer3(version3, this.options); } catch (er) { return false; } } - return cmp(version2, this.operator, this.semver, this.options); + return cmp(version3, this.operator, this.semver, this.options); } intersects(comp, options) { if (!(comp instanceof _Comparator)) { @@ -1746,9 +1799,10 @@ var require_comparator = __commonJS({ } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/classes/range.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/classes/range.js var require_range = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/classes/range.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/classes/range.js"(exports2, module2) { + var SPACE_CHARACTERS = /\s+/g; var Range3 = class _Range { constructor(range, options) { options = parseOptions(options); @@ -1762,13 +1816,13 @@ var require_range = __commonJS({ if (range instanceof Comparator) { this.raw = range.value; this.set = [[range]]; - this.format(); + this.formatted = void 0; return this; } this.options = options; this.loose = !!options.loose; this.includePrerelease = !!options.includePrerelease; - this.raw = range.trim().split(/\s+/).join(" "); + this.raw = range.trim().replace(SPACE_CHARACTERS, " "); this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length); if (!this.set.length) { throw new TypeError(`Invalid SemVer Range: ${this.raw}`); @@ -1787,10 +1841,27 @@ var require_range = __commonJS({ } } } - this.format(); + this.formatted = void 0; + } + get range() { + if (this.formatted === void 0) { + this.formatted = ""; + for (let i = 0; i < this.set.length; i++) { + if (i > 0) { + this.formatted += "||"; + } + const comps = this.set[i]; + for (let k = 0; k < comps.length; k++) { + if (k > 0) { + this.formatted += " "; + } + this.formatted += comps[k].toString().trim(); + } + } + } + return this.formatted; } format() { - this.range = this.set.map((comps) => comps.join(" ").trim()).join("||").trim(); return this.range; } toString() { @@ -1851,19 +1922,19 @@ var require_range = __commonJS({ }); } // if ANY of the sets match ALL of its comparators, then pass - test(version2) { - if (!version2) { + test(version3) { + if (!version3) { return false; } - if (typeof version2 === "string") { + if (typeof version3 === "string") { try { - version2 = new SemVer3(version2, this.options); + version3 = new SemVer3(version3, this.options); } catch (er) { return false; } } for (let i = 0; i < this.set.length; i++) { - if (testSet(this.set[i], version2, this.options)) { + if (testSet(this.set[i], version3, this.options)) { return true; } } @@ -2077,13 +2148,13 @@ var require_range = __commonJS({ } return `${from} ${to}`.trim(); }; - var testSet = (set, version2, options) => { + var testSet = (set, version3, options) => { for (let i = 0; i < set.length; i++) { - if (!set[i].test(version2)) { + if (!set[i].test(version3)) { return false; } } - if (version2.prerelease.length && !options.includePrerelease) { + if (version3.prerelease.length && !options.includePrerelease) { for (let i = 0; i < set.length; i++) { debug2(set[i].semver); if (set[i].semver === Comparator.ANY) { @@ -2091,7 +2162,7 @@ var require_range = __commonJS({ } if (set[i].semver.prerelease.length > 0) { const allowed = set[i].semver; - if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) { + if (allowed.major === version3.major && allowed.minor === version3.minor && allowed.patch === version3.patch) { return true; } } @@ -2103,9 +2174,9 @@ var require_range = __commonJS({ } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/ranges/valid.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/ranges/valid.js var require_valid2 = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/ranges/valid.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/ranges/valid.js"(exports2, module2) { var Range3 = require_range(); var validRange = (range, options) => { try { @@ -2131,7 +2202,7 @@ var require_ms = __commonJS({ options = options || {}; var type = typeof val; if (type === "string" && val.length > 0) { - return parse(val); + return parse5(val); } else if (type === "number" && isFinite(val)) { return options.long ? fmtLong(val) : fmtShort(val); } @@ -2139,7 +2210,7 @@ var require_ms = __commonJS({ "val is not a non-empty string or a valid number. val=" + JSON.stringify(val) ); }; - function parse(str) { + function parse5(str) { str = String(str); if (str.length > 100) { return; @@ -2227,9 +2298,9 @@ var require_ms = __commonJS({ } return ms + " ms"; } - function plural2(ms, msAbs, n, name) { + function plural2(ms, msAbs, n, name2) { var isPlural = msAbs >= n * 1.5; - return Math.round(ms / n) + " " + name + (isPlural ? "s" : ""); + return Math.round(ms / n) + " " + name2 + (isPlural ? "s" : ""); } } }); @@ -2360,19 +2431,19 @@ var require_common = __commonJS({ createDebug.enable(""); return namespaces; } - function enabled(name) { - if (name[name.length - 1] === "*") { + function enabled(name2) { + if (name2[name2.length - 1] === "*") { return true; } let i; let len; for (i = 0, len = createDebug.skips.length; i < len; i++) { - if (createDebug.skips[i].test(name)) { + if (createDebug.skips[i].test(name2)) { return false; } } for (i = 0, len = createDebug.names.length; i < len; i++) { - if (createDebug.names[i].test(name)) { + if (createDebug.names[i].test(name2)) { return true; } } @@ -2653,10 +2724,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) { return 3; } if ("TERM_PROGRAM" in env) { - const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10); + const version3 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10); switch (env.TERM_PROGRAM) { case "iTerm.app": { - return version2 >= 3 ? 3 : 2; + return version3 >= 3 ? 3 : 2; } case "Apple_Terminal": { return 2; @@ -2702,9 +2773,9 @@ var init_supports_color = __esm({ }); // .yarn/__virtual__/debug-virtual-710203f68e/0/cache/debug-npm-4.3.5-b5001f59b7-082c375a2b.zip/node_modules/debug/src/node.js -var require_node = __commonJS({ +var require_node2 = __commonJS({ ".yarn/__virtual__/debug-virtual-710203f68e/0/cache/debug-npm-4.3.5-b5001f59b7-082c375a2b.zip/node_modules/debug/src/node.js"(exports2, module2) { - var tty3 = require("tty"); + var tty2 = require("tty"); var util = require("util"); exports2.init = init; exports2.log = log2; @@ -2822,18 +2893,18 @@ var require_node = __commonJS({ return obj; }, {}); function useColors() { - return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty3.isatty(process.stderr.fd); + return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty2.isatty(process.stderr.fd); } function formatArgs(args) { - const { namespace: name, useColors: useColors2 } = this; + const { namespace: name2, useColors: useColors2 } = this; if (useColors2) { const c = this.color; const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c); - const prefix = ` ${colorCode};1m${name} \x1B[0m`; + const prefix = ` ${colorCode};1m${name2} \x1B[0m`; args[0] = prefix + args[0].split("\n").join("\n" + prefix); args.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m"); } else { - args[0] = getDate() + name + " " + args[0]; + args[0] = getDate() + name2 + " " + args[0]; } } function getDate() { @@ -2881,7 +2952,7 @@ var require_src = __commonJS({ if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) { module2.exports = require_browser(); } else { - module2.exports = require_node(); + module2.exports = require_node2(); } } }); @@ -3108,10 +3179,10 @@ var require_errors = __commonJS({ } }; var HTTPParserError = class extends Error { - constructor(message, code, data) { + constructor(message, code2, data) { super(message); this.name = "HTTPParserError"; - this.code = code ? `HPE_${code}` : void 0; + this.code = code2 ? `HPE_${code2}` : void 0; this.data = data ? data.toString() : void 0; } }; @@ -3124,12 +3195,12 @@ var require_errors = __commonJS({ } }; var RequestRetryError = class extends UndiciError { - constructor(message, code, { headers, data }) { + constructor(message, code2, { headers, data }) { super(message); this.name = "RequestRetryError"; this.message = message || "Request retry error"; this.code = "UND_ERR_REQ_RETRY"; - this.statusCode = code; + this.statusCode = code2; this.data = data; this.headers = headers; } @@ -3386,8 +3457,8 @@ var require_tree = __commonJS({ if (index === void 0 || index >= key.length) { throw new TypeError("Unreachable"); } - const code = this.code = key.charCodeAt(index); - if (code > 127) { + const code2 = this.code = key.charCodeAt(index); + if (code2 > 127) { throw new TypeError("key must be ascii string"); } if (key.length !== ++index) { @@ -3408,11 +3479,11 @@ var require_tree = __commonJS({ let index = 0; let node = this; while (true) { - const code = key.charCodeAt(index); - if (code > 127) { + const code2 = key.charCodeAt(index); + if (code2 > 127) { throw new TypeError("key must be ascii string"); } - if (node.code === code) { + if (node.code === code2) { if (length === ++index) { node.value = value; break; @@ -3422,7 +3493,7 @@ var require_tree = __commonJS({ node.middle = new _TstNode(key, value, index); break; } - } else if (node.code < code) { + } else if (node.code < code2) { if (node.left !== null) { node = node.left; } else { @@ -3446,19 +3517,19 @@ var require_tree = __commonJS({ let index = 0; let node = this; while (node !== null && index < keylength) { - let code = key[index]; - if (code <= 90 && code >= 65) { - code |= 32; + let code2 = key[index]; + if (code2 <= 90 && code2 >= 65) { + code2 |= 32; } while (node !== null) { - if (code === node.code) { + if (code2 === node.code) { if (keylength === ++index) { return node; } node = node.middle; break; } - node = node.code < code ? node.left : node.right; + node = node.code < code2 ? node.left : node.right; } } return null; @@ -3502,7 +3573,7 @@ var require_tree = __commonJS({ var require_util = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/core/util.js"(exports2, module2) { "use strict"; - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var { kDestroyed, kBodyUsed, kListeners, kBody } = require_symbols(); var { IncomingMessage } = require("node:http"); var stream = require("node:stream"); @@ -3510,7 +3581,7 @@ var require_util = __commonJS({ var { Blob: Blob2 } = require("node:buffer"); var nodeUtil = require("node:util"); var { stringify } = require("node:querystring"); - var { EventEmitter: EE } = require("node:events"); + var { EventEmitter: EE3 } = require("node:events"); var { InvalidArgumentError } = require_errors(); var { headerNameLowerCasedRecord } = require_constants2(); var { tree } = require_tree(); @@ -3521,21 +3592,21 @@ var require_util = __commonJS({ this[kBodyUsed] = false; } async *[Symbol.asyncIterator]() { - assert3(!this[kBodyUsed], "disturbed"); + assert5(!this[kBodyUsed], "disturbed"); this[kBodyUsed] = true; yield* this[kBody]; } }; function wrapRequestBody(body) { - if (isStream(body)) { + if (isStream2(body)) { if (bodyLength(body) === 0) { body.on("data", function() { - assert3(false); + assert5(false); }); } if (typeof body.readableDidRead !== "boolean") { body[kBodyUsed] = false; - EE.prototype.on.call(body, "data", function() { + EE3.prototype.on.call(body, "data", function() { this[kBodyUsed] = true; }); } @@ -3550,7 +3621,7 @@ var require_util = __commonJS({ } function nop() { } - function isStream(obj) { + function isStream2(obj) { return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function"; } function isBlobLike(object) { @@ -3614,14 +3685,14 @@ var require_util = __commonJS({ } const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80; let origin = url.origin != null ? url.origin : `${url.protocol || ""}//${url.hostname || ""}:${port}`; - let path10 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`; + let path16 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`; if (origin[origin.length - 1] === "/") { origin = origin.slice(0, origin.length - 1); } - if (path10 && path10[0] !== "/") { - path10 = `/${path10}`; + if (path16 && path16[0] !== "/") { + path16 = `/${path16}`; } - return new URL(`${origin}${path10}`); + return new URL(`${origin}${path16}`); } if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) { throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`."); @@ -3638,7 +3709,7 @@ var require_util = __commonJS({ function getHostname(host) { if (host[0] === "[") { const idx2 = host.indexOf("]"); - assert3(idx2 !== -1); + assert5(idx2 !== -1); return host.substring(1, idx2); } const idx = host.indexOf(":"); @@ -3649,7 +3720,7 @@ var require_util = __commonJS({ if (!host) { return null; } - assert3.strictEqual(typeof host, "string"); + assert5.strictEqual(typeof host, "string"); const servername = getHostname(host); if (net.isIP(servername)) { return ""; @@ -3668,7 +3739,7 @@ var require_util = __commonJS({ function bodyLength(body) { if (body == null) { return 0; - } else if (isStream(body)) { + } else if (isStream2(body)) { const state = body._readableState; return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null; } else if (isBlobLike(body)) { @@ -3682,7 +3753,7 @@ var require_util = __commonJS({ return body && !!(body.destroyed || body[kDestroyed] || stream.isDestroyed?.(body)); } function destroy(stream2, err) { - if (stream2 == null || !isStream(stream2) || isDestroyed(stream2)) { + if (stream2 == null || !isStream2(stream2) || isDestroyed(stream2)) { return; } if (typeof stream2.destroy === "function") { @@ -3800,7 +3871,7 @@ var require_util = __commonJS({ function isErrored(body) { return !!(body && stream.isErrored(body)); } - function isReadable(body) { + function isReadable2(body) { return !!(body && stream.isReadable(body)); } function getSocketInfo(socket) { @@ -3911,22 +3982,22 @@ var require_util = __commonJS({ size: m[3] ? parseInt(m[3]) : null } : null; } - function addListener(obj, name, listener) { + function addListener(obj, name2, listener) { const listeners = obj[kListeners] ??= []; - listeners.push([name, listener]); - obj.on(name, listener); + listeners.push([name2, listener]); + obj.on(name2, listener); return obj; } function removeAllListeners(obj) { - for (const [name, listener] of obj[kListeners] ?? []) { - obj.removeListener(name, listener); + for (const [name2, listener] of obj[kListeners] ?? []) { + obj.removeListener(name2, listener); } obj[kListeners] = null; } function errorRequest(client, request, err) { try { request.onError(err); - assert3(request.aborted); + assert5(request.aborted); } catch (err2) { client.emit("error", err2); } @@ -3959,14 +4030,14 @@ var require_util = __commonJS({ nop, isDisturbed, isErrored, - isReadable, + isReadable: isReadable2, toUSVString, isUSVString, isBlobLike, parseOrigin, parseURL, getServerName, - isStream, + isStream: isStream2, isIterable, isAsyncIterable, isDestroyed, @@ -4008,7 +4079,7 @@ var require_util = __commonJS({ var require_readable = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/api/readable.js"(exports2, module2) { "use strict"; - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var { Readable: Readable2 } = require("node:stream"); var { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require_errors(); var util = require_util(); @@ -4019,7 +4090,7 @@ var require_readable = __commonJS({ var kAbort = Symbol("kAbort"); var kContentType = Symbol("kContentType"); var kContentLength = Symbol("kContentLength"); - var noop = () => { + var noop2 = () => { }; var BodyReadable = class extends Readable2 { constructor({ @@ -4117,7 +4188,7 @@ var require_readable = __commonJS({ this[kBody] = ReadableStreamFrom(this); if (this[kConsume]) { this[kBody].getReader(); - assert3(this[kBody].locked); + assert5(this[kBody].locked); } } return this[kBody]; @@ -4132,7 +4203,7 @@ var require_readable = __commonJS({ if (this._readableState.closeEmitted) { return null; } - return await new Promise((resolve, reject) => { + return await new Promise((resolve2, reject) => { if (this[kContentLength] > limit) { this.destroy(new AbortError()); } @@ -4145,9 +4216,9 @@ var require_readable = __commonJS({ if (signal?.aborted) { reject(signal.reason ?? new AbortError()); } else { - resolve(null); + resolve2(null); } - }).on("error", noop).on("data", function(chunk) { + }).on("error", noop2).on("data", function(chunk) { limit -= chunk.length; if (limit <= 0) { this.destroy(); @@ -4163,8 +4234,8 @@ var require_readable = __commonJS({ return util.isDisturbed(self2) || isLocked(self2); } async function consume(stream, type) { - assert3(!stream[kConsume]); - return new Promise((resolve, reject) => { + assert5(!stream[kConsume]); + return new Promise((resolve2, reject) => { if (isUnusable(stream)) { const rState = stream._readableState; if (rState.destroyed && rState.closeEmitted === false) { @@ -4181,7 +4252,7 @@ var require_readable = __commonJS({ stream[kConsume] = { type, stream, - resolve, + resolve: resolve2, reject, length: 0, body: [] @@ -4235,22 +4306,22 @@ var require_readable = __commonJS({ return buffer.utf8Slice(start, bufferLength); } function consumeEnd(consume2) { - const { type, body, resolve, stream, length } = consume2; + const { type, body, resolve: resolve2, stream, length } = consume2; try { if (type === "text") { - resolve(chunksDecode(body, length)); + resolve2(chunksDecode(body, length)); } else if (type === "json") { - resolve(JSON.parse(chunksDecode(body, length))); + resolve2(JSON.parse(chunksDecode(body, length))); } else if (type === "arrayBuffer") { const dst = new Uint8Array(length); - let pos = 0; + let pos2 = 0; for (const buf of body) { - dst.set(buf, pos); - pos += buf.byteLength; + dst.set(buf, pos2); + pos2 += buf.byteLength; } - resolve(dst.buffer); + resolve2(dst.buffer); } else if (type === "blob") { - resolve(new Blob(body, { type: stream[kContentType] })); + resolve2(new Blob(body, { type: stream[kContentType] })); } consumeFinish(consume2); } catch (err) { @@ -4284,14 +4355,14 @@ var require_readable = __commonJS({ // .yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/api/util.js var require_util2 = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/api/util.js"(exports2, module2) { - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var { ResponseStatusCodeError } = require_errors(); var { chunksDecode } = require_readable(); var CHUNK_LIMIT = 128 * 1024; async function getResolveErrorBodyCallback({ callback, body, contentType, statusCode, statusMessage, headers }) { - assert3(body); + assert5(body); let chunks = []; let length = 0; try { @@ -4346,7 +4417,7 @@ var require_util2 = __commonJS({ var require_api_request = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/api/api-request.js"(exports2, module2) { "use strict"; - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var { Readable: Readable2 } = require_readable(); var { InvalidArgumentError, RequestAbortedError } = require_errors(); var util = require_util(); @@ -4426,7 +4497,7 @@ var require_api_request = __commonJS({ abort(this.reason); return; } - assert3(this.callback); + assert5(this.callback); this.abort = abort; this.context = context; } @@ -4507,9 +4578,9 @@ var require_api_request = __commonJS({ }; function request(opts, callback) { if (callback === void 0) { - return new Promise((resolve, reject) => { + return new Promise((resolve2, reject) => { request.call(this, opts, (err, data) => { - return err ? reject(err) : resolve(data); + return err ? reject(err) : resolve2(data); }); }); } @@ -4583,7 +4654,7 @@ var require_abort_signal = __commonJS({ var require_api_stream = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/api/api-stream.js"(exports2, module2) { "use strict"; - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var { finished, PassThrough } = require("node:stream"); var { InvalidArgumentError, InvalidReturnValueError } = require_errors(); var util = require_util(); @@ -4642,7 +4713,7 @@ var require_api_stream = __commonJS({ abort(this.reason); return; } - assert3(this.callback); + assert5(this.callback); this.abort = abort; this.context = context; } @@ -4732,9 +4803,9 @@ var require_api_stream = __commonJS({ }; function stream(opts, factory, callback) { if (callback === void 0) { - return new Promise((resolve, reject) => { + return new Promise((resolve2, reject) => { stream.call(this, opts, factory, (err, data) => { - return err ? reject(err) : resolve(data); + return err ? reject(err) : resolve2(data); }); }); } @@ -4769,7 +4840,7 @@ var require_api_pipeline = __commonJS({ var util = require_util(); var { AsyncResource } = require("node:async_hooks"); var { addSignal, removeSignal } = require_abort_signal(); - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var kResume = Symbol("resume"); var PipelineRequest = class extends Readable2 { constructor() { @@ -4873,8 +4944,8 @@ var require_api_pipeline = __commonJS({ abort(this.reason); return; } - assert3(!res, "pipeline cannot be retried"); - assert3(!ret.destroyed); + assert5(!res, "pipeline cannot be retried"); + assert5(!ret.destroyed); this.abort = abort; this.context = context; } @@ -4960,7 +5031,7 @@ var require_api_upgrade = __commonJS({ var { AsyncResource } = require("node:async_hooks"); var util = require_util(); var { addSignal, removeSignal } = require_abort_signal(); - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var UpgradeHandler = class extends AsyncResource { constructor(opts, callback) { if (!opts || typeof opts !== "object") { @@ -4986,7 +5057,7 @@ var require_api_upgrade = __commonJS({ abort(this.reason); return; } - assert3(this.callback); + assert5(this.callback); this.abort = abort; this.context = null; } @@ -4995,7 +5066,7 @@ var require_api_upgrade = __commonJS({ } onUpgrade(statusCode, rawHeaders, socket) { const { callback, opaque, context } = this; - assert3.strictEqual(statusCode, 101); + assert5.strictEqual(statusCode, 101); removeSignal(this); this.callback = null; const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders); @@ -5019,9 +5090,9 @@ var require_api_upgrade = __commonJS({ }; function upgrade(opts, callback) { if (callback === void 0) { - return new Promise((resolve, reject) => { + return new Promise((resolve2, reject) => { upgrade.call(this, opts, (err, data) => { - return err ? reject(err) : resolve(data); + return err ? reject(err) : resolve2(data); }); }); } @@ -5048,7 +5119,7 @@ var require_api_upgrade = __commonJS({ var require_api_connect = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/api/api-connect.js"(exports2, module2) { "use strict"; - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var { AsyncResource } = require("node:async_hooks"); var { InvalidArgumentError, SocketError } = require_errors(); var util = require_util(); @@ -5077,7 +5148,7 @@ var require_api_connect = __commonJS({ abort(this.reason); return; } - assert3(this.callback); + assert5(this.callback); this.abort = abort; this.context = context; } @@ -5113,9 +5184,9 @@ var require_api_connect = __commonJS({ }; function connect(opts, callback) { if (callback === void 0) { - return new Promise((resolve, reject) => { + return new Promise((resolve2, reject) => { connect.call(this, opts, (err, data) => { - return err ? reject(err) : resolve(data); + return err ? reject(err) : resolve2(data); }); }); } @@ -5150,8 +5221,8 @@ var require_api = __commonJS({ var require_dispatcher = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/dispatcher/dispatcher.js"(exports2, module2) { "use strict"; - var EventEmitter = require("node:events"); - var Dispatcher = class extends EventEmitter { + var EventEmitter2 = require("node:events"); + var Dispatcher = class extends EventEmitter2 { dispatch() { throw new Error("not implemented"); } @@ -5245,9 +5316,9 @@ var require_dispatcher_base = __commonJS({ } close(callback) { if (callback === void 0) { - return new Promise((resolve, reject) => { + return new Promise((resolve2, reject) => { this.close((err, data) => { - return err ? reject(err) : resolve(data); + return err ? reject(err) : resolve2(data); }); }); } @@ -5285,12 +5356,12 @@ var require_dispatcher_base = __commonJS({ err = null; } if (callback === void 0) { - return new Promise((resolve, reject) => { + return new Promise((resolve2, reject) => { this.destroy(err, (err2, data) => { return err2 ? ( /* istanbul ignore next: should never error */ reject(err2) - ) : resolve(data); + ) : resolve2(data); }); }); } @@ -5546,8 +5617,8 @@ var require_pool_base = __commonJS({ if (this[kQueue].isEmpty()) { return Promise.all(this[kClients].map((c) => c.close())); } else { - return new Promise((resolve) => { - this[kClosedResolve] = resolve; + return new Promise((resolve2) => { + this[kClosedResolve] = resolve2; }); } } @@ -5639,74 +5710,74 @@ var require_diagnostics = __commonJS({ const debuglog = fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog; diagnosticsChannel.channel("undici:client:beforeConnect").subscribe((evt) => { const { - connectParams: { version: version2, protocol, port, host } + connectParams: { version: version3, protocol, port, host } } = evt; debuglog( "connecting to %s using %s%s", `${host}${port ? `:${port}` : ""}`, protocol, - version2 + version3 ); }); diagnosticsChannel.channel("undici:client:connected").subscribe((evt) => { const { - connectParams: { version: version2, protocol, port, host } + connectParams: { version: version3, protocol, port, host } } = evt; debuglog( "connected to %s using %s%s", `${host}${port ? `:${port}` : ""}`, protocol, - version2 + version3 ); }); diagnosticsChannel.channel("undici:client:connectError").subscribe((evt) => { const { - connectParams: { version: version2, protocol, port, host }, + connectParams: { version: version3, protocol, port, host }, error } = evt; debuglog( "connection to %s using %s%s errored - %s", `${host}${port ? `:${port}` : ""}`, protocol, - version2, + version3, error.message ); }); diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => { const { - request: { method, path: path10, origin } + request: { method, path: path16, origin } } = evt; - debuglog("sending request to %s %s/%s", method, origin, path10); + debuglog("sending request to %s %s/%s", method, origin, path16); }); diagnosticsChannel.channel("undici:request:headers").subscribe((evt) => { const { - request: { method, path: path10, origin }, + request: { method, path: path16, origin }, response: { statusCode } } = evt; debuglog( "received response to %s %s/%s - HTTP %d", method, origin, - path10, + path16, statusCode ); }); diagnosticsChannel.channel("undici:request:trailers").subscribe((evt) => { const { - request: { method, path: path10, origin } + request: { method, path: path16, origin } } = evt; - debuglog("trailers received from %s %s/%s", method, origin, path10); + debuglog("trailers received from %s %s/%s", method, origin, path16); }); diagnosticsChannel.channel("undici:request:error").subscribe((evt) => { const { - request: { method, path: path10, origin }, + request: { method, path: path16, origin }, error } = evt; debuglog( "request to %s %s/%s errored - %s", method, origin, - path10, + path16, error.message ); }); @@ -5717,31 +5788,31 @@ var require_diagnostics = __commonJS({ const debuglog = undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog; diagnosticsChannel.channel("undici:client:beforeConnect").subscribe((evt) => { const { - connectParams: { version: version2, protocol, port, host } + connectParams: { version: version3, protocol, port, host } } = evt; debuglog( "connecting to %s%s using %s%s", host, port ? `:${port}` : "", protocol, - version2 + version3 ); }); diagnosticsChannel.channel("undici:client:connected").subscribe((evt) => { const { - connectParams: { version: version2, protocol, port, host } + connectParams: { version: version3, protocol, port, host } } = evt; debuglog( "connected to %s%s using %s%s", host, port ? `:${port}` : "", protocol, - version2 + version3 ); }); diagnosticsChannel.channel("undici:client:connectError").subscribe((evt) => { const { - connectParams: { version: version2, protocol, port, host }, + connectParams: { version: version3, protocol, port, host }, error } = evt; debuglog( @@ -5749,15 +5820,15 @@ var require_diagnostics = __commonJS({ host, port ? `:${port}` : "", protocol, - version2, + version3, error.message ); }); diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => { const { - request: { method, path: path10, origin } + request: { method, path: path16, origin } } = evt; - debuglog("sending request to %s %s/%s", method, origin, path10); + debuglog("sending request to %s %s/%s", method, origin, path16); }); } diagnosticsChannel.channel("undici:websocket:open").subscribe((evt) => { @@ -5767,11 +5838,11 @@ var require_diagnostics = __commonJS({ websocketDebuglog("connection opened %s%s", address, port ? `:${port}` : ""); }); diagnosticsChannel.channel("undici:websocket:close").subscribe((evt) => { - const { websocket, code, reason } = evt; + const { websocket, code: code2, reason } = evt; websocketDebuglog( "closed connection to %s - %s %s", websocket.url, - code, + code2, reason ); }); @@ -5799,11 +5870,11 @@ var require_request = __commonJS({ InvalidArgumentError, NotSupportedError } = require_errors(); - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var { isValidHTTPToken, isValidHeaderValue, - isStream, + isStream: isStream2, destroy, isBuffer, isFormDataLike, @@ -5820,7 +5891,7 @@ var require_request = __commonJS({ var kHandler = Symbol("handler"); var Request = class { constructor(origin, { - path: path10, + path: path16, method, body, headers, @@ -5835,11 +5906,11 @@ var require_request = __commonJS({ expectContinue, servername }, handler) { - if (typeof path10 !== "string") { + if (typeof path16 !== "string") { throw new InvalidArgumentError("path must be a string"); - } else if (path10[0] !== "/" && !(path10.startsWith("http://") || path10.startsWith("https://")) && method !== "CONNECT") { + } else if (path16[0] !== "/" && !(path16.startsWith("http://") || path16.startsWith("https://")) && method !== "CONNECT") { throw new InvalidArgumentError("path must be an absolute URL or start with a slash"); - } else if (invalidPathRegex.test(path10)) { + } else if (invalidPathRegex.test(path16)) { throw new InvalidArgumentError("invalid request path"); } if (typeof method !== "string") { @@ -5869,7 +5940,7 @@ var require_request = __commonJS({ this.abort = null; if (body == null) { this.body = null; - } else if (isStream(body)) { + } else if (isStream2(body)) { this.body = body; const rState = this.body._readableState; if (!rState || !rState.autoDestroy) { @@ -5902,7 +5973,7 @@ var require_request = __commonJS({ this.completed = false; this.aborted = false; this.upgrade = upgrade || null; - this.path = query ? buildURL(path10, query) : path10; + this.path = query ? buildURL(path16, query) : path16; this.origin = origin; this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent; this.blocking = blocking == null ? false : blocking; @@ -5965,8 +6036,8 @@ var require_request = __commonJS({ } } onConnect(abort) { - assert3(!this.aborted); - assert3(!this.completed); + assert5(!this.aborted); + assert5(!this.completed); if (this.error) { abort(this.error); } else { @@ -5978,8 +6049,8 @@ var require_request = __commonJS({ return this[kHandler].onResponseStarted?.(); } onHeaders(statusCode, headers, resume, statusText) { - assert3(!this.aborted); - assert3(!this.completed); + assert5(!this.aborted); + assert5(!this.completed); if (channels.headers.hasSubscribers) { channels.headers.publish({ request: this, response: { statusCode, headers, statusText } }); } @@ -5990,8 +6061,8 @@ var require_request = __commonJS({ } } onData(chunk) { - assert3(!this.aborted); - assert3(!this.completed); + assert5(!this.aborted); + assert5(!this.completed); try { return this[kHandler].onData(chunk); } catch (err) { @@ -6000,13 +6071,13 @@ var require_request = __commonJS({ } } onUpgrade(statusCode, headers, socket) { - assert3(!this.aborted); - assert3(!this.completed); + assert5(!this.aborted); + assert5(!this.completed); return this[kHandler].onUpgrade(statusCode, headers, socket); } onComplete(trailers) { this.onFinally(); - assert3(!this.aborted); + assert5(!this.aborted); this.completed = true; if (channels.trailers.hasSubscribers) { channels.trailers.publish({ request: this, trailers }); @@ -6120,7 +6191,7 @@ var require_connect = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/core/connect.js"(exports2, module2) { "use strict"; var net = require("node:net"); - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var util = require_util(); var { InvalidArgumentError, ConnectTimeoutError } = require_errors(); var tls; @@ -6190,7 +6261,7 @@ var require_connect = __commonJS({ servername = servername || options.servername || util.getServerName(host) || null; const sessionKey = servername || hostname; const session = customSession || sessionCache.get(sessionKey) || null; - assert3(sessionKey); + assert5(sessionKey); socket = tls.connect({ highWaterMark: 16384, // TLS in node can't have bigger HWM anyway... @@ -6209,7 +6280,7 @@ var require_connect = __commonJS({ sessionCache.set(sessionKey, session2); }); } else { - assert3(!httpSocket, "httpSocket can only be sent on TLS update"); + assert5(!httpSocket, "httpSocket can only be sent on TLS update"); socket = net.connect({ highWaterMark: 64 * 1024, // Same as nodejs fs streams. @@ -6385,34 +6456,34 @@ var require_constants3 = __commonJS({ Object.defineProperty(exports2, "__esModule", { value: true }); exports2.SPECIAL_HEADERS = exports2.HEADER_STATE = exports2.MINOR = exports2.MAJOR = exports2.CONNECTION_TOKEN_CHARS = exports2.HEADER_CHARS = exports2.TOKEN = exports2.STRICT_TOKEN = exports2.HEX = exports2.URL_CHAR = exports2.STRICT_URL_CHAR = exports2.USERINFO_CHARS = exports2.MARK = exports2.ALPHANUM = exports2.NUM = exports2.HEX_MAP = exports2.NUM_MAP = exports2.ALPHA = exports2.FINISH = exports2.H_METHOD_MAP = exports2.METHOD_MAP = exports2.METHODS_RTSP = exports2.METHODS_ICE = exports2.METHODS_HTTP = exports2.METHODS = exports2.LENIENT_FLAGS = exports2.FLAGS = exports2.TYPE = exports2.ERROR = void 0; var utils_1 = require_utils(); - var ERROR; - (function(ERROR2) { - ERROR2[ERROR2["OK"] = 0] = "OK"; - ERROR2[ERROR2["INTERNAL"] = 1] = "INTERNAL"; - ERROR2[ERROR2["STRICT"] = 2] = "STRICT"; - ERROR2[ERROR2["LF_EXPECTED"] = 3] = "LF_EXPECTED"; - ERROR2[ERROR2["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH"; - ERROR2[ERROR2["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION"; - ERROR2[ERROR2["INVALID_METHOD"] = 6] = "INVALID_METHOD"; - ERROR2[ERROR2["INVALID_URL"] = 7] = "INVALID_URL"; - ERROR2[ERROR2["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT"; - ERROR2[ERROR2["INVALID_VERSION"] = 9] = "INVALID_VERSION"; - ERROR2[ERROR2["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN"; - ERROR2[ERROR2["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH"; - ERROR2[ERROR2["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE"; - ERROR2[ERROR2["INVALID_STATUS"] = 13] = "INVALID_STATUS"; - ERROR2[ERROR2["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE"; - ERROR2[ERROR2["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING"; - ERROR2[ERROR2["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN"; - ERROR2[ERROR2["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE"; - ERROR2[ERROR2["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE"; - ERROR2[ERROR2["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER"; - ERROR2[ERROR2["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE"; - ERROR2[ERROR2["PAUSED"] = 21] = "PAUSED"; - ERROR2[ERROR2["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE"; - ERROR2[ERROR2["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE"; - ERROR2[ERROR2["USER"] = 24] = "USER"; - })(ERROR = exports2.ERROR || (exports2.ERROR = {})); + var ERROR2; + (function(ERROR3) { + ERROR3[ERROR3["OK"] = 0] = "OK"; + ERROR3[ERROR3["INTERNAL"] = 1] = "INTERNAL"; + ERROR3[ERROR3["STRICT"] = 2] = "STRICT"; + ERROR3[ERROR3["LF_EXPECTED"] = 3] = "LF_EXPECTED"; + ERROR3[ERROR3["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH"; + ERROR3[ERROR3["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION"; + ERROR3[ERROR3["INVALID_METHOD"] = 6] = "INVALID_METHOD"; + ERROR3[ERROR3["INVALID_URL"] = 7] = "INVALID_URL"; + ERROR3[ERROR3["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT"; + ERROR3[ERROR3["INVALID_VERSION"] = 9] = "INVALID_VERSION"; + ERROR3[ERROR3["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN"; + ERROR3[ERROR3["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH"; + ERROR3[ERROR3["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE"; + ERROR3[ERROR3["INVALID_STATUS"] = 13] = "INVALID_STATUS"; + ERROR3[ERROR3["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE"; + ERROR3[ERROR3["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING"; + ERROR3[ERROR3["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN"; + ERROR3[ERROR3["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE"; + ERROR3[ERROR3["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE"; + ERROR3[ERROR3["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER"; + ERROR3[ERROR3["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE"; + ERROR3[ERROR3["PAUSED"] = 21] = "PAUSED"; + ERROR3[ERROR3["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE"; + ERROR3[ERROR3["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE"; + ERROR3[ERROR3["USER"] = 24] = "USER"; + })(ERROR2 = exports2.ERROR || (exports2.ERROR = {})); var TYPE; (function(TYPE2) { TYPE2[TYPE2["BOTH"] = 0] = "BOTH"; @@ -6703,8 +6774,8 @@ var require_constants3 = __commonJS({ var require_llhttp_wasm = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/llhttp/llhttp-wasm.js"(exports2, module2) { "use strict"; - var { Buffer: Buffer2 } = require("node:buffer"); - module2.exports = Buffer2.from("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", "base64"); + var { Buffer: Buffer3 } = require("node:buffer"); + module2.exports = Buffer3.from("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", "base64"); } }); @@ -6712,8 +6783,8 @@ var require_llhttp_wasm = __commonJS({ var require_llhttp_simd_wasm = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/llhttp/llhttp_simd-wasm.js"(exports2, module2) { "use strict"; - var { Buffer: Buffer2 } = require("node:buffer"); - module2.exports = Buffer2.from("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", "base64"); + var { Buffer: Buffer3 } = require("node:buffer"); + module2.exports = Buffer3.from("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", "base64"); } }); @@ -6933,14 +7004,14 @@ var require_global = __commonJS({ var require_data_url = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/web/fetch/data-url.js"(exports2, module2) { "use strict"; - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var encoder = new TextEncoder(); var HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+\-.^_|~A-Za-z0-9]+$/; var HTTP_WHITESPACE_REGEX = /[\u000A\u000D\u0009\u0020]/; var ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g; var HTTP_QUOTED_STRING_TOKENS = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/; function dataURLProcessor(dataURL) { - assert3(dataURL.protocol === "data:"); + assert5(dataURL.protocol === "data:"); let input = URLSerializer(dataURL, true); input = input.slice(5); const position = { position: 0 }; @@ -7141,7 +7212,7 @@ var require_data_url = __commonJS({ function collectAnHTTPQuotedString(input, position, extractValue) { const positionStart = position.position; let value = ""; - assert3(input[position.position] === '"'); + assert5(input[position.position] === '"'); position.position++; while (true) { value += collectASequenceOfCodePoints( @@ -7162,7 +7233,7 @@ var require_data_url = __commonJS({ value += input[position.position]; position.position++; } else { - assert3(quoteOrBackslash === '"'); + assert5(quoteOrBackslash === '"'); break; } } @@ -7172,12 +7243,12 @@ var require_data_url = __commonJS({ return input.slice(positionStart, position.position); } function serializeAMimeType(mimeType) { - assert3(mimeType !== "failure"); + assert5(mimeType !== "failure"); const { parameters, essence } = mimeType; let serialization = essence; - for (let [name, value] of parameters.entries()) { + for (let [name2, value] of parameters.entries()) { serialization += ";"; - serialization += name; + serialization += name2; serialization += "="; if (!HTTP_TOKEN_CODEPOINTS.test(value)) { value = value.replace(/(\\|")/g, "\\$1"); @@ -7622,11 +7693,11 @@ var require_webidl = __commonJS({ } return V; }; - webidl.converters.TypedArray = function(V, T, prefix, name, opts) { + webidl.converters.TypedArray = function(V, T, prefix, name2, opts) { if (webidl.util.Type(V) !== "Object" || !types.isTypedArray(V) || V.constructor.name !== T.name) { throw webidl.errors.conversionFailed({ prefix, - argument: `${name} ("${webidl.util.Stringify(V)}")`, + argument: `${name2} ("${webidl.util.Stringify(V)}")`, types: [T.name] }); } @@ -7644,11 +7715,11 @@ var require_webidl = __commonJS({ } return V; }; - webidl.converters.DataView = function(V, prefix, name, opts) { + webidl.converters.DataView = function(V, prefix, name2, opts) { if (webidl.util.Type(V) !== "Object" || !types.isDataView(V)) { throw webidl.errors.exception({ header: prefix, - message: `${name} is not a DataView.` + message: `${name2} is not a DataView.` }); } if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) { @@ -7665,19 +7736,19 @@ var require_webidl = __commonJS({ } return V; }; - webidl.converters.BufferSource = function(V, prefix, name, opts) { + webidl.converters.BufferSource = function(V, prefix, name2, opts) { if (types.isAnyArrayBuffer(V)) { - return webidl.converters.ArrayBuffer(V, prefix, name, { ...opts, allowShared: false }); + return webidl.converters.ArrayBuffer(V, prefix, name2, { ...opts, allowShared: false }); } if (types.isTypedArray(V)) { - return webidl.converters.TypedArray(V, V.constructor, prefix, name, { ...opts, allowShared: false }); + return webidl.converters.TypedArray(V, V.constructor, prefix, name2, { ...opts, allowShared: false }); } if (types.isDataView(V)) { - return webidl.converters.DataView(V, prefix, name, { ...opts, allowShared: false }); + return webidl.converters.DataView(V, prefix, name2, { ...opts, allowShared: false }); } throw webidl.errors.conversionFailed({ prefix, - argument: `${name} ("${webidl.util.Stringify(V)}")`, + argument: `${name2} ("${webidl.util.Stringify(V)}")`, types: ["BufferSource"] }); }; @@ -7708,7 +7779,7 @@ var require_util3 = __commonJS({ var { collectASequenceOfCodePoints, collectAnHTTPQuotedString, removeChars, parseMIMEType } = require_data_url(); var { performance } = require("node:perf_hooks"); var { isBlobLike, ReadableStreamFrom, isValidHTTPToken, normalizedMethodRecordsBase } = require_util(); - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var { isUint8Array } = require("node:util/types"); var { webidl } = require_webidl(); var supportedHashes = []; @@ -7742,9 +7813,9 @@ var require_util3 = __commonJS({ } function isValidEncodedURL(url) { for (let i = 0; i < url.length; ++i) { - const code = url.charCodeAt(i); - if (code > 126 || // Non-US-ASCII + DEL - code < 32) { + const code2 = url.charCodeAt(i); + if (code2 > 126 || // Non-US-ASCII + DEL + code2 < 32) { return false; } } @@ -7894,7 +7965,7 @@ var require_util3 = __commonJS({ } function determineRequestsReferrer(request) { const policy = request.referrerPolicy; - assert3(policy); + assert5(policy); let referrerSource = null; if (request.referrer === "client") { const globalOrigin = getGlobalOrigin(); @@ -7938,7 +8009,7 @@ var require_util3 = __commonJS({ } } function stripURLForReferrer(url, originOnly) { - assert3(url instanceof URL); + assert5(url instanceof URL); url = new URL(url); if (url.protocol === "file:" || url.protocol === "about:" || url.protocol === "blank:") { return "no-referrer"; @@ -8046,13 +8117,13 @@ var require_util3 = __commonJS({ if (metadataList.length === 1) { return metadataList; } - let pos = 0; + let pos2 = 0; for (let i = 0; i < metadataList.length; ++i) { if (metadataList[i].algo === algorithm) { - metadataList[pos++] = metadataList[i]; + metadataList[pos2++] = metadataList[i]; } } - metadataList.length = pos; + metadataList.length = pos2; return metadataList; } function compareBase64Mixed(actualValue, expectedValue) { @@ -8083,8 +8154,8 @@ var require_util3 = __commonJS({ function createDeferredPromise() { let res; let rej; - const promise = new Promise((resolve, reject) => { - res = resolve; + const promise = new Promise((resolve2, reject) => { + res = resolve2; rej = reject; }); return { promise, resolve: res, reject: rej }; @@ -8103,11 +8174,11 @@ var require_util3 = __commonJS({ if (result === void 0) { throw new TypeError("Value is not JSON serializable"); } - assert3(typeof result === "string"); + assert5(typeof result === "string"); return result; } var esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())); - function createIterator(name, kInternalIterator, keyIndex = 0, valueIndex = 1) { + function createIterator(name2, kInternalIterator, keyIndex = 0, valueIndex = 1) { class FastIterableIterator { /** @type {any} */ #target; @@ -8128,7 +8199,7 @@ var require_util3 = __commonJS({ next() { if (typeof this !== "object" || this === null || !(#target in this)) { throw new TypeError( - `'next' called on an object that does not implement interface ${name} Iterator.` + `'next' called on an object that does not implement interface ${name2} Iterator.` ); } const index = this.#index; @@ -8167,7 +8238,7 @@ var require_util3 = __commonJS({ writable: false, enumerable: false, configurable: true, - value: `${name} Iterator` + value: `${name2} Iterator` }, next: { writable: true, enumerable: true, configurable: true } }); @@ -8175,8 +8246,8 @@ var require_util3 = __commonJS({ return new FastIterableIterator(target, kind); }; } - function iteratorMixin(name, object, kInternalIterator, keyIndex = 0, valueIndex = 1) { - const makeIterator = createIterator(name, kInternalIterator, keyIndex, valueIndex); + function iteratorMixin(name2, object, kInternalIterator, keyIndex = 0, valueIndex = 1) { + const makeIterator = createIterator(name2, kInternalIterator, keyIndex, valueIndex); const properties = { keys: { writable: true, @@ -8211,10 +8282,10 @@ var require_util3 = __commonJS({ configurable: true, value: function forEach(callbackfn, thisArg = globalThis) { webidl.brandCheck(this, object); - webidl.argumentLengthCheck(arguments, 1, `${name}.forEach`); + webidl.argumentLengthCheck(arguments, 1, `${name2}.forEach`); if (typeof callbackfn !== "function") { throw new TypeError( - `Failed to execute 'forEach' on '${name}': parameter 1 is not of type 'Function'.` + `Failed to execute 'forEach' on '${name2}': parameter 1 is not of type 'Function'.` ); } for (const { 0: key, 1: value } of makeIterator(this, "key+value")) { @@ -8264,7 +8335,7 @@ var require_util3 = __commonJS({ } var invalidIsomorphicEncodeValueRegex = /[^\x00-\xFF]/; function isomorphicEncode(input) { - assert3(!invalidIsomorphicEncodeValueRegex.test(input)); + assert5(!invalidIsomorphicEncodeValueRegex.test(input)); return input; } async function readAllBytes(reader) { @@ -8283,7 +8354,7 @@ var require_util3 = __commonJS({ } } function urlIsLocal(url) { - assert3("protocol" in url); + assert5("protocol" in url); const protocol = url.protocol; return protocol === "about:" || protocol === "blob:" || protocol === "data:"; } @@ -8291,7 +8362,7 @@ var require_util3 = __commonJS({ return typeof url === "string" && url[5] === ":" && url[0] === "h" && url[1] === "t" && url[2] === "t" && url[3] === "p" && url[4] === "s" || url.protocol === "https:"; } function urlIsHttpHttpsScheme(url) { - assert3("protocol" in url); + assert5("protocol" in url); const protocol = url.protocol; return protocol === "http:" || protocol === "https:"; } @@ -8321,8 +8392,8 @@ var require_util3 = __commonJS({ } const rangeStart = collectASequenceOfCodePoints( (char) => { - const code = char.charCodeAt(0); - return code >= 48 && code <= 57; + const code2 = char.charCodeAt(0); + return code2 >= 48 && code2 <= 57; }, data, position @@ -8348,8 +8419,8 @@ var require_util3 = __commonJS({ } const rangeEnd = collectASequenceOfCodePoints( (char) => { - const code = char.charCodeAt(0); - return code >= 48 && code <= 57; + const code2 = char.charCodeAt(0); + return code2 >= 48 && code2 <= 57; }, data, position @@ -8450,7 +8521,7 @@ var require_util3 = __commonJS({ continue; } } else { - assert3(input.charCodeAt(position.position) === 44); + assert5(input.charCodeAt(position.position) === 44); position.position++; } } @@ -8460,8 +8531,8 @@ var require_util3 = __commonJS({ } return values; } - function getDecodeSplit(name, list) { - const value = list.get(name, true); + function getDecodeSplit(name2, list2) { + const value = list2.get(name2, true); if (value === null) { return null; } @@ -8647,7 +8718,7 @@ var require_formdata = __commonJS({ } this[kState] = []; } - append(name, value, filename = void 0) { + append(name2, value, filename = void 0) { webidl.brandCheck(this, _FormData); const prefix = "FormData.append"; webidl.argumentLengthCheck(arguments, 2, prefix); @@ -8656,45 +8727,45 @@ var require_formdata = __commonJS({ "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'" ); } - name = webidl.converters.USVString(name, prefix, "name"); + name2 = webidl.converters.USVString(name2, prefix, "name"); value = isBlobLike(value) ? webidl.converters.Blob(value, prefix, "value", { strict: false }) : webidl.converters.USVString(value, prefix, "value"); filename = arguments.length === 3 ? webidl.converters.USVString(filename, prefix, "filename") : void 0; - const entry = makeEntry(name, value, filename); + const entry = makeEntry(name2, value, filename); this[kState].push(entry); } - delete(name) { + delete(name2) { webidl.brandCheck(this, _FormData); const prefix = "FormData.delete"; webidl.argumentLengthCheck(arguments, 1, prefix); - name = webidl.converters.USVString(name, prefix, "name"); - this[kState] = this[kState].filter((entry) => entry.name !== name); + name2 = webidl.converters.USVString(name2, prefix, "name"); + this[kState] = this[kState].filter((entry) => entry.name !== name2); } - get(name) { + get(name2) { webidl.brandCheck(this, _FormData); const prefix = "FormData.get"; webidl.argumentLengthCheck(arguments, 1, prefix); - name = webidl.converters.USVString(name, prefix, "name"); - const idx = this[kState].findIndex((entry) => entry.name === name); + name2 = webidl.converters.USVString(name2, prefix, "name"); + const idx = this[kState].findIndex((entry) => entry.name === name2); if (idx === -1) { return null; } return this[kState][idx].value; } - getAll(name) { + getAll(name2) { webidl.brandCheck(this, _FormData); const prefix = "FormData.getAll"; webidl.argumentLengthCheck(arguments, 1, prefix); - name = webidl.converters.USVString(name, prefix, "name"); - return this[kState].filter((entry) => entry.name === name).map((entry) => entry.value); + name2 = webidl.converters.USVString(name2, prefix, "name"); + return this[kState].filter((entry) => entry.name === name2).map((entry) => entry.value); } - has(name) { + has(name2) { webidl.brandCheck(this, _FormData); const prefix = "FormData.has"; webidl.argumentLengthCheck(arguments, 1, prefix); - name = webidl.converters.USVString(name, prefix, "name"); - return this[kState].findIndex((entry) => entry.name === name) !== -1; + name2 = webidl.converters.USVString(name2, prefix, "name"); + return this[kState].findIndex((entry) => entry.name === name2) !== -1; } - set(name, value, filename = void 0) { + set(name2, value, filename = void 0) { webidl.brandCheck(this, _FormData); const prefix = "FormData.set"; webidl.argumentLengthCheck(arguments, 2, prefix); @@ -8703,16 +8774,16 @@ var require_formdata = __commonJS({ "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'" ); } - name = webidl.converters.USVString(name, prefix, "name"); + name2 = webidl.converters.USVString(name2, prefix, "name"); value = isBlobLike(value) ? webidl.converters.Blob(value, prefix, "name", { strict: false }) : webidl.converters.USVString(value, prefix, "name"); filename = arguments.length === 3 ? webidl.converters.USVString(filename, prefix, "name") : void 0; - const entry = makeEntry(name, value, filename); - const idx = this[kState].findIndex((entry2) => entry2.name === name); + const entry = makeEntry(name2, value, filename); + const idx = this[kState].findIndex((entry2) => entry2.name === name2); if (idx !== -1) { this[kState] = [ ...this[kState].slice(0, idx), entry, - ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name) + ...this[kState].slice(idx + 1).filter((entry2) => entry2.name !== name2) ]; } else { this[kState].push(entry); @@ -8750,7 +8821,7 @@ var require_formdata = __commonJS({ configurable: true } }); - function makeEntry(name, value, filename) { + function makeEntry(name2, value, filename) { if (typeof value === "string") { } else { if (!isFileLike(value)) { @@ -8764,7 +8835,7 @@ var require_formdata = __commonJS({ value = value instanceof NativeFile ? new File([value], filename, options) : new FileLike(value, filename, options); } } - return { name, value }; + return { name: name2, value }; } module2.exports = { FormData, makeEntry }; } @@ -8779,7 +8850,7 @@ var require_formdata_parser = __commonJS({ var { HTTP_TOKEN_CODEPOINTS, isomorphicDecode } = require_data_url(); var { isFileLike } = require_file(); var { makeEntry } = require_formdata(); - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var { File: NodeFile } = require("node:buffer"); var File = globalThis.File ?? NodeFile; var formDataNameBuffer = Buffer.from('form-data; name="'); @@ -8808,7 +8879,7 @@ var require_formdata_parser = __commonJS({ return true; } function multipartFormDataParser(input, mimeType) { - assert3(mimeType !== "failure" && mimeType.essence === "multipart/form-data"); + assert5(mimeType !== "failure" && mimeType.essence === "multipart/form-data"); const boundaryString = mimeType.parameters.get("boundary"); if (boundaryString === void 0) { return "failure"; @@ -8836,7 +8907,7 @@ var require_formdata_parser = __commonJS({ if (result === "failure") { return "failure"; } - let { name, filename, contentType, encoding } = result; + let { name: name2, filename, contentType, encoding } = result; position.position += 2; let body; { @@ -8865,22 +8936,22 @@ var require_formdata_parser = __commonJS({ } else { value = utf8DecodeBytes(Buffer.from(body)); } - assert3(isUSVString(name)); - assert3(typeof value === "string" && isUSVString(value) || isFileLike(value)); - entryList.push(makeEntry(name, value, filename)); + assert5(isUSVString(name2)); + assert5(typeof value === "string" && isUSVString(value) || isFileLike(value)); + entryList.push(makeEntry(name2, value, filename)); } } function parseMultipartFormDataHeaders(input, position) { - let name = null; + let name2 = null; let filename = null; let contentType = null; let encoding = null; while (true) { if (input[position.position] === 13 && input[position.position + 1] === 10) { - if (name === null) { + if (name2 === null) { return "failure"; } - return { name, filename, contentType, encoding }; + return { name: name2, filename, contentType, encoding }; } let headerName = collectASequenceOfBytes( (char) => char !== 10 && char !== 13 && char !== 58, @@ -8902,13 +8973,13 @@ var require_formdata_parser = __commonJS({ ); switch (bufferToLowerCasedHeaderName(headerName)) { case "content-disposition": { - name = filename = null; + name2 = filename = null; if (!bufferStartsWith(input, formDataNameBuffer, position)) { return "failure"; } position.position += 17; - name = parseMultipartFormDataName(input, position); - if (name === null) { + name2 = parseMultipartFormDataName(input, position); + if (name2 === null) { return "failure"; } if (bufferStartsWith(input, filenameBuffer, position)) { @@ -8964,8 +9035,8 @@ var require_formdata_parser = __commonJS({ } } function parseMultipartFormDataName(input, position) { - assert3(input[position.position - 1] === 34); - let name = collectASequenceOfBytes( + assert5(input[position.position - 1] === 34); + let name2 = collectASequenceOfBytes( (char) => char !== 10 && char !== 13 && char !== 34, input, position @@ -8975,8 +9046,8 @@ var require_formdata_parser = __commonJS({ } else { position.position++; } - name = new TextDecoder().decode(name).replace(/%0A/ig, "\n").replace(/%0D/ig, "\r").replace(/%22/g, '"'); - return name; + name2 = new TextDecoder().decode(name2).replace(/%0A/ig, "\n").replace(/%0D/ig, "\r").replace(/%22/g, '"'); + return name2; } function collectASequenceOfBytes(condition, input, position) { let start = position.position; @@ -9033,7 +9104,7 @@ var require_body = __commonJS({ var { kState } = require_symbols2(); var { webidl } = require_webidl(); var { Blob: Blob2 } = require("node:buffer"); - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var { isErrored } = require_util(); var { isArrayBuffer } = require("node:util/types"); var { serializeAMimeType } = require_data_url(); @@ -9059,7 +9130,7 @@ var require_body = __commonJS({ type: "bytes" }); } - assert3(isReadableStreamLike(stream)); + assert5(isReadableStreamLike(stream)); let action = null; let source = null; let length = null; @@ -9084,16 +9155,16 @@ Content-Disposition: form-data`; const rn = new Uint8Array([13, 10]); length = 0; let hasUnknownSizeValue = false; - for (const [name, value] of object) { + for (const [name2, value] of object) { if (typeof value === "string") { - const chunk2 = textEncoder.encode(prefix + `; name="${escape(normalizeLinefeeds(name))}"\r + const chunk2 = textEncoder.encode(prefix + `; name="${escape(normalizeLinefeeds(name2))}"\r \r ${normalizeLinefeeds(value)}\r `); blobParts.push(chunk2); length += chunk2.byteLength; } else { - const chunk2 = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape(value.name)}"` : "") + `\r + const chunk2 = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name2))}"` + (value.name ? `; filename="${escape(value.name)}"` : "") + `\r Content-Type: ${value.type || "application/octet-stream"}\r \r `); @@ -9176,8 +9247,8 @@ Content-Type: ${value.type || "application/octet-stream"}\r } function safelyExtractBody(object, keepalive = false) { if (object instanceof ReadableStream) { - assert3(!util.isDisturbed(object), "The body has already been consumed."); - assert3(!object.locked, "The stream is locked."); + assert5(!util.isDisturbed(object), "The body has already been consumed."); + assert5(!object.locked, "The stream is locked."); } return extractBody(object, keepalive); } @@ -9236,8 +9307,8 @@ Content-Type: ${value.type || "application/octet-stream"}\r case "application/x-www-form-urlencoded": { const entries = new URLSearchParams(value.toString()); const fd = new FormData(); - for (const [name, value2] of entries) { - fd.append(name, value2); + for (const [name2, value2] of entries) { + fd.append(name2, value2); } return fd; } @@ -9308,7 +9379,7 @@ Content-Type: ${value.type || "application/octet-stream"}\r var require_client_h1 = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/dispatcher/client-h1.js"(exports2, module2) { "use strict"; - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var util = require_util(); var { channels } = require_diagnostics(); var timers = require_timers(); @@ -9357,7 +9428,7 @@ var require_client_h1 = __commonJS({ kResume, kHTTPContext } = require_symbols(); - var constants = require_constants3(); + var constants2 = require_constants3(); var EMPTY_BUF = Buffer.alloc(0); var FastBuffer = Buffer[Symbol.species]; var addListener = util.addListener; @@ -9378,35 +9449,35 @@ var require_client_h1 = __commonJS({ return 0; }, wasm_on_status: (p, at, len) => { - assert3.strictEqual(currentParser.ptr, p); + assert5.strictEqual(currentParser.ptr, p); const start = at - currentBufferPtr + currentBufferRef.byteOffset; return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; }, wasm_on_message_begin: (p) => { - assert3.strictEqual(currentParser.ptr, p); + assert5.strictEqual(currentParser.ptr, p); return currentParser.onMessageBegin() || 0; }, wasm_on_header_field: (p, at, len) => { - assert3.strictEqual(currentParser.ptr, p); + assert5.strictEqual(currentParser.ptr, p); const start = at - currentBufferPtr + currentBufferRef.byteOffset; return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; }, wasm_on_header_value: (p, at, len) => { - assert3.strictEqual(currentParser.ptr, p); + assert5.strictEqual(currentParser.ptr, p); const start = at - currentBufferPtr + currentBufferRef.byteOffset; return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; }, wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => { - assert3.strictEqual(currentParser.ptr, p); + assert5.strictEqual(currentParser.ptr, p); return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0; }, wasm_on_body: (p, at, len) => { - assert3.strictEqual(currentParser.ptr, p); + assert5.strictEqual(currentParser.ptr, p); const start = at - currentBufferPtr + currentBufferRef.byteOffset; return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0; }, wasm_on_message_complete: (p) => { - assert3.strictEqual(currentParser.ptr, p); + assert5.strictEqual(currentParser.ptr, p); return currentParser.onMessageComplete() || 0; } /* eslint-enable camelcase */ @@ -9423,11 +9494,11 @@ var require_client_h1 = __commonJS({ var TIMEOUT_HEADERS = 1; var TIMEOUT_BODY = 2; var TIMEOUT_IDLE = 3; - var Parser = class { + var Parser2 = class { constructor(client, socket, { exports: exports3 }) { - assert3(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0); + assert5(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0); this.llhttp = exports3; - this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE); + this.ptr = this.llhttp.llhttp_alloc(constants2.TYPE.RESPONSE); this.client = client; this.socket = socket; this.timeout = null; @@ -9471,10 +9542,10 @@ var require_client_h1 = __commonJS({ if (this.socket.destroyed || !this.paused) { return; } - assert3(this.ptr != null); - assert3(currentParser == null); + assert5(this.ptr != null); + assert5(currentParser == null); this.llhttp.llhttp_resume(this.ptr); - assert3(this.timeoutType === TIMEOUT_BODY); + assert5(this.timeoutType === TIMEOUT_BODY); if (this.timeout) { if (this.timeout.refresh) { this.timeout.refresh(); @@ -9494,9 +9565,9 @@ var require_client_h1 = __commonJS({ } } execute(data) { - assert3(this.ptr != null); - assert3(currentParser == null); - assert3(!this.paused); + assert5(this.ptr != null); + assert5(currentParser == null); + assert5(!this.paused); const { socket, llhttp } = this; if (data.length > currentBufferSize) { if (currentBufferPtr) { @@ -9519,27 +9590,27 @@ var require_client_h1 = __commonJS({ currentBufferRef = null; } const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr; - if (ret === constants.ERROR.PAUSED_UPGRADE) { + if (ret === constants2.ERROR.PAUSED_UPGRADE) { this.onUpgrade(data.slice(offset)); - } else if (ret === constants.ERROR.PAUSED) { + } else if (ret === constants2.ERROR.PAUSED) { this.paused = true; socket.unshift(data.slice(offset)); - } else if (ret !== constants.ERROR.OK) { + } else if (ret !== constants2.ERROR.OK) { const ptr = llhttp.llhttp_get_error_reason(this.ptr); let message = ""; if (ptr) { const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0); message = "Response does not match the HTTP/1.1 protocol (" + Buffer.from(llhttp.memory.buffer, ptr, len).toString() + ")"; } - throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset)); + throw new HTTPParserError(message, constants2.ERROR[ret], data.slice(offset)); } } catch (err) { util.destroy(socket, err); } } destroy() { - assert3(this.ptr != null); - assert3(currentParser == null); + assert5(this.ptr != null); + assert5(currentParser == null); this.llhttp.llhttp_free(this.ptr); this.ptr = null; timers.clearTimeout(this.timeout); @@ -9600,17 +9671,17 @@ var require_client_h1 = __commonJS({ } onUpgrade(head) { const { upgrade, client, socket, headers, statusCode } = this; - assert3(upgrade); + assert5(upgrade); const request = client[kQueue][client[kRunningIdx]]; - assert3(request); - assert3(!socket.destroyed); - assert3(socket === client[kSocket]); - assert3(!this.paused); - assert3(request.upgrade || request.method === "CONNECT"); + assert5(request); + assert5(!socket.destroyed); + assert5(socket === client[kSocket]); + assert5(!this.paused); + assert5(request.upgrade || request.method === "CONNECT"); this.statusCode = null; this.statusText = ""; this.shouldKeepAlive = null; - assert3(this.headers.length % 2 === 0); + assert5(this.headers.length % 2 === 0); this.headers = []; this.headersSize = 0; socket.unshift(head); @@ -9639,8 +9710,8 @@ var require_client_h1 = __commonJS({ if (!request) { return -1; } - assert3(!this.upgrade); - assert3(this.statusCode < 200); + assert5(!this.upgrade); + assert5(this.statusCode < 200); if (statusCode === 100) { util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket))); return -1; @@ -9649,7 +9720,7 @@ var require_client_h1 = __commonJS({ util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket))); return -1; } - assert3.strictEqual(this.timeoutType, TIMEOUT_HEADERS); + assert5.strictEqual(this.timeoutType, TIMEOUT_HEADERS); this.statusCode = statusCode; this.shouldKeepAlive = shouldKeepAlive || // Override llhttp value which does not allow keepAlive for HEAD. request.method === "HEAD" && !socket[kReset] && this.connection.toLowerCase() === "keep-alive"; @@ -9662,16 +9733,16 @@ var require_client_h1 = __commonJS({ } } if (request.method === "CONNECT") { - assert3(client[kRunning] === 1); + assert5(client[kRunning] === 1); this.upgrade = true; return 2; } if (upgrade) { - assert3(client[kRunning] === 1); + assert5(client[kRunning] === 1); this.upgrade = true; return 2; } - assert3(this.headers.length % 2 === 0); + assert5(this.headers.length % 2 === 0); this.headers = []; this.headersSize = 0; if (this.shouldKeepAlive && client[kPipelining]) { @@ -9706,7 +9777,7 @@ var require_client_h1 = __commonJS({ socket[kBlocking] = false; client[kResume](); } - return pause ? constants.ERROR.PAUSED : 0; + return pause ? constants2.ERROR.PAUSED : 0; } onBody(buf) { const { client, socket, statusCode, maxResponseSize } = this; @@ -9714,21 +9785,21 @@ var require_client_h1 = __commonJS({ return -1; } const request = client[kQueue][client[kRunningIdx]]; - assert3(request); - assert3.strictEqual(this.timeoutType, TIMEOUT_BODY); + assert5(request); + assert5.strictEqual(this.timeoutType, TIMEOUT_BODY); if (this.timeout) { if (this.timeout.refresh) { this.timeout.refresh(); } } - assert3(statusCode >= 200); + assert5(statusCode >= 200); if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) { util.destroy(socket, new ResponseExceededMaxSizeError()); return -1; } this.bytesRead += buf.length; if (request.onData(buf) === false) { - return constants.ERROR.PAUSED; + return constants2.ERROR.PAUSED; } } onMessageComplete() { @@ -9740,15 +9811,15 @@ var require_client_h1 = __commonJS({ return; } const request = client[kQueue][client[kRunningIdx]]; - assert3(request); - assert3(statusCode >= 100); + assert5(request); + assert5(statusCode >= 100); this.statusCode = null; this.statusText = ""; this.bytesRead = 0; this.contentLength = ""; this.keepAlive = ""; this.connection = ""; - assert3(this.headers.length % 2 === 0); + assert5(this.headers.length % 2 === 0); this.headers = []; this.headersSize = 0; if (statusCode < 200) { @@ -9761,15 +9832,15 @@ var require_client_h1 = __commonJS({ request.onComplete(headers); client[kQueue][client[kRunningIdx]++] = null; if (socket[kWriting]) { - assert3.strictEqual(client[kRunning], 0); + assert5.strictEqual(client[kRunning], 0); util.destroy(socket, new InformationalError("reset")); - return constants.ERROR.PAUSED; + return constants2.ERROR.PAUSED; } else if (!shouldKeepAlive) { util.destroy(socket, new InformationalError("reset")); - return constants.ERROR.PAUSED; + return constants2.ERROR.PAUSED; } else if (socket[kReset] && client[kRunning] === 0) { util.destroy(socket, new InformationalError("reset")); - return constants.ERROR.PAUSED; + return constants2.ERROR.PAUSED; } else if (client[kPipelining] == null || client[kPipelining] === 1) { setImmediate(() => client[kResume]()); } else { @@ -9781,7 +9852,7 @@ var require_client_h1 = __commonJS({ const { socket, timeoutType, client } = parser; if (timeoutType === TIMEOUT_HEADERS) { if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) { - assert3(!parser.paused, "cannot be paused while waiting for headers"); + assert5(!parser.paused, "cannot be paused while waiting for headers"); util.destroy(socket, new HeadersTimeoutError()); } } else if (timeoutType === TIMEOUT_BODY) { @@ -9789,7 +9860,7 @@ var require_client_h1 = __commonJS({ util.destroy(socket, new BodyTimeoutError()); } } else if (timeoutType === TIMEOUT_IDLE) { - assert3(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]); + assert5(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]); util.destroy(socket, new InformationalError("socket idle timeout")); } } @@ -9803,10 +9874,10 @@ var require_client_h1 = __commonJS({ socket[kWriting] = false; socket[kReset] = false; socket[kBlocking] = false; - socket[kParser] = new Parser(client, socket, llhttpInstance); + socket[kParser] = new Parser2(client, socket, llhttpInstance); addListener(socket, "error", function(err) { const parser = this[kParser]; - assert3(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + assert5(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); if (err.code === "ECONNRESET" && parser.statusCode && !parser.shouldKeepAlive) { parser.onMessageComplete(); return; @@ -9842,7 +9913,7 @@ var require_client_h1 = __commonJS({ client2[kSocket] = null; client2[kHTTPContext] = null; if (client2.destroyed) { - assert3(client2[kPending] === 0); + assert5(client2[kPending] === 0); const requests = client2[kQueue].splice(client2[kRunningIdx]); for (let i = 0; i < requests.length; i++) { const request = requests[i]; @@ -9854,7 +9925,7 @@ var require_client_h1 = __commonJS({ util.errorRequest(client2, request, err); } client2[kPendingIdx] = client2[kRunningIdx]; - assert3(client2[kRunning] === 0); + assert5(client2[kRunning] === 0); client2.emit("disconnect", client2[kUrl], [client2], err); client2[kResume](); }); @@ -9929,7 +10000,7 @@ var require_client_h1 = __commonJS({ return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT"; } function writeH1(client, request) { - const { method, path: path10, host, upgrade, blocking, reset } = request; + const { method, path: path16, host, upgrade, blocking, reset } = request; let { body, headers, contentLength } = request; const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH"; if (util.isFormDataLike(body)) { @@ -9995,7 +10066,7 @@ var require_client_h1 = __commonJS({ if (blocking) { socket[kBlocking] = true; } - let header = `${method} ${path10} HTTP/1.1\r + let header = `${method} ${path16} HTTP/1.1\r `; if (typeof host === "string") { header += `host: ${host}\r @@ -10045,12 +10116,12 @@ upgrade: ${upgrade}\r } else if (util.isIterable(body)) { writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload); } else { - assert3(false); + assert5(false); } return true; } function writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload) { - assert3(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined"); + assert5(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined"); let finished = false; const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header }); const onData = function(chunk) { @@ -10087,7 +10158,7 @@ upgrade: ${upgrade}\r return; } finished = true; - assert3(socket.destroyed || socket[kWriting] && client[kRunning] <= 1); + assert5(socket.destroyed || socket[kWriting] && client[kRunning] <= 1); socket.off("drain", onDrain).off("error", onFinished); body.removeListener("data", onData).removeListener("end", onFinished).removeListener("close", onClose); if (!err) { @@ -10126,12 +10197,12 @@ upgrade: ${upgrade}\r \r `, "latin1"); } else { - assert3(contentLength === null, "no body must not have content length"); + assert5(contentLength === null, "no body must not have content length"); socket.write(`${header}\r `, "latin1"); } } else if (util.isBuffer(body)) { - assert3(contentLength === body.byteLength, "buffer body must have content length"); + assert5(contentLength === body.byteLength, "buffer body must have content length"); socket.cork(); socket.write(`${header}content-length: ${contentLength}\r \r @@ -10150,7 +10221,7 @@ upgrade: ${upgrade}\r } } async function writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload) { - assert3(contentLength === body.size, "blob body must have content length"); + assert5(contentLength === body.size, "blob body must have content length"); try { if (contentLength != null && contentLength !== body.size) { throw new RequestContentLengthMismatchError(); @@ -10173,7 +10244,7 @@ upgrade: ${upgrade}\r } } async function writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload) { - assert3(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined"); + assert5(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined"); let callback = null; function onDrain() { if (callback) { @@ -10182,12 +10253,12 @@ upgrade: ${upgrade}\r cb(); } } - const waitForDrain = () => new Promise((resolve, reject) => { - assert3(callback === null); + const waitForDrain = () => new Promise((resolve2, reject) => { + assert5(callback === null); if (socket[kError]) { reject(socket[kError]); } else { - callback = resolve; + callback = resolve2; } }); socket.on("close", onDrain).on("drain", onDrain); @@ -10310,7 +10381,7 @@ ${len.toString(16)}\r const { socket, client, abort } = this; socket[kWriting] = false; if (err) { - assert3(client[kRunning] <= 1, "pipeline should only contain this request"); + assert5(client[kRunning] <= 1, "pipeline should only contain this request"); abort(err); } } @@ -10323,7 +10394,7 @@ ${len.toString(16)}\r var require_client_h2 = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/dispatcher/client-h2.js"(exports2, module2) { "use strict"; - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var { pipeline } = require("node:stream"); var util = require_util(); var { @@ -10370,13 +10441,13 @@ var require_client_h2 = __commonJS({ } = http2; function parseH2Headers(headers) { const result = []; - for (const [name, value] of Object.entries(headers)) { + for (const [name2, value] of Object.entries(headers)) { if (Array.isArray(value)) { for (const subvalue of value) { - result.push(Buffer.from(name), Buffer.from(subvalue)); + result.push(Buffer.from(name2), Buffer.from(subvalue)); } } else { - result.push(Buffer.from(name), Buffer.from(value)); + result.push(Buffer.from(name2), Buffer.from(value)); } } return result; @@ -10406,7 +10477,7 @@ var require_client_h2 = __commonJS({ const err = this[kSocket][kError] || this[kError] || new SocketError("closed", util.getSocketInfo(socket2)); client2[kHTTP2Session] = null; if (client2.destroyed) { - assert3(client2[kPending] === 0); + assert5(client2[kPending] === 0); const requests = client2[kQueue].splice(client2[kRunningIdx]); for (let i = 0; i < requests.length; i++) { const request = requests[i]; @@ -10418,7 +10489,7 @@ var require_client_h2 = __commonJS({ client[kHTTP2Session] = session; socket[kHTTP2Session] = session; util.addListener(socket, "error", function(err) { - assert3(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + assert5(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); this[kError] = err; this[kClient][kOnError](err); }); @@ -10432,7 +10503,7 @@ var require_client_h2 = __commonJS({ this[kHTTP2Session].destroy(err); } client[kPendingIdx] = client[kRunningIdx]; - assert3(client[kRunning] === 0); + assert5(client[kRunning] === 0); client.emit("disconnect", client[kUrl], [client], err); client[kResume](); }); @@ -10464,13 +10535,13 @@ var require_client_h2 = __commonJS({ }; } function onHttp2SessionError(err) { - assert3(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); + assert5(err.code !== "ERR_TLS_CERT_ALTNAME_INVALID"); this[kSocket][kError] = err; this[kClient][kOnError](err); } - function onHttp2FrameError(type, code, id) { + function onHttp2FrameError(type, code2, id) { if (id === 0) { - const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`); + const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code2}`); this[kSocket][kError] = err; this[kClient][kOnError](err); } @@ -10480,8 +10551,8 @@ var require_client_h2 = __commonJS({ this.destroy(err); util.destroy(this[kSocket], err); } - function onHTTP2GoAway(code) { - const err = new RequestAbortedError(`HTTP/2: "GOAWAY" frame received with code ${code}`); + function onHTTP2GoAway(code2) { + const err = new RequestAbortedError(`HTTP/2: "GOAWAY" frame received with code ${code2}`); this[kSocket][kError] = err; this[kClient][kOnError](err); this.unref(); @@ -10492,7 +10563,7 @@ var require_client_h2 = __commonJS({ } function writeH2(client, request) { const session = client[kHTTP2Session]; - const { body, method, path: path10, host, upgrade, expectContinue, signal, headers: reqHeaders } = request; + const { body, method, path: path16, host, upgrade, expectContinue, signal, headers: reqHeaders } = request; if (upgrade) { util.errorRequest(client, request, new Error("Upgrade not supported for H2")); return false; @@ -10554,7 +10625,7 @@ var require_client_h2 = __commonJS({ }); return true; } - headers[HTTP2_HEADER_PATH] = path10; + headers[HTTP2_HEADER_PATH] = path16; headers[HTTP2_HEADER_SCHEME] = "https"; const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH"; if (body && typeof body.read === "function") { @@ -10575,7 +10646,7 @@ var require_client_h2 = __commonJS({ process.emitWarning(new RequestContentLengthMismatchError()); } if (contentLength != null) { - assert3(body, "no body must not have content length"); + assert5(body, "no body must not have content length"); headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`; } session.ref(); @@ -10629,8 +10700,8 @@ var require_client_h2 = __commonJS({ stream.once("error", function(err) { abort(err); }); - stream.once("frameError", (type, code) => { - abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)); + stream.once("frameError", (type, code2) => { + abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code2}`)); }); return true; function writeBodyH2() { @@ -10703,14 +10774,14 @@ var require_client_h2 = __commonJS({ expectsPayload ); } else { - assert3(false); + assert5(false); } } } function writeBuffer(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) { try { if (body != null && util.isBuffer(body)) { - assert3(contentLength === body.byteLength, "buffer body must have content length"); + assert5(contentLength === body.byteLength, "buffer body must have content length"); h2stream.cork(); h2stream.write(body); h2stream.uncork(); @@ -10727,7 +10798,7 @@ var require_client_h2 = __commonJS({ } } function writeStream(abort, socket, expectsPayload, h2stream, body, client, request, contentLength) { - assert3(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined"); + assert5(contentLength !== 0 || client[kRunning] === 0, "stream body cannot be pipelined"); const pipe = pipeline( body, h2stream, @@ -10751,7 +10822,7 @@ var require_client_h2 = __commonJS({ } } async function writeBlob(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) { - assert3(contentLength === body.size, "blob body must have content length"); + assert5(contentLength === body.size, "blob body must have content length"); try { if (contentLength != null && contentLength !== body.size) { throw new RequestContentLengthMismatchError(); @@ -10772,7 +10843,7 @@ var require_client_h2 = __commonJS({ } } async function writeIterable(abort, h2stream, body, client, request, socket, contentLength, expectsPayload) { - assert3(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined"); + assert5(contentLength !== 0 || client[kRunning] === 0, "iterator body cannot be pipelined"); let callback = null; function onDrain() { if (callback) { @@ -10781,12 +10852,12 @@ var require_client_h2 = __commonJS({ cb(); } } - const waitForDrain = () => new Promise((resolve, reject) => { - assert3(callback === null); + const waitForDrain = () => new Promise((resolve2, reject) => { + assert5(callback === null); if (socket[kError]) { reject(socket[kError]); } else { - callback = resolve; + callback = resolve2; } }); h2stream.on("close", onDrain).on("drain", onDrain); @@ -10823,9 +10894,9 @@ var require_redirect_handler = __commonJS({ "use strict"; var util = require_util(); var { kBodyUsed } = require_symbols(); - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var { InvalidArgumentError } = require_errors(); - var EE = require("node:events"); + var EE3 = require("node:events"); var redirectableStatusCodes = [300, 301, 302, 303, 307, 308]; var kBody = Symbol("body"); var BodyAsyncIterable = class { @@ -10834,7 +10905,7 @@ var require_redirect_handler = __commonJS({ this[kBodyUsed] = false; } async *[Symbol.asyncIterator]() { - assert3(!this[kBodyUsed], "disturbed"); + assert5(!this[kBodyUsed], "disturbed"); this[kBodyUsed] = true; yield* this[kBody]; } @@ -10856,12 +10927,12 @@ var require_redirect_handler = __commonJS({ if (util.isStream(this.opts.body)) { if (util.bodyLength(this.opts.body) === 0) { this.opts.body.on("data", function() { - assert3(false); + assert5(false); }); } if (typeof this.opts.body.readableDidRead !== "boolean") { this.opts.body[kBodyUsed] = false; - EE.prototype.on.call(this.opts.body, "data", function() { + EE3.prototype.on.call(this.opts.body, "data", function() { this[kBodyUsed] = true; }); } @@ -10898,9 +10969,9 @@ var require_redirect_handler = __commonJS({ return this.handler.onHeaders(statusCode, headers, resume, statusText); } const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin))); - const path10 = search ? `${pathname}${search}` : pathname; + const path16 = search ? `${pathname}${search}` : pathname; this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin); - this.opts.path = path10; + this.opts.path = path16; this.opts.origin = origin; this.opts.maxRedirections = 0; this.opts.query = null; @@ -10948,8 +11019,8 @@ var require_redirect_handler = __commonJS({ return true; } if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) { - const name = util.headerNameToString(header); - return name === "authorization" || name === "cookie" || name === "proxy-authorization"; + const name2 = util.headerNameToString(header); + return name2 === "authorization" || name2 === "cookie" || name2 === "proxy-authorization"; } return false; } @@ -10968,7 +11039,7 @@ var require_redirect_handler = __commonJS({ } } } else { - assert3(headers == null, "headers must be an object or an array"); + assert5(headers == null, "headers must be an object or an array"); } return ret; } @@ -11002,7 +11073,7 @@ var require_redirect_interceptor = __commonJS({ var require_client = __commonJS({ ".yarn/cache/undici-npm-6.19.2-a9aa1269bb-3b7b9238c0.zip/node_modules/undici/lib/dispatcher/client.js"(exports2, module2) { "use strict"; - var assert3 = require("node:assert"); + var assert5 = require("node:assert"); var net = require("node:net"); var http = require("node:http"); var util = require_util(); @@ -11261,16 +11332,16 @@ var require_client = __commonJS({ return this[kNeedDrain] < 2; } async [kClose]() { - return new Promise((resolve) => { + return new Promise((resolve2) => { if (this[kSize]) { - this[kClosedResolve] = resolve; + this[kClosedResolve] = resolve2; } else { - resolve(null); + resolve2(null); } }); } async [kDestroy](err) { - return new Promise((resolve) => { + return new Promise((resolve2) => { const requests = this[kQueue].splice(this[kPendingIdx]); for (let i = 0; i < requests.length; i++) { const request = requests[i]; @@ -11281,7 +11352,7 @@ var require_client = __commonJS({ this[kClosedResolve](); this[kClosedResolve] = null; } - resolve(null); + resolve2(null); }; if (this[kHTTPContext]) { this[kHTTPContext].destroy(err, callback); @@ -11296,24 +11367,24 @@ var require_client = __commonJS({ var createRedirectInterceptor = require_redirect_interceptor(); function onError(client, err) { if (client[kRunning] === 0 && err.code !== "UND_ERR_INFO" && err.code !== "UND_ERR_SOCKET") { - assert3(client[kPendingIdx] === client[kRunningIdx]); + assert5(client[kPendingIdx] === client[kRunningIdx]); const requests = client[kQueue].splice(client[kRunningIdx]); for (let i = 0; i < requests.length; i++) { const request = requests[i]; util.errorRequest(client, request, err); } - assert3(client[kSize] === 0); + assert5(client[kSize] === 0); } } async function connect(client) { - assert3(!client[kConnecting]); - assert3(!client[kHTTPContext]); + assert5(!client[kConnecting]); + assert5(!client[kHTTPContext]); let { host, hostname, protocol, port } = client[kUrl]; if (hostname[0] === "[") { const idx = hostname.indexOf("]"); - assert3(idx !== -1); + assert5(idx !== -1); const ip = hostname.substring(1, idx); - assert3(net.isIP(ip)); + assert5(net.isIP(ip)); hostname = ip; } client[kConnecting] = true; @@ -11332,7 +11403,7 @@ var require_client = __commonJS({ }); } try { - const socket = await new Promise((resolve, reject) => { + const socket = await new Promise((resolve2, reject) => { client[kConnector]({ host, hostname, @@ -11344,7 +11415,7 @@ var require_client = __commonJS({ if (err) { reject(err); } else { - resolve(socket2); + resolve2(socket2); } }); }); @@ -11353,7 +11424,7 @@ var require_client = __commonJS({ }), new ClientDestroyedError()); return; } - assert3(socket); + assert5(socket); try { client[kHTTPContext] = socket.alpnProtocol === "h2" ? await connectH2(client, socket) : await connectH1(client, socket); } catch (err) { @@ -11403,7 +11474,7 @@ var require_client = __commonJS({ }); } if (err.code === "ERR_TLS_CERT_ALTNAME_INVALID") { - assert3(client[kRunning] === 0); + assert5(client[kRunning] === 0); while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) { const request = client[kQueue][client[kPendingIdx]++]; util.errorRequest(client, request, err); @@ -11435,7 +11506,7 @@ var require_client = __commonJS({ function _resume(client, sync) { while (true) { if (client.destroyed) { - assert3(client[kPending] === 0); + assert5(client[kPending] === 0); return; } if (client[kClosedResolve] && !client[kSize]) { @@ -11832,106 +11903,84 @@ var require_proxy_agent = __commonJS({ } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/high-level-opt.js -var require_high_level_opt = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/high-level-opt.js"(exports2, module2) { - "use strict"; - var argmap = /* @__PURE__ */ new Map([ - ["C", "cwd"], - ["f", "file"], - ["z", "gzip"], - ["P", "preservePaths"], - ["U", "unlink"], - ["strip-components", "strip"], - ["stripComponents", "strip"], - ["keep-newer", "newer"], - ["keepNewer", "newer"], - ["keep-newer-files", "newer"], - ["keepNewerFiles", "newer"], - ["k", "keep"], - ["keep-existing", "keep"], - ["keepExisting", "keep"], - ["m", "noMtime"], - ["no-mtime", "noMtime"], - ["p", "preserveOwner"], - ["L", "follow"], - ["h", "follow"] - ]); - module2.exports = (opt) => opt ? Object.keys(opt).map((k) => [ - argmap.has(k) ? argmap.get(k) : k, - opt[k] - ]).reduce((set, kv) => (set[kv[0]] = kv[1], set), /* @__PURE__ */ Object.create(null)) : {}; - } -}); - -// .yarn/cache/minipass-npm-5.0.0-c64fb63c92-a91d8043f6.zip/node_modules/minipass/index.js -var require_minipass = __commonJS({ - ".yarn/cache/minipass-npm-5.0.0-c64fb63c92-a91d8043f6.zip/node_modules/minipass/index.js"(exports2) { - "use strict"; - var proc = typeof process === "object" && process ? process : { +// .yarn/cache/minipass-npm-7.1.2-3a5327d36d-b0fd20bb9f.zip/node_modules/minipass/dist/esm/index.js +var import_node_events, import_node_stream, import_node_string_decoder, proc, isStream, isReadable, isWritable, EOF, MAYBE_EMIT_END, EMITTED_END, EMITTING_END, EMITTED_ERROR, CLOSED, READ, FLUSH, FLUSHCHUNK, ENCODING, DECODER, FLOWING, PAUSED, RESUME, BUFFER, PIPES, BUFFERLENGTH, BUFFERPUSH, BUFFERSHIFT, OBJECTMODE, DESTROYED, ERROR, EMITDATA, EMITEND, EMITEND2, ASYNC, ABORT, ABORTED, SIGNAL, DATALISTENERS, DISCARDED, defer, nodefer, isEndish, isArrayBufferLike, isArrayBufferView, Pipe, PipeProxyErrors, isObjectModeOptions, isEncodingOptions, Minipass; +var init_esm = __esm({ + ".yarn/cache/minipass-npm-7.1.2-3a5327d36d-b0fd20bb9f.zip/node_modules/minipass/dist/esm/index.js"() { + import_node_events = require("node:events"); + import_node_stream = __toESM(require("node:stream"), 1); + import_node_string_decoder = require("node:string_decoder"); + proc = typeof process === "object" && process ? process : { stdout: null, stderr: null }; - var EE = require("events"); - var Stream = require("stream"); - var stringdecoder = require("string_decoder"); - var SD = stringdecoder.StringDecoder; - var EOF = Symbol("EOF"); - var MAYBE_EMIT_END = Symbol("maybeEmitEnd"); - var EMITTED_END = Symbol("emittedEnd"); - var EMITTING_END = Symbol("emittingEnd"); - var EMITTED_ERROR = Symbol("emittedError"); - var CLOSED = Symbol("closed"); - var READ = Symbol("read"); - var FLUSH = Symbol("flush"); - var FLUSHCHUNK = Symbol("flushChunk"); - var ENCODING = Symbol("encoding"); - var DECODER = Symbol("decoder"); - var FLOWING = Symbol("flowing"); - var PAUSED = Symbol("paused"); - var RESUME = Symbol("resume"); - var BUFFER = Symbol("buffer"); - var PIPES = Symbol("pipes"); - var BUFFERLENGTH = Symbol("bufferLength"); - var BUFFERPUSH = Symbol("bufferPush"); - var BUFFERSHIFT = Symbol("bufferShift"); - var OBJECTMODE = Symbol("objectMode"); - var DESTROYED = Symbol("destroyed"); - var ERROR = Symbol("error"); - var EMITDATA = Symbol("emitData"); - var EMITEND = Symbol("emitEnd"); - var EMITEND2 = Symbol("emitEnd2"); - var ASYNC = Symbol("async"); - var ABORT = Symbol("abort"); - var ABORTED = Symbol("aborted"); - var SIGNAL = Symbol("signal"); - var defer = (fn2) => Promise.resolve().then(fn2); - var doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== "1"; - var ASYNCITERATOR = doIter && Symbol.asyncIterator || Symbol("asyncIterator not implemented"); - var ITERATOR = doIter && Symbol.iterator || Symbol("iterator not implemented"); - var isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish"; - var isArrayBuffer = (b) => b instanceof ArrayBuffer || typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0; - var isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b); - var Pipe = class { + isStream = (s) => !!s && typeof s === "object" && (s instanceof Minipass || s instanceof import_node_stream.default || isReadable(s) || isWritable(s)); + isReadable = (s) => !!s && typeof s === "object" && s instanceof import_node_events.EventEmitter && typeof s.pipe === "function" && // node core Writable streams have a pipe() method, but it throws + s.pipe !== import_node_stream.default.Writable.prototype.pipe; + isWritable = (s) => !!s && typeof s === "object" && s instanceof import_node_events.EventEmitter && typeof s.write === "function" && typeof s.end === "function"; + EOF = Symbol("EOF"); + MAYBE_EMIT_END = Symbol("maybeEmitEnd"); + EMITTED_END = Symbol("emittedEnd"); + EMITTING_END = Symbol("emittingEnd"); + EMITTED_ERROR = Symbol("emittedError"); + CLOSED = Symbol("closed"); + READ = Symbol("read"); + FLUSH = Symbol("flush"); + FLUSHCHUNK = Symbol("flushChunk"); + ENCODING = Symbol("encoding"); + DECODER = Symbol("decoder"); + FLOWING = Symbol("flowing"); + PAUSED = Symbol("paused"); + RESUME = Symbol("resume"); + BUFFER = Symbol("buffer"); + PIPES = Symbol("pipes"); + BUFFERLENGTH = Symbol("bufferLength"); + BUFFERPUSH = Symbol("bufferPush"); + BUFFERSHIFT = Symbol("bufferShift"); + OBJECTMODE = Symbol("objectMode"); + DESTROYED = Symbol("destroyed"); + ERROR = Symbol("error"); + EMITDATA = Symbol("emitData"); + EMITEND = Symbol("emitEnd"); + EMITEND2 = Symbol("emitEnd2"); + ASYNC = Symbol("async"); + ABORT = Symbol("abort"); + ABORTED = Symbol("aborted"); + SIGNAL = Symbol("signal"); + DATALISTENERS = Symbol("dataListeners"); + DISCARDED = Symbol("discarded"); + defer = (fn2) => Promise.resolve().then(fn2); + nodefer = (fn2) => fn2(); + isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish"; + isArrayBufferLike = (b) => b instanceof ArrayBuffer || !!b && typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0; + isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b); + Pipe = class { + src; + dest; + opts; + ondrain; constructor(src, dest, opts) { this.src = src; this.dest = dest; this.opts = opts; this.ondrain = () => src[RESUME](); - dest.on("drain", this.ondrain); + this.dest.on("drain", this.ondrain); } unpipe() { this.dest.removeListener("drain", this.ondrain); } - // istanbul ignore next - only here for the prototype - proxyErrors() { + // only here for the prototype + /* c8 ignore start */ + proxyErrors(_er) { } + /* c8 ignore stop */ end() { this.unpipe(); - if (this.opts.end) this.dest.end(); + if (this.opts.end) + this.dest.end(); } }; - var PipeProxyErrors = class extends Pipe { + PipeProxyErrors = class extends Pipe { unpipe() { this.src.removeListener("error", this.proxyErrors); super.unpipe(); @@ -11942,258 +11991,508 @@ var require_minipass = __commonJS({ src.on("error", this.proxyErrors); } }; - var Minipass = class _Minipass extends Stream { - constructor(options) { + isObjectModeOptions = (o) => !!o.objectMode; + isEncodingOptions = (o) => !o.objectMode && !!o.encoding && o.encoding !== "buffer"; + Minipass = class extends import_node_events.EventEmitter { + [FLOWING] = false; + [PAUSED] = false; + [PIPES] = []; + [BUFFER] = []; + [OBJECTMODE]; + [ENCODING]; + [ASYNC]; + [DECODER]; + [EOF] = false; + [EMITTED_END] = false; + [EMITTING_END] = false; + [CLOSED] = false; + [EMITTED_ERROR] = null; + [BUFFERLENGTH] = 0; + [DESTROYED] = false; + [SIGNAL]; + [ABORTED] = false; + [DATALISTENERS] = 0; + [DISCARDED] = false; + /** + * true if the stream can be written + */ + writable = true; + /** + * true if the stream can be read + */ + readable = true; + /** + * If `RType` is Buffer, then options do not need to be provided. + * Otherwise, an options object must be provided to specify either + * {@link Minipass.SharedOptions.objectMode} or + * {@link Minipass.SharedOptions.encoding}, as appropriate. + */ + constructor(...args) { + const options = args[0] || {}; super(); - this[FLOWING] = false; - this[PAUSED] = false; - this[PIPES] = []; - this[BUFFER] = []; - this[OBJECTMODE] = options && options.objectMode || false; - if (this[OBJECTMODE]) this[ENCODING] = null; - else this[ENCODING] = options && options.encoding || null; - if (this[ENCODING] === "buffer") this[ENCODING] = null; - this[ASYNC] = options && !!options.async || false; - this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null; - this[EOF] = false; - this[EMITTED_END] = false; - this[EMITTING_END] = false; - this[CLOSED] = false; - this[EMITTED_ERROR] = null; - this.writable = true; - this.readable = true; - this[BUFFERLENGTH] = 0; - this[DESTROYED] = false; + if (options.objectMode && typeof options.encoding === "string") { + throw new TypeError("Encoding and objectMode may not be used together"); + } + if (isObjectModeOptions(options)) { + this[OBJECTMODE] = true; + this[ENCODING] = null; + } else if (isEncodingOptions(options)) { + this[ENCODING] = options.encoding; + this[OBJECTMODE] = false; + } else { + this[OBJECTMODE] = false; + this[ENCODING] = null; + } + this[ASYNC] = !!options.async; + this[DECODER] = this[ENCODING] ? new import_node_string_decoder.StringDecoder(this[ENCODING]) : null; if (options && options.debugExposeBuffer === true) { Object.defineProperty(this, "buffer", { get: () => this[BUFFER] }); } if (options && options.debugExposePipes === true) { Object.defineProperty(this, "pipes", { get: () => this[PIPES] }); } - this[SIGNAL] = options && options.signal; - this[ABORTED] = false; - if (this[SIGNAL]) { - this[SIGNAL].addEventListener("abort", () => this[ABORT]()); - if (this[SIGNAL].aborted) { + const { signal } = options; + if (signal) { + this[SIGNAL] = signal; + if (signal.aborted) { this[ABORT](); + } else { + signal.addEventListener("abort", () => this[ABORT]()); } } } + /** + * The amount of data stored in the buffer waiting to be read. + * + * For Buffer strings, this will be the total byte length. + * For string encoding streams, this will be the string character length, + * according to JavaScript's `string.length` logic. + * For objectMode streams, this is a count of the items waiting to be + * emitted. + */ get bufferLength() { return this[BUFFERLENGTH]; } + /** + * The `BufferEncoding` currently in use, or `null` + */ get encoding() { return this[ENCODING]; } - set encoding(enc) { - if (this[OBJECTMODE]) throw new Error("cannot set encoding in objectMode"); - if (this[ENCODING] && enc !== this[ENCODING] && (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH])) - throw new Error("cannot change encoding"); - if (this[ENCODING] !== enc) { - this[DECODER] = enc ? new SD(enc) : null; - if (this[BUFFER].length) - this[BUFFER] = this[BUFFER].map((chunk) => this[DECODER].write(chunk)); - } - this[ENCODING] = enc; + /** + * @deprecated - This is a read only property + */ + set encoding(_enc) { + throw new Error("Encoding must be set at instantiation time"); } - setEncoding(enc) { - this.encoding = enc; + /** + * @deprecated - Encoding may only be set at instantiation time + */ + setEncoding(_enc) { + throw new Error("Encoding must be set at instantiation time"); } + /** + * True if this is an objectMode stream + */ get objectMode() { return this[OBJECTMODE]; } - set objectMode(om) { - this[OBJECTMODE] = this[OBJECTMODE] || !!om; + /** + * @deprecated - This is a read-only property + */ + set objectMode(_om) { + throw new Error("objectMode must be set at instantiation time"); } + /** + * true if this is an async stream + */ get ["async"]() { return this[ASYNC]; } + /** + * Set to true to make this stream async. + * + * Once set, it cannot be unset, as this would potentially cause incorrect + * behavior. Ie, a sync stream can be made async, but an async stream + * cannot be safely made sync. + */ set ["async"](a) { this[ASYNC] = this[ASYNC] || !!a; } // drop everything and get out of the flow completely [ABORT]() { this[ABORTED] = true; - this.emit("abort", this[SIGNAL].reason); - this.destroy(this[SIGNAL].reason); + this.emit("abort", this[SIGNAL]?.reason); + this.destroy(this[SIGNAL]?.reason); } + /** + * True if the stream has been aborted. + */ get aborted() { return this[ABORTED]; } + /** + * No-op setter. Stream aborted status is set via the AbortSignal provided + * in the constructor options. + */ set aborted(_) { } write(chunk, encoding, cb) { - if (this[ABORTED]) return false; - if (this[EOF]) throw new Error("write after end"); + if (this[ABORTED]) + return false; + if (this[EOF]) + throw new Error("write after end"); if (this[DESTROYED]) { - this.emit( - "error", - Object.assign( - new Error("Cannot call write after a stream was destroyed"), - { code: "ERR_STREAM_DESTROYED" } - ) - ); + this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" })); return true; } - if (typeof encoding === "function") cb = encoding, encoding = "utf8"; - if (!encoding) encoding = "utf8"; - const fn2 = this[ASYNC] ? defer : (f) => f(); + if (typeof encoding === "function") { + cb = encoding; + encoding = "utf8"; + } + if (!encoding) + encoding = "utf8"; + const fn2 = this[ASYNC] ? defer : nodefer; if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) { - if (isArrayBufferView(chunk)) + if (isArrayBufferView(chunk)) { chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength); - else if (isArrayBuffer(chunk)) chunk = Buffer.from(chunk); - else if (typeof chunk !== "string") - this.objectMode = true; + } else if (isArrayBufferLike(chunk)) { + chunk = Buffer.from(chunk); + } else if (typeof chunk !== "string") { + throw new Error("Non-contiguous data written to non-objectMode stream"); + } } if (this[OBJECTMODE]) { - if (this.flowing && this[BUFFERLENGTH] !== 0) this[FLUSH](true); - if (this.flowing) this.emit("data", chunk); - else this[BUFFERPUSH](chunk); - if (this[BUFFERLENGTH] !== 0) this.emit("readable"); - if (cb) fn2(cb); - return this.flowing; + if (this[FLOWING] && this[BUFFERLENGTH] !== 0) + this[FLUSH](true); + if (this[FLOWING]) + this.emit("data", chunk); + else + this[BUFFERPUSH](chunk); + if (this[BUFFERLENGTH] !== 0) + this.emit("readable"); + if (cb) + fn2(cb); + return this[FLOWING]; } if (!chunk.length) { - if (this[BUFFERLENGTH] !== 0) this.emit("readable"); - if (cb) fn2(cb); - return this.flowing; + if (this[BUFFERLENGTH] !== 0) + this.emit("readable"); + if (cb) + fn2(cb); + return this[FLOWING]; } if (typeof chunk === "string" && // unless it is a string already ready for us to use - !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) { + !(encoding === this[ENCODING] && !this[DECODER]?.lastNeed)) { chunk = Buffer.from(chunk, encoding); } - if (Buffer.isBuffer(chunk) && this[ENCODING]) + if (Buffer.isBuffer(chunk) && this[ENCODING]) { chunk = this[DECODER].write(chunk); - if (this.flowing && this[BUFFERLENGTH] !== 0) this[FLUSH](true); - if (this.flowing) this.emit("data", chunk); - else this[BUFFERPUSH](chunk); - if (this[BUFFERLENGTH] !== 0) this.emit("readable"); - if (cb) fn2(cb); - return this.flowing; + } + if (this[FLOWING] && this[BUFFERLENGTH] !== 0) + this[FLUSH](true); + if (this[FLOWING]) + this.emit("data", chunk); + else + this[BUFFERPUSH](chunk); + if (this[BUFFERLENGTH] !== 0) + this.emit("readable"); + if (cb) + fn2(cb); + return this[FLOWING]; } + /** + * Low-level explicit read method. + * + * In objectMode, the argument is ignored, and one item is returned if + * available. + * + * `n` is the number of bytes (or in the case of encoding streams, + * characters) to consume. If `n` is not provided, then the entire buffer + * is returned, or `null` is returned if no data is available. + * + * If `n` is greater that the amount of data in the internal buffer, + * then `null` is returned. + */ read(n) { - if (this[DESTROYED]) return null; - if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) { + if (this[DESTROYED]) + return null; + this[DISCARDED] = false; + if (this[BUFFERLENGTH] === 0 || n === 0 || n && n > this[BUFFERLENGTH]) { this[MAYBE_EMIT_END](); return null; } - if (this[OBJECTMODE]) n = null; + if (this[OBJECTMODE]) + n = null; if (this[BUFFER].length > 1 && !this[OBJECTMODE]) { - if (this.encoding) this[BUFFER] = [this[BUFFER].join("")]; - else this[BUFFER] = [Buffer.concat(this[BUFFER], this[BUFFERLENGTH])]; + this[BUFFER] = [ + this[ENCODING] ? this[BUFFER].join("") : Buffer.concat(this[BUFFER], this[BUFFERLENGTH]) + ]; } const ret = this[READ](n || null, this[BUFFER][0]); this[MAYBE_EMIT_END](); return ret; } [READ](n, chunk) { - if (n === chunk.length || n === null) this[BUFFERSHIFT](); + if (this[OBJECTMODE]) + this[BUFFERSHIFT](); else { - this[BUFFER][0] = chunk.slice(n); - chunk = chunk.slice(0, n); - this[BUFFERLENGTH] -= n; + const c = chunk; + if (n === c.length || n === null) + this[BUFFERSHIFT](); + else if (typeof c === "string") { + this[BUFFER][0] = c.slice(n); + chunk = c.slice(0, n); + this[BUFFERLENGTH] -= n; + } else { + this[BUFFER][0] = c.subarray(n); + chunk = c.subarray(0, n); + this[BUFFERLENGTH] -= n; + } } this.emit("data", chunk); - if (!this[BUFFER].length && !this[EOF]) this.emit("drain"); + if (!this[BUFFER].length && !this[EOF]) + this.emit("drain"); return chunk; } end(chunk, encoding, cb) { - if (typeof chunk === "function") cb = chunk, chunk = null; - if (typeof encoding === "function") cb = encoding, encoding = "utf8"; - if (chunk) this.write(chunk, encoding); - if (cb) this.once("end", cb); + if (typeof chunk === "function") { + cb = chunk; + chunk = void 0; + } + if (typeof encoding === "function") { + cb = encoding; + encoding = "utf8"; + } + if (chunk !== void 0) + this.write(chunk, encoding); + if (cb) + this.once("end", cb); this[EOF] = true; this.writable = false; - if (this.flowing || !this[PAUSED]) this[MAYBE_EMIT_END](); + if (this[FLOWING] || !this[PAUSED]) + this[MAYBE_EMIT_END](); return this; } // don't let the internal resume be overwritten [RESUME]() { - if (this[DESTROYED]) return; + if (this[DESTROYED]) + return; + if (!this[DATALISTENERS] && !this[PIPES].length) { + this[DISCARDED] = true; + } this[PAUSED] = false; this[FLOWING] = true; this.emit("resume"); - if (this[BUFFER].length) this[FLUSH](); - else if (this[EOF]) this[MAYBE_EMIT_END](); - else this.emit("drain"); + if (this[BUFFER].length) + this[FLUSH](); + else if (this[EOF]) + this[MAYBE_EMIT_END](); + else + this.emit("drain"); } + /** + * Resume the stream if it is currently in a paused state + * + * If called when there are no pipe destinations or `data` event listeners, + * this will place the stream in a "discarded" state, where all data will + * be thrown away. The discarded state is removed if a pipe destination or + * data handler is added, if pause() is called, or if any synchronous or + * asynchronous iteration is started. + */ resume() { return this[RESUME](); } + /** + * Pause the stream + */ pause() { this[FLOWING] = false; this[PAUSED] = true; + this[DISCARDED] = false; } + /** + * true if the stream has been forcibly destroyed + */ get destroyed() { return this[DESTROYED]; } + /** + * true if the stream is currently in a flowing state, meaning that + * any writes will be immediately emitted. + */ get flowing() { return this[FLOWING]; } + /** + * true if the stream is currently in a paused state + */ get paused() { return this[PAUSED]; } [BUFFERPUSH](chunk) { - if (this[OBJECTMODE]) this[BUFFERLENGTH] += 1; - else this[BUFFERLENGTH] += chunk.length; + if (this[OBJECTMODE]) + this[BUFFERLENGTH] += 1; + else + this[BUFFERLENGTH] += chunk.length; this[BUFFER].push(chunk); } [BUFFERSHIFT]() { - if (this[OBJECTMODE]) this[BUFFERLENGTH] -= 1; - else this[BUFFERLENGTH] -= this[BUFFER][0].length; + if (this[OBJECTMODE]) + this[BUFFERLENGTH] -= 1; + else + this[BUFFERLENGTH] -= this[BUFFER][0].length; return this[BUFFER].shift(); } - [FLUSH](noDrain) { + [FLUSH](noDrain = false) { do { } while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length); - if (!noDrain && !this[BUFFER].length && !this[EOF]) this.emit("drain"); + if (!noDrain && !this[BUFFER].length && !this[EOF]) + this.emit("drain"); } [FLUSHCHUNK](chunk) { this.emit("data", chunk); - return this.flowing; + return this[FLOWING]; } + /** + * Pipe all data emitted by this stream into the destination provided. + * + * Triggers the flow of data. + */ pipe(dest, opts) { - if (this[DESTROYED]) return; + if (this[DESTROYED]) + return dest; + this[DISCARDED] = false; const ended = this[EMITTED_END]; opts = opts || {}; - if (dest === proc.stdout || dest === proc.stderr) opts.end = false; - else opts.end = opts.end !== false; + if (dest === proc.stdout || dest === proc.stderr) + opts.end = false; + else + opts.end = opts.end !== false; opts.proxyErrors = !!opts.proxyErrors; if (ended) { - if (opts.end) dest.end(); + if (opts.end) + dest.end(); } else { - this[PIPES].push( - !opts.proxyErrors ? new Pipe(this, dest, opts) : new PipeProxyErrors(this, dest, opts) - ); - if (this[ASYNC]) defer(() => this[RESUME]()); - else this[RESUME](); + this[PIPES].push(!opts.proxyErrors ? new Pipe(this, dest, opts) : new PipeProxyErrors(this, dest, opts)); + if (this[ASYNC]) + defer(() => this[RESUME]()); + else + this[RESUME](); } return dest; } + /** + * Fully unhook a piped destination stream. + * + * If the destination stream was the only consumer of this stream (ie, + * there are no other piped destinations or `'data'` event listeners) + * then the flow of data will stop until there is another consumer or + * {@link Minipass#resume} is explicitly called. + */ unpipe(dest) { const p = this[PIPES].find((p2) => p2.dest === dest); if (p) { - this[PIPES].splice(this[PIPES].indexOf(p), 1); + if (this[PIPES].length === 1) { + if (this[FLOWING] && this[DATALISTENERS] === 0) { + this[FLOWING] = false; + } + this[PIPES] = []; + } else + this[PIPES].splice(this[PIPES].indexOf(p), 1); p.unpipe(); } } - addListener(ev, fn2) { - return this.on(ev, fn2); + /** + * Alias for {@link Minipass#on} + */ + addListener(ev, handler) { + return this.on(ev, handler); } - on(ev, fn2) { - const ret = super.on(ev, fn2); - if (ev === "data" && !this[PIPES].length && !this.flowing) this[RESUME](); - else if (ev === "readable" && this[BUFFERLENGTH] !== 0) + /** + * Mostly identical to `EventEmitter.on`, with the following + * behavior differences to prevent data loss and unnecessary hangs: + * + * - Adding a 'data' event handler will trigger the flow of data + * + * - Adding a 'readable' event handler when there is data waiting to be read + * will cause 'readable' to be emitted immediately. + * + * - Adding an 'endish' event handler ('end', 'finish', etc.) which has + * already passed will cause the event to be emitted immediately and all + * handlers removed. + * + * - Adding an 'error' event handler after an error has been emitted will + * cause the event to be re-emitted immediately with the error previously + * raised. + */ + on(ev, handler) { + const ret = super.on(ev, handler); + if (ev === "data") { + this[DISCARDED] = false; + this[DATALISTENERS]++; + if (!this[PIPES].length && !this[FLOWING]) { + this[RESUME](); + } + } else if (ev === "readable" && this[BUFFERLENGTH] !== 0) { super.emit("readable"); - else if (isEndish(ev) && this[EMITTED_END]) { + } else if (isEndish(ev) && this[EMITTED_END]) { super.emit(ev); this.removeAllListeners(ev); } else if (ev === "error" && this[EMITTED_ERROR]) { - if (this[ASYNC]) defer(() => fn2.call(this, this[EMITTED_ERROR])); - else fn2.call(this, this[EMITTED_ERROR]); + const h = handler; + if (this[ASYNC]) + defer(() => h.call(this, this[EMITTED_ERROR])); + else + h.call(this, this[EMITTED_ERROR]); + } + return ret; + } + /** + * Alias for {@link Minipass#off} + */ + removeListener(ev, handler) { + return this.off(ev, handler); + } + /** + * Mostly identical to `EventEmitter.off` + * + * If a 'data' event handler is removed, and it was the last consumer + * (ie, there are no pipe destinations or other 'data' event listeners), + * then the flow of data will stop until there is another consumer or + * {@link Minipass#resume} is explicitly called. + */ + off(ev, handler) { + const ret = super.off(ev, handler); + if (ev === "data") { + this[DATALISTENERS] = this.listeners("data").length; + if (this[DATALISTENERS] === 0 && !this[DISCARDED] && !this[PIPES].length) { + this[FLOWING] = false; + } + } + return ret; + } + /** + * Mostly identical to `EventEmitter.removeAllListeners` + * + * If all 'data' event handlers are removed, and they were the last consumer + * (ie, there are no pipe destinations), then the flow of data will stop + * until there is another consumer or {@link Minipass#resume} is explicitly + * called. + */ + removeAllListeners(ev) { + const ret = super.removeAllListeners(ev); + if (ev === "data" || ev === void 0) { + this[DATALISTENERS] = 0; + if (!this[DISCARDED] && !this[PIPES].length) { + this[FLOWING] = false; + } } return ret; } + /** + * true if the 'end' event has been emitted + */ get emittedEnd() { return this[EMITTED_END]; } @@ -12203,20 +12502,47 @@ var require_minipass = __commonJS({ this.emit("end"); this.emit("prefinish"); this.emit("finish"); - if (this[CLOSED]) this.emit("close"); + if (this[CLOSED]) + this.emit("close"); this[EMITTING_END] = false; } } - emit(ev, data, ...extra) { - if (ev !== "error" && ev !== "close" && ev !== DESTROYED && this[DESTROYED]) - return; - else if (ev === "data") { - return !this[OBJECTMODE] && !data ? false : this[ASYNC] ? defer(() => this[EMITDATA](data)) : this[EMITDATA](data); + /** + * Mostly identical to `EventEmitter.emit`, with the following + * behavior differences to prevent data loss and unnecessary hangs: + * + * If the stream has been destroyed, and the event is something other + * than 'close' or 'error', then `false` is returned and no handlers + * are called. + * + * If the event is 'end', and has already been emitted, then the event + * is ignored. If the stream is in a paused or non-flowing state, then + * the event will be deferred until data flow resumes. If the stream is + * async, then handlers will be called on the next tick rather than + * immediately. + * + * If the event is 'close', and 'end' has not yet been emitted, then + * the event will be deferred until after 'end' is emitted. + * + * If the event is 'error', and an AbortSignal was provided for the stream, + * and there are no listeners, then the event is ignored, matching the + * behavior of node core streams in the presense of an AbortSignal. + * + * If the event is 'finish' or 'prefinish', then all listeners will be + * removed after emitting the event, to prevent double-firing. + */ + emit(ev, ...args) { + const data = args[0]; + if (ev !== "error" && ev !== "close" && ev !== DESTROYED && this[DESTROYED]) { + return false; + } else if (ev === "data") { + return !this[OBJECTMODE] && !data ? false : this[ASYNC] ? (defer(() => this[EMITDATA](data)), true) : this[EMITDATA](data); } else if (ev === "end") { return this[EMITEND](); } else if (ev === "close") { this[CLOSED] = true; - if (!this[EMITTED_END] && !this[DESTROYED]) return; + if (!this[EMITTED_END] && !this[DESTROYED]) + return false; const ret2 = super.emit("close"); this.removeAllListeners("close"); return ret2; @@ -12235,24 +12561,25 @@ var require_minipass = __commonJS({ this.removeAllListeners(ev); return ret2; } - const ret = super.emit(ev, data, ...extra); + const ret = super.emit(ev, ...args); this[MAYBE_EMIT_END](); return ret; } [EMITDATA](data) { for (const p of this[PIPES]) { - if (p.dest.write(data) === false) this.pause(); + if (p.dest.write(data) === false) + this.pause(); } - const ret = super.emit("data", data); + const ret = this[DISCARDED] ? false : super.emit("data", data); this[MAYBE_EMIT_END](); return ret; } [EMITEND]() { - if (this[EMITTED_END]) return; + if (this[EMITTED_END]) + return false; this[EMITTED_END] = true; this.readable = false; - if (this[ASYNC]) defer(() => this[EMITEND2]()); - else this[EMITEND2](); + return this[ASYNC] ? (defer(() => this[EMITEND2]()), true) : this[EMITEND2](); } [EMITEND2]() { if (this[DECODER]) { @@ -12261,7 +12588,8 @@ var require_minipass = __commonJS({ for (const p of this[PIPES]) { p.dest.write(data); } - super.emit("data", data); + if (!this[DISCARDED]) + super.emit("data", data); } } for (const p of this[PIPES]) { @@ -12271,71 +12599,96 @@ var require_minipass = __commonJS({ this.removeAllListeners("end"); return ret; } - // const all = await stream.collect() - collect() { - const buf = []; - if (!this[OBJECTMODE]) buf.dataLength = 0; + /** + * Return a Promise that resolves to an array of all emitted data once + * the stream ends. + */ + async collect() { + const buf = Object.assign([], { + dataLength: 0 + }); + if (!this[OBJECTMODE]) + buf.dataLength = 0; const p = this.promise(); this.on("data", (c) => { buf.push(c); - if (!this[OBJECTMODE]) buf.dataLength += c.length; + if (!this[OBJECTMODE]) + buf.dataLength += c.length; }); - return p.then(() => buf); + await p; + return buf; } - // const data = await stream.concat() - concat() { - return this[OBJECTMODE] ? Promise.reject(new Error("cannot concat in objectMode")) : this.collect().then( - (buf) => this[OBJECTMODE] ? Promise.reject(new Error("cannot concat in objectMode")) : this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength) - ); + /** + * Return a Promise that resolves to the concatenation of all emitted data + * once the stream ends. + * + * Not allowed on objectMode streams. + */ + async concat() { + if (this[OBJECTMODE]) { + throw new Error("cannot concat in objectMode"); + } + const buf = await this.collect(); + return this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength); } - // stream.promise().then(() => done, er => emitted error) - promise() { - return new Promise((resolve, reject) => { + /** + * Return a void Promise that resolves once the stream ends. + */ + async promise() { + return new Promise((resolve2, reject) => { this.on(DESTROYED, () => reject(new Error("stream destroyed"))); this.on("error", (er) => reject(er)); - this.on("end", () => resolve()); + this.on("end", () => resolve2()); }); } - // for await (let chunk of stream) - [ASYNCITERATOR]() { - let stopped = false; - const stop = () => { + /** + * Asynchronous `for await of` iteration. + * + * This will continue emitting all chunks until the stream terminates. + */ + [Symbol.asyncIterator]() { + this[DISCARDED] = false; + let stopped = false; + const stop = async () => { this.pause(); stopped = true; - return Promise.resolve({ done: true }); + return { value: void 0, done: true }; }; const next = () => { - if (stopped) return stop(); + if (stopped) + return stop(); const res = this.read(); - if (res !== null) return Promise.resolve({ done: false, value: res }); - if (this[EOF]) return stop(); - let resolve = null; - let reject = null; + if (res !== null) + return Promise.resolve({ done: false, value: res }); + if (this[EOF]) + return stop(); + let resolve2; + let reject; const onerr = (er) => { - this.removeListener("data", ondata); - this.removeListener("end", onend); - this.removeListener(DESTROYED, ondestroy); + this.off("data", ondata); + this.off("end", onend); + this.off(DESTROYED, ondestroy); stop(); reject(er); }; const ondata = (value) => { - this.removeListener("error", onerr); - this.removeListener("end", onend); - this.removeListener(DESTROYED, ondestroy); + this.off("error", onerr); + this.off("end", onend); + this.off(DESTROYED, ondestroy); this.pause(); - resolve({ value, done: !!this[EOF] }); + resolve2({ value, done: !!this[EOF] }); }; const onend = () => { - this.removeListener("error", onerr); - this.removeListener("data", ondata); - this.removeListener(DESTROYED, ondestroy); + this.off("error", onerr); + this.off("data", ondata); + this.off(DESTROYED, ondestroy); stop(); - resolve({ done: true }); + resolve2({ done: true, value: void 0 }); }; const ondestroy = () => onerr(new Error("stream destroyed")); return new Promise((res2, rej) => { reject = rej; - resolve = res2; + resolve2 = res2; this.once(DESTROYED, ondestroy); this.once("error", onerr); this.once("end", onend); @@ -12346,26 +12699,33 @@ var require_minipass = __commonJS({ next, throw: stop, return: stop, - [ASYNCITERATOR]() { + [Symbol.asyncIterator]() { return this; } }; } - // for (let chunk of stream) - [ITERATOR]() { + /** + * Synchronous `for of` iteration. + * + * The iteration will terminate when the internal buffer runs out, even + * if the stream has not yet terminated. + */ + [Symbol.iterator]() { + this[DISCARDED] = false; let stopped = false; const stop = () => { this.pause(); - this.removeListener(ERROR, stop); - this.removeListener(DESTROYED, stop); - this.removeListener("end", stop); + this.off(ERROR, stop); + this.off(DESTROYED, stop); + this.off("end", stop); stopped = true; - return { done: true }; + return { done: true, value: void 0 }; }; const next = () => { - if (stopped) return stop(); + if (stopped) + return stop(); const value = this.read(); - return value === null ? stop() : { value }; + return value === null ? stop() : { done: false, value }; }; this.once("end", stop); this.once(ERROR, stop); @@ -12374,1093 +12734,1304 @@ var require_minipass = __commonJS({ next, throw: stop, return: stop, - [ITERATOR]() { + [Symbol.iterator]() { return this; } }; } + /** + * Destroy a stream, preventing it from being used for any further purpose. + * + * If the stream has a `close()` method, then it will be called on + * destruction. + * + * After destruction, any attempt to write data, read data, or emit most + * events will be ignored. + * + * If an error argument is provided, then it will be emitted in an + * 'error' event. + */ destroy(er) { if (this[DESTROYED]) { - if (er) this.emit("error", er); - else this.emit(DESTROYED); + if (er) + this.emit("error", er); + else + this.emit(DESTROYED); return this; } this[DESTROYED] = true; + this[DISCARDED] = true; this[BUFFER].length = 0; this[BUFFERLENGTH] = 0; - if (typeof this.close === "function" && !this[CLOSED]) this.close(); - if (er) this.emit("error", er); - else this.emit(DESTROYED); + const wc = this; + if (typeof wc.close === "function" && !this[CLOSED]) + wc.close(); + if (er) + this.emit("error", er); + else + this.emit(DESTROYED); return this; } - static isStream(s) { - return !!s && (s instanceof _Minipass || s instanceof Stream || s instanceof EE && // readable - (typeof s.pipe === "function" || // writable - typeof s.write === "function" && typeof s.end === "function")); + /** + * Alias for {@link isStream} + * + * Former export location, maintained for backwards compatibility. + * + * @deprecated + */ + static get isStream() { + return isStream; } }; - exports2.Minipass = Minipass; - } -}); - -// .yarn/cache/minizlib-npm-2.1.2-ea89cd0cfb-64fae024e1.zip/node_modules/minizlib/constants.js -var require_constants5 = __commonJS({ - ".yarn/cache/minizlib-npm-2.1.2-ea89cd0cfb-64fae024e1.zip/node_modules/minizlib/constants.js"(exports2, module2) { - var realZlibConstants = require("zlib").constants || /* istanbul ignore next */ - { ZLIB_VERNUM: 4736 }; - module2.exports = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), { - Z_NO_FLUSH: 0, - Z_PARTIAL_FLUSH: 1, - Z_SYNC_FLUSH: 2, - Z_FULL_FLUSH: 3, - Z_FINISH: 4, - Z_BLOCK: 5, - Z_OK: 0, - Z_STREAM_END: 1, - Z_NEED_DICT: 2, - Z_ERRNO: -1, - Z_STREAM_ERROR: -2, - Z_DATA_ERROR: -3, - Z_MEM_ERROR: -4, - Z_BUF_ERROR: -5, - Z_VERSION_ERROR: -6, - Z_NO_COMPRESSION: 0, - Z_BEST_SPEED: 1, - Z_BEST_COMPRESSION: 9, - Z_DEFAULT_COMPRESSION: -1, - Z_FILTERED: 1, - Z_HUFFMAN_ONLY: 2, - Z_RLE: 3, - Z_FIXED: 4, - Z_DEFAULT_STRATEGY: 0, - DEFLATE: 1, - INFLATE: 2, - GZIP: 3, - GUNZIP: 4, - DEFLATERAW: 5, - INFLATERAW: 6, - UNZIP: 7, - BROTLI_DECODE: 8, - BROTLI_ENCODE: 9, - Z_MIN_WINDOWBITS: 8, - Z_MAX_WINDOWBITS: 15, - Z_DEFAULT_WINDOWBITS: 15, - Z_MIN_CHUNK: 64, - Z_MAX_CHUNK: Infinity, - Z_DEFAULT_CHUNK: 16384, - Z_MIN_MEMLEVEL: 1, - Z_MAX_MEMLEVEL: 9, - Z_DEFAULT_MEMLEVEL: 8, - Z_MIN_LEVEL: -1, - Z_MAX_LEVEL: 9, - Z_DEFAULT_LEVEL: -1, - BROTLI_OPERATION_PROCESS: 0, - BROTLI_OPERATION_FLUSH: 1, - BROTLI_OPERATION_FINISH: 2, - BROTLI_OPERATION_EMIT_METADATA: 3, - BROTLI_MODE_GENERIC: 0, - BROTLI_MODE_TEXT: 1, - BROTLI_MODE_FONT: 2, - BROTLI_DEFAULT_MODE: 0, - BROTLI_MIN_QUALITY: 0, - BROTLI_MAX_QUALITY: 11, - BROTLI_DEFAULT_QUALITY: 11, - BROTLI_MIN_WINDOW_BITS: 10, - BROTLI_MAX_WINDOW_BITS: 24, - BROTLI_LARGE_MAX_WINDOW_BITS: 30, - BROTLI_DEFAULT_WINDOW: 22, - BROTLI_MIN_INPUT_BLOCK_BITS: 16, - BROTLI_MAX_INPUT_BLOCK_BITS: 24, - BROTLI_PARAM_MODE: 0, - BROTLI_PARAM_QUALITY: 1, - BROTLI_PARAM_LGWIN: 2, - BROTLI_PARAM_LGBLOCK: 3, - BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4, - BROTLI_PARAM_SIZE_HINT: 5, - BROTLI_PARAM_LARGE_WINDOW: 6, - BROTLI_PARAM_NPOSTFIX: 7, - BROTLI_PARAM_NDIRECT: 8, - BROTLI_DECODER_RESULT_ERROR: 0, - BROTLI_DECODER_RESULT_SUCCESS: 1, - BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2, - BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3, - BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0, - BROTLI_DECODER_PARAM_LARGE_WINDOW: 1, - BROTLI_DECODER_NO_ERROR: 0, - BROTLI_DECODER_SUCCESS: 1, - BROTLI_DECODER_NEEDS_MORE_INPUT: 2, - BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3, - BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1, - BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2, - BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3, - BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4, - BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5, - BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6, - BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7, - BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8, - BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9, - BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10, - BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11, - BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12, - BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13, - BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14, - BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15, - BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16, - BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19, - BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20, - BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21, - BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22, - BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25, - BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26, - BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27, - BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30, - BROTLI_DECODER_ERROR_UNREACHABLE: -31 - }, realZlibConstants)); } }); -// .yarn/cache/minipass-npm-3.3.6-b8d93a945b-a114746943.zip/node_modules/minipass/index.js -var require_minipass2 = __commonJS({ - ".yarn/cache/minipass-npm-3.3.6-b8d93a945b-a114746943.zip/node_modules/minipass/index.js"(exports2, module2) { - "use strict"; - var proc = typeof process === "object" && process ? process : { - stdout: null, - stderr: null - }; - var EE = require("events"); - var Stream = require("stream"); - var SD = require("string_decoder").StringDecoder; - var EOF = Symbol("EOF"); - var MAYBE_EMIT_END = Symbol("maybeEmitEnd"); - var EMITTED_END = Symbol("emittedEnd"); - var EMITTING_END = Symbol("emittingEnd"); - var EMITTED_ERROR = Symbol("emittedError"); - var CLOSED = Symbol("closed"); - var READ = Symbol("read"); - var FLUSH = Symbol("flush"); - var FLUSHCHUNK = Symbol("flushChunk"); - var ENCODING = Symbol("encoding"); - var DECODER = Symbol("decoder"); - var FLOWING = Symbol("flowing"); - var PAUSED = Symbol("paused"); - var RESUME = Symbol("resume"); - var BUFFERLENGTH = Symbol("bufferLength"); - var BUFFERPUSH = Symbol("bufferPush"); - var BUFFERSHIFT = Symbol("bufferShift"); - var OBJECTMODE = Symbol("objectMode"); - var DESTROYED = Symbol("destroyed"); - var EMITDATA = Symbol("emitData"); - var EMITEND = Symbol("emitEnd"); - var EMITEND2 = Symbol("emitEnd2"); - var ASYNC = Symbol("async"); - var defer = (fn2) => Promise.resolve().then(fn2); - var doIter = global._MP_NO_ITERATOR_SYMBOLS_ !== "1"; - var ASYNCITERATOR = doIter && Symbol.asyncIterator || Symbol("asyncIterator not implemented"); - var ITERATOR = doIter && Symbol.iterator || Symbol("iterator not implemented"); - var isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish"; - var isArrayBuffer = (b) => b instanceof ArrayBuffer || typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0; - var isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b); - var Pipe = class { - constructor(src, dest, opts) { - this.src = src; - this.dest = dest; - this.opts = opts; - this.ondrain = () => src[RESUME](); - dest.on("drain", this.ondrain); - } - unpipe() { - this.dest.removeListener("drain", this.ondrain); - } - // istanbul ignore next - only here for the prototype - proxyErrors() { - } - end() { - this.unpipe(); - if (this.opts.end) - this.dest.end(); +// .yarn/cache/@isaacs-fs-minipass-npm-4.0.1-677026e841-c25b6dc159.zip/node_modules/@isaacs/fs-minipass/dist/esm/index.js +var import_events2, import_fs2, writev, _autoClose, _close, _ended, _fd, _finished, _flags, _flush, _handleChunk, _makeBuf, _mode, _needDrain, _onerror, _onopen, _onread, _onwrite, _open, _path, _pos, _queue, _read, _readSize, _reading, _remain, _size, _write, _writing, _defaultFlag, _errored, ReadStream, ReadStreamSync, WriteStream, WriteStreamSync; +var init_esm2 = __esm({ + ".yarn/cache/@isaacs-fs-minipass-npm-4.0.1-677026e841-c25b6dc159.zip/node_modules/@isaacs/fs-minipass/dist/esm/index.js"() { + import_events2 = __toESM(require("events"), 1); + import_fs2 = __toESM(require("fs"), 1); + init_esm(); + writev = import_fs2.default.writev; + _autoClose = Symbol("_autoClose"); + _close = Symbol("_close"); + _ended = Symbol("_ended"); + _fd = Symbol("_fd"); + _finished = Symbol("_finished"); + _flags = Symbol("_flags"); + _flush = Symbol("_flush"); + _handleChunk = Symbol("_handleChunk"); + _makeBuf = Symbol("_makeBuf"); + _mode = Symbol("_mode"); + _needDrain = Symbol("_needDrain"); + _onerror = Symbol("_onerror"); + _onopen = Symbol("_onopen"); + _onread = Symbol("_onread"); + _onwrite = Symbol("_onwrite"); + _open = Symbol("_open"); + _path = Symbol("_path"); + _pos = Symbol("_pos"); + _queue = Symbol("_queue"); + _read = Symbol("_read"); + _readSize = Symbol("_readSize"); + _reading = Symbol("_reading"); + _remain = Symbol("_remain"); + _size = Symbol("_size"); + _write = Symbol("_write"); + _writing = Symbol("_writing"); + _defaultFlag = Symbol("_defaultFlag"); + _errored = Symbol("_errored"); + ReadStream = class extends Minipass { + [_errored] = false; + [_fd]; + [_path]; + [_readSize]; + [_reading] = false; + [_size]; + [_remain]; + [_autoClose]; + constructor(path16, opt) { + opt = opt || {}; + super(opt); + this.readable = true; + this.writable = false; + if (typeof path16 !== "string") { + throw new TypeError("path must be a string"); + } + this[_errored] = false; + this[_fd] = typeof opt.fd === "number" ? opt.fd : void 0; + this[_path] = path16; + this[_readSize] = opt.readSize || 16 * 1024 * 1024; + this[_reading] = false; + this[_size] = typeof opt.size === "number" ? opt.size : Infinity; + this[_remain] = this[_size]; + this[_autoClose] = typeof opt.autoClose === "boolean" ? opt.autoClose : true; + if (typeof this[_fd] === "number") { + this[_read](); + } else { + this[_open](); + } } - }; - var PipeProxyErrors = class extends Pipe { - unpipe() { - this.src.removeListener("error", this.proxyErrors); - super.unpipe(); + get fd() { + return this[_fd]; } - constructor(src, dest, opts) { - super(src, dest, opts); - this.proxyErrors = (er) => dest.emit("error", er); - src.on("error", this.proxyErrors); + get path() { + return this[_path]; } - }; - module2.exports = class Minipass extends Stream { - constructor(options) { - super(); - this[FLOWING] = false; - this[PAUSED] = false; - this.pipes = []; - this.buffer = []; - this[OBJECTMODE] = options && options.objectMode || false; - if (this[OBJECTMODE]) - this[ENCODING] = null; - else - this[ENCODING] = options && options.encoding || null; - if (this[ENCODING] === "buffer") - this[ENCODING] = null; - this[ASYNC] = options && !!options.async || false; - this[DECODER] = this[ENCODING] ? new SD(this[ENCODING]) : null; - this[EOF] = false; - this[EMITTED_END] = false; - this[EMITTING_END] = false; - this[CLOSED] = false; - this[EMITTED_ERROR] = null; - this.writable = true; - this.readable = true; - this[BUFFERLENGTH] = 0; - this[DESTROYED] = false; + //@ts-ignore + write() { + throw new TypeError("this is a readable stream"); } - get bufferLength() { - return this[BUFFERLENGTH]; + //@ts-ignore + end() { + throw new TypeError("this is a readable stream"); } - get encoding() { - return this[ENCODING]; + [_open]() { + import_fs2.default.open(this[_path], "r", (er, fd) => this[_onopen](er, fd)); } - set encoding(enc) { - if (this[OBJECTMODE]) - throw new Error("cannot set encoding in objectMode"); - if (this[ENCODING] && enc !== this[ENCODING] && (this[DECODER] && this[DECODER].lastNeed || this[BUFFERLENGTH])) - throw new Error("cannot change encoding"); - if (this[ENCODING] !== enc) { - this[DECODER] = enc ? new SD(enc) : null; - if (this.buffer.length) - this.buffer = this.buffer.map((chunk) => this[DECODER].write(chunk)); + [_onopen](er, fd) { + if (er) { + this[_onerror](er); + } else { + this[_fd] = fd; + this.emit("open", fd); + this[_read](); } - this[ENCODING] = enc; } - setEncoding(enc) { - this.encoding = enc; + [_makeBuf]() { + return Buffer.allocUnsafe(Math.min(this[_readSize], this[_remain])); } - get objectMode() { - return this[OBJECTMODE]; + [_read]() { + if (!this[_reading]) { + this[_reading] = true; + const buf = this[_makeBuf](); + if (buf.length === 0) { + return process.nextTick(() => this[_onread](null, 0, buf)); + } + import_fs2.default.read(this[_fd], buf, 0, buf.length, null, (er, br, b) => this[_onread](er, br, b)); + } } - set objectMode(om) { - this[OBJECTMODE] = this[OBJECTMODE] || !!om; + [_onread](er, br, buf) { + this[_reading] = false; + if (er) { + this[_onerror](er); + } else if (this[_handleChunk](br, buf)) { + this[_read](); + } } - get ["async"]() { - return this[ASYNC]; + [_close]() { + if (this[_autoClose] && typeof this[_fd] === "number") { + const fd = this[_fd]; + this[_fd] = void 0; + import_fs2.default.close(fd, (er) => er ? this.emit("error", er) : this.emit("close")); + } } - set ["async"](a) { - this[ASYNC] = this[ASYNC] || !!a; + [_onerror](er) { + this[_reading] = true; + this[_close](); + this.emit("error", er); } - write(chunk, encoding, cb) { - if (this[EOF]) - throw new Error("write after end"); - if (this[DESTROYED]) { - this.emit("error", Object.assign( - new Error("Cannot call write after a stream was destroyed"), - { code: "ERR_STREAM_DESTROYED" } - )); - return true; + [_handleChunk](br, buf) { + let ret = false; + this[_remain] -= br; + if (br > 0) { + ret = super.write(br < buf.length ? buf.subarray(0, br) : buf); } - if (typeof encoding === "function") - cb = encoding, encoding = "utf8"; - if (!encoding) - encoding = "utf8"; - const fn2 = this[ASYNC] ? defer : (f) => f(); - if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) { - if (isArrayBufferView(chunk)) - chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength); - else if (isArrayBuffer(chunk)) - chunk = Buffer.from(chunk); - else if (typeof chunk !== "string") - this.objectMode = true; - } - if (this[OBJECTMODE]) { - if (this.flowing && this[BUFFERLENGTH] !== 0) - this[FLUSH](true); - if (this.flowing) - this.emit("data", chunk); - else - this[BUFFERPUSH](chunk); - if (this[BUFFERLENGTH] !== 0) - this.emit("readable"); - if (cb) - fn2(cb); - return this.flowing; - } - if (!chunk.length) { - if (this[BUFFERLENGTH] !== 0) - this.emit("readable"); - if (cb) - fn2(cb); - return this.flowing; - } - if (typeof chunk === "string" && // unless it is a string already ready for us to use - !(encoding === this[ENCODING] && !this[DECODER].lastNeed)) { - chunk = Buffer.from(chunk, encoding); + if (br === 0 || this[_remain] <= 0) { + ret = false; + this[_close](); + super.end(); } - if (Buffer.isBuffer(chunk) && this[ENCODING]) - chunk = this[DECODER].write(chunk); - if (this.flowing && this[BUFFERLENGTH] !== 0) - this[FLUSH](true); - if (this.flowing) - this.emit("data", chunk); - else - this[BUFFERPUSH](chunk); - if (this[BUFFERLENGTH] !== 0) - this.emit("readable"); - if (cb) - fn2(cb); - return this.flowing; + return ret; } - read(n) { - if (this[DESTROYED]) - return null; - if (this[BUFFERLENGTH] === 0 || n === 0 || n > this[BUFFERLENGTH]) { - this[MAYBE_EMIT_END](); - return null; + emit(ev, ...args) { + switch (ev) { + case "prefinish": + case "finish": + return false; + case "drain": + if (typeof this[_fd] === "number") { + this[_read](); + } + return false; + case "error": + if (this[_errored]) { + return false; + } + this[_errored] = true; + return super.emit(ev, ...args); + default: + return super.emit(ev, ...args); } - if (this[OBJECTMODE]) - n = null; - if (this.buffer.length > 1 && !this[OBJECTMODE]) { - if (this.encoding) - this.buffer = [this.buffer.join("")]; - else - this.buffer = [Buffer.concat(this.buffer, this[BUFFERLENGTH])]; + } + }; + ReadStreamSync = class extends ReadStream { + [_open]() { + let threw = true; + try { + this[_onopen](null, import_fs2.default.openSync(this[_path], "r")); + threw = false; + } finally { + if (threw) { + this[_close](); + } } - const ret = this[READ](n || null, this.buffer[0]); - this[MAYBE_EMIT_END](); - return ret; } - [READ](n, chunk) { - if (n === chunk.length || n === null) - this[BUFFERSHIFT](); - else { - this.buffer[0] = chunk.slice(n); - chunk = chunk.slice(0, n); - this[BUFFERLENGTH] -= n; + [_read]() { + let threw = true; + try { + if (!this[_reading]) { + this[_reading] = true; + do { + const buf = this[_makeBuf](); + const br = buf.length === 0 ? 0 : import_fs2.default.readSync(this[_fd], buf, 0, buf.length, null); + if (!this[_handleChunk](br, buf)) { + break; + } + } while (true); + this[_reading] = false; + } + threw = false; + } finally { + if (threw) { + this[_close](); + } } - this.emit("data", chunk); - if (!this.buffer.length && !this[EOF]) - this.emit("drain"); - return chunk; } - end(chunk, encoding, cb) { - if (typeof chunk === "function") - cb = chunk, chunk = null; - if (typeof encoding === "function") - cb = encoding, encoding = "utf8"; - if (chunk) - this.write(chunk, encoding); - if (cb) - this.once("end", cb); - this[EOF] = true; - this.writable = false; - if (this.flowing || !this[PAUSED]) - this[MAYBE_EMIT_END](); - return this; + [_close]() { + if (this[_autoClose] && typeof this[_fd] === "number") { + const fd = this[_fd]; + this[_fd] = void 0; + import_fs2.default.closeSync(fd); + this.emit("close"); + } } - // don't let the internal resume be overwritten - [RESUME]() { - if (this[DESTROYED]) - return; - this[PAUSED] = false; - this[FLOWING] = true; - this.emit("resume"); - if (this.buffer.length) - this[FLUSH](); - else if (this[EOF]) - this[MAYBE_EMIT_END](); - else - this.emit("drain"); + }; + WriteStream = class extends import_events2.default { + readable = false; + writable = true; + [_errored] = false; + [_writing] = false; + [_ended] = false; + [_queue] = []; + [_needDrain] = false; + [_path]; + [_mode]; + [_autoClose]; + [_fd]; + [_defaultFlag]; + [_flags]; + [_finished] = false; + [_pos]; + constructor(path16, opt) { + opt = opt || {}; + super(opt); + this[_path] = path16; + this[_fd] = typeof opt.fd === "number" ? opt.fd : void 0; + this[_mode] = opt.mode === void 0 ? 438 : opt.mode; + this[_pos] = typeof opt.start === "number" ? opt.start : void 0; + this[_autoClose] = typeof opt.autoClose === "boolean" ? opt.autoClose : true; + const defaultFlag = this[_pos] !== void 0 ? "r+" : "w"; + this[_defaultFlag] = opt.flags === void 0; + this[_flags] = opt.flags === void 0 ? defaultFlag : opt.flags; + if (this[_fd] === void 0) { + this[_open](); + } } - resume() { - return this[RESUME](); + emit(ev, ...args) { + if (ev === "error") { + if (this[_errored]) { + return false; + } + this[_errored] = true; + } + return super.emit(ev, ...args); } - pause() { - this[FLOWING] = false; - this[PAUSED] = true; + get fd() { + return this[_fd]; } - get destroyed() { - return this[DESTROYED]; + get path() { + return this[_path]; } - get flowing() { - return this[FLOWING]; + [_onerror](er) { + this[_close](); + this[_writing] = true; + this.emit("error", er); } - get paused() { - return this[PAUSED]; + [_open]() { + import_fs2.default.open(this[_path], this[_flags], this[_mode], (er, fd) => this[_onopen](er, fd)); } - [BUFFERPUSH](chunk) { - if (this[OBJECTMODE]) - this[BUFFERLENGTH] += 1; - else - this[BUFFERLENGTH] += chunk.length; - this.buffer.push(chunk); + [_onopen](er, fd) { + if (this[_defaultFlag] && this[_flags] === "r+" && er && er.code === "ENOENT") { + this[_flags] = "w"; + this[_open](); + } else if (er) { + this[_onerror](er); + } else { + this[_fd] = fd; + this.emit("open", fd); + if (!this[_writing]) { + this[_flush](); + } + } } - [BUFFERSHIFT]() { - if (this.buffer.length) { - if (this[OBJECTMODE]) - this[BUFFERLENGTH] -= 1; - else - this[BUFFERLENGTH] -= this.buffer[0].length; + end(buf, enc) { + if (buf) { + this.write(buf, enc); + } + this[_ended] = true; + if (!this[_writing] && !this[_queue].length && typeof this[_fd] === "number") { + this[_onwrite](null, 0); } - return this.buffer.shift(); + return this; } - [FLUSH](noDrain) { - do { - } while (this[FLUSHCHUNK](this[BUFFERSHIFT]())); - if (!noDrain && !this.buffer.length && !this[EOF]) - this.emit("drain"); + write(buf, enc) { + if (typeof buf === "string") { + buf = Buffer.from(buf, enc); + } + if (this[_ended]) { + this.emit("error", new Error("write() after end()")); + return false; + } + if (this[_fd] === void 0 || this[_writing] || this[_queue].length) { + this[_queue].push(buf); + this[_needDrain] = true; + return false; + } + this[_writing] = true; + this[_write](buf); + return true; } - [FLUSHCHUNK](chunk) { - return chunk ? (this.emit("data", chunk), this.flowing) : false; + [_write](buf) { + import_fs2.default.write(this[_fd], buf, 0, buf.length, this[_pos], (er, bw) => this[_onwrite](er, bw)); } - pipe(dest, opts) { - if (this[DESTROYED]) - return; - const ended = this[EMITTED_END]; - opts = opts || {}; - if (dest === proc.stdout || dest === proc.stderr) - opts.end = false; - else - opts.end = opts.end !== false; - opts.proxyErrors = !!opts.proxyErrors; - if (ended) { - if (opts.end) - dest.end(); + [_onwrite](er, bw) { + if (er) { + this[_onerror](er); } else { - this.pipes.push(!opts.proxyErrors ? new Pipe(this, dest, opts) : new PipeProxyErrors(this, dest, opts)); - if (this[ASYNC]) - defer(() => this[RESUME]()); - else - this[RESUME](); + if (this[_pos] !== void 0 && typeof bw === "number") { + this[_pos] += bw; + } + if (this[_queue].length) { + this[_flush](); + } else { + this[_writing] = false; + if (this[_ended] && !this[_finished]) { + this[_finished] = true; + this[_close](); + this.emit("finish"); + } else if (this[_needDrain]) { + this[_needDrain] = false; + this.emit("drain"); + } + } } - return dest; } - unpipe(dest) { - const p = this.pipes.find((p2) => p2.dest === dest); - if (p) { - this.pipes.splice(this.pipes.indexOf(p), 1); - p.unpipe(); + [_flush]() { + if (this[_queue].length === 0) { + if (this[_ended]) { + this[_onwrite](null, 0); + } + } else if (this[_queue].length === 1) { + this[_write](this[_queue].pop()); + } else { + const iovec = this[_queue]; + this[_queue] = []; + writev(this[_fd], iovec, this[_pos], (er, bw) => this[_onwrite](er, bw)); } } - addListener(ev, fn2) { - return this.on(ev, fn2); - } - on(ev, fn2) { - const ret = super.on(ev, fn2); - if (ev === "data" && !this.pipes.length && !this.flowing) - this[RESUME](); - else if (ev === "readable" && this[BUFFERLENGTH] !== 0) - super.emit("readable"); - else if (isEndish(ev) && this[EMITTED_END]) { - super.emit(ev); - this.removeAllListeners(ev); - } else if (ev === "error" && this[EMITTED_ERROR]) { - if (this[ASYNC]) - defer(() => fn2.call(this, this[EMITTED_ERROR])); - else - fn2.call(this, this[EMITTED_ERROR]); + [_close]() { + if (this[_autoClose] && typeof this[_fd] === "number") { + const fd = this[_fd]; + this[_fd] = void 0; + import_fs2.default.close(fd, (er) => er ? this.emit("error", er) : this.emit("close")); } - return ret; - } - get emittedEnd() { - return this[EMITTED_END]; } - [MAYBE_EMIT_END]() { - if (!this[EMITTING_END] && !this[EMITTED_END] && !this[DESTROYED] && this.buffer.length === 0 && this[EOF]) { - this[EMITTING_END] = true; - this.emit("end"); - this.emit("prefinish"); - this.emit("finish"); - if (this[CLOSED]) - this.emit("close"); - this[EMITTING_END] = false; - } - } - emit(ev, data, ...extra) { - if (ev !== "error" && ev !== "close" && ev !== DESTROYED && this[DESTROYED]) - return; - else if (ev === "data") { - return !data ? false : this[ASYNC] ? defer(() => this[EMITDATA](data)) : this[EMITDATA](data); - } else if (ev === "end") { - return this[EMITEND](); - } else if (ev === "close") { - this[CLOSED] = true; - if (!this[EMITTED_END] && !this[DESTROYED]) - return; - const ret2 = super.emit("close"); - this.removeAllListeners("close"); - return ret2; - } else if (ev === "error") { - this[EMITTED_ERROR] = data; - const ret2 = super.emit("error", data); - this[MAYBE_EMIT_END](); - return ret2; - } else if (ev === "resume") { - const ret2 = super.emit("resume"); - this[MAYBE_EMIT_END](); - return ret2; - } else if (ev === "finish" || ev === "prefinish") { - const ret2 = super.emit(ev); - this.removeAllListeners(ev); - return ret2; - } - const ret = super.emit(ev, data, ...extra); - this[MAYBE_EMIT_END](); - return ret; - } - [EMITDATA](data) { - for (const p of this.pipes) { - if (p.dest.write(data) === false) - this.pause(); - } - const ret = super.emit("data", data); - this[MAYBE_EMIT_END](); - return ret; - } - [EMITEND]() { - if (this[EMITTED_END]) - return; - this[EMITTED_END] = true; - this.readable = false; - if (this[ASYNC]) - defer(() => this[EMITEND2]()); - else - this[EMITEND2](); - } - [EMITEND2]() { - if (this[DECODER]) { - const data = this[DECODER].end(); - if (data) { - for (const p of this.pipes) { - p.dest.write(data); + }; + WriteStreamSync = class extends WriteStream { + [_open]() { + let fd; + if (this[_defaultFlag] && this[_flags] === "r+") { + try { + fd = import_fs2.default.openSync(this[_path], this[_flags], this[_mode]); + } catch (er) { + if (er?.code === "ENOENT") { + this[_flags] = "w"; + return this[_open](); + } else { + throw er; } - super.emit("data", data); } + } else { + fd = import_fs2.default.openSync(this[_path], this[_flags], this[_mode]); } - for (const p of this.pipes) { - p.end(); - } - const ret = super.emit("end"); - this.removeAllListeners("end"); - return ret; - } - // const all = await stream.collect() - collect() { - const buf = []; - if (!this[OBJECTMODE]) - buf.dataLength = 0; - const p = this.promise(); - this.on("data", (c) => { - buf.push(c); - if (!this[OBJECTMODE]) - buf.dataLength += c.length; - }); - return p.then(() => buf); - } - // const data = await stream.concat() - concat() { - return this[OBJECTMODE] ? Promise.reject(new Error("cannot concat in objectMode")) : this.collect().then((buf) => this[OBJECTMODE] ? Promise.reject(new Error("cannot concat in objectMode")) : this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength)); - } - // stream.promise().then(() => done, er => emitted error) - promise() { - return new Promise((resolve, reject) => { - this.on(DESTROYED, () => reject(new Error("stream destroyed"))); - this.on("error", (er) => reject(er)); - this.on("end", () => resolve()); - }); - } - // for await (let chunk of stream) - [ASYNCITERATOR]() { - const next = () => { - const res = this.read(); - if (res !== null) - return Promise.resolve({ done: false, value: res }); - if (this[EOF]) - return Promise.resolve({ done: true }); - let resolve = null; - let reject = null; - const onerr = (er) => { - this.removeListener("data", ondata); - this.removeListener("end", onend); - reject(er); - }; - const ondata = (value) => { - this.removeListener("error", onerr); - this.removeListener("end", onend); - this.pause(); - resolve({ value, done: !!this[EOF] }); - }; - const onend = () => { - this.removeListener("error", onerr); - this.removeListener("data", ondata); - resolve({ done: true }); - }; - const ondestroy = () => onerr(new Error("stream destroyed")); - return new Promise((res2, rej) => { - reject = rej; - resolve = res2; - this.once(DESTROYED, ondestroy); - this.once("error", onerr); - this.once("end", onend); - this.once("data", ondata); - }); - }; - return { next }; - } - // for (let chunk of stream) - [ITERATOR]() { - const next = () => { - const value = this.read(); - const done = value === null; - return { value, done }; - }; - return { next }; - } - destroy(er) { - if (this[DESTROYED]) { - if (er) - this.emit("error", er); - else - this.emit(DESTROYED); - return this; - } - this[DESTROYED] = true; - this.buffer.length = 0; - this[BUFFERLENGTH] = 0; - if (typeof this.close === "function" && !this[CLOSED]) - this.close(); - if (er) - this.emit("error", er); - else - this.emit(DESTROYED); - return this; - } - static isStream(s) { - return !!s && (s instanceof Minipass || s instanceof Stream || s instanceof EE && (typeof s.pipe === "function" || // readable - typeof s.write === "function" && typeof s.end === "function")); - } - }; - } -}); - -// .yarn/cache/minizlib-npm-2.1.2-ea89cd0cfb-64fae024e1.zip/node_modules/minizlib/index.js -var require_minizlib = __commonJS({ - ".yarn/cache/minizlib-npm-2.1.2-ea89cd0cfb-64fae024e1.zip/node_modules/minizlib/index.js"(exports2) { - "use strict"; - var assert3 = require("assert"); - var Buffer2 = require("buffer").Buffer; - var realZlib = require("zlib"); - var constants = exports2.constants = require_constants5(); - var Minipass = require_minipass2(); - var OriginalBufferConcat = Buffer2.concat; - var _superWrite = Symbol("_superWrite"); - var ZlibError = class extends Error { - constructor(err) { - super("zlib: " + err.message); - this.code = err.code; - this.errno = err.errno; - if (!this.code) - this.code = "ZLIB_ERROR"; - this.message = "zlib: " + err.message; - Error.captureStackTrace(this, this.constructor); - } - get name() { - return "ZlibError"; - } - }; - var _opts = Symbol("opts"); - var _flushFlag = Symbol("flushFlag"); - var _finishFlushFlag = Symbol("finishFlushFlag"); - var _fullFlushFlag = Symbol("fullFlushFlag"); - var _handle = Symbol("handle"); - var _onError = Symbol("onError"); - var _sawError = Symbol("sawError"); - var _level = Symbol("level"); - var _strategy = Symbol("strategy"); - var _ended = Symbol("ended"); - var _defaultFullFlush = Symbol("_defaultFullFlush"); - var ZlibBase = class extends Minipass { - constructor(opts, mode) { - if (!opts || typeof opts !== "object") - throw new TypeError("invalid options for ZlibBase constructor"); - super(opts); - this[_sawError] = false; - this[_ended] = false; - this[_opts] = opts; - this[_flushFlag] = opts.flush; - this[_finishFlushFlag] = opts.finishFlush; - try { - this[_handle] = new realZlib[mode](opts); - } catch (er) { - throw new ZlibError(er); - } - this[_onError] = (err) => { - if (this[_sawError]) - return; - this[_sawError] = true; - this.close(); - this.emit("error", err); - }; - this[_handle].on("error", (er) => this[_onError](new ZlibError(er))); - this.once("end", () => this.close); + this[_onopen](null, fd); } - close() { - if (this[_handle]) { - this[_handle].close(); - this[_handle] = null; + [_close]() { + if (this[_autoClose] && typeof this[_fd] === "number") { + const fd = this[_fd]; + this[_fd] = void 0; + import_fs2.default.closeSync(fd); this.emit("close"); } } - reset() { - if (!this[_sawError]) { - assert3(this[_handle], "zlib binding closed"); - return this[_handle].reset(); - } - } - flush(flushFlag) { - if (this.ended) - return; - if (typeof flushFlag !== "number") - flushFlag = this[_fullFlushFlag]; - this.write(Object.assign(Buffer2.alloc(0), { [_flushFlag]: flushFlag })); - } - end(chunk, encoding, cb) { - if (chunk) - this.write(chunk, encoding); - this.flush(this[_finishFlushFlag]); - this[_ended] = true; - return super.end(null, null, cb); - } - get ended() { - return this[_ended]; - } - write(chunk, encoding, cb) { - if (typeof encoding === "function") - cb = encoding, encoding = "utf8"; - if (typeof chunk === "string") - chunk = Buffer2.from(chunk, encoding); - if (this[_sawError]) - return; - assert3(this[_handle], "zlib binding closed"); - const nativeHandle = this[_handle]._handle; - const originalNativeClose = nativeHandle.close; - nativeHandle.close = () => { - }; - const originalClose = this[_handle].close; - this[_handle].close = () => { - }; - Buffer2.concat = (args) => args; - let result; + [_write](buf) { + let threw = true; try { - const flushFlag = typeof chunk[_flushFlag] === "number" ? chunk[_flushFlag] : this[_flushFlag]; - result = this[_handle]._processChunk(chunk, flushFlag); - Buffer2.concat = OriginalBufferConcat; - } catch (err) { - Buffer2.concat = OriginalBufferConcat; - this[_onError](new ZlibError(err)); + this[_onwrite](null, import_fs2.default.writeSync(this[_fd], buf, 0, buf.length, this[_pos])); + threw = false; } finally { - if (this[_handle]) { - this[_handle]._handle = nativeHandle; - nativeHandle.close = originalNativeClose; - this[_handle].close = originalClose; - this[_handle].removeAllListeners("error"); - } - } - if (this[_handle]) - this[_handle].on("error", (er) => this[_onError](new ZlibError(er))); - let writeReturn; - if (result) { - if (Array.isArray(result) && result.length > 0) { - writeReturn = this[_superWrite](Buffer2.from(result[0])); - for (let i = 1; i < result.length; i++) { - writeReturn = this[_superWrite](result[i]); + if (threw) { + try { + this[_close](); + } catch { } - } else { - writeReturn = this[_superWrite](Buffer2.from(result)); - } - } - if (cb) - cb(); - return writeReturn; - } - [_superWrite](data) { - return super.write(data); - } - }; - var Zlib = class extends ZlibBase { - constructor(opts, mode) { - opts = opts || {}; - opts.flush = opts.flush || constants.Z_NO_FLUSH; - opts.finishFlush = opts.finishFlush || constants.Z_FINISH; - super(opts, mode); - this[_fullFlushFlag] = constants.Z_FULL_FLUSH; - this[_level] = opts.level; - this[_strategy] = opts.strategy; - } - params(level, strategy) { - if (this[_sawError]) - return; - if (!this[_handle]) - throw new Error("cannot switch params when binding is closed"); - if (!this[_handle].params) - throw new Error("not supported in this implementation"); - if (this[_level] !== level || this[_strategy] !== strategy) { - this.flush(constants.Z_SYNC_FLUSH); - assert3(this[_handle], "zlib binding closed"); - const origFlush = this[_handle].flush; - this[_handle].flush = (flushFlag, cb) => { - this.flush(flushFlag); - cb(); - }; - try { - this[_handle].params(level, strategy); - } finally { - this[_handle].flush = origFlush; - } - if (this[_handle]) { - this[_level] = level; - this[_strategy] = strategy; } } } }; - var Deflate = class extends Zlib { - constructor(opts) { - super(opts, "Deflate"); - } + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/options.js +var argmap, isSyncFile, isAsyncFile, isSyncNoFile, isAsyncNoFile, dealiasKey, dealias; +var init_options = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/options.js"() { + argmap = /* @__PURE__ */ new Map([ + ["C", "cwd"], + ["f", "file"], + ["z", "gzip"], + ["P", "preservePaths"], + ["U", "unlink"], + ["strip-components", "strip"], + ["stripComponents", "strip"], + ["keep-newer", "newer"], + ["keepNewer", "newer"], + ["keep-newer-files", "newer"], + ["keepNewerFiles", "newer"], + ["k", "keep"], + ["keep-existing", "keep"], + ["keepExisting", "keep"], + ["m", "noMtime"], + ["no-mtime", "noMtime"], + ["p", "preserveOwner"], + ["L", "follow"], + ["h", "follow"], + ["onentry", "onReadEntry"] + ]); + isSyncFile = (o) => !!o.sync && !!o.file; + isAsyncFile = (o) => !o.sync && !!o.file; + isSyncNoFile = (o) => !!o.sync && !o.file; + isAsyncNoFile = (o) => !o.sync && !o.file; + dealiasKey = (k) => { + const d = argmap.get(k); + if (d) + return d; + return k; + }; + dealias = (opt = {}) => { + if (!opt) + return {}; + const result = {}; + for (const [key, v] of Object.entries(opt)) { + const k = dealiasKey(key); + result[k] = v; + } + if (result.chmod === void 0 && result.noChmod === false) { + result.chmod = true; + } + delete result.noChmod; + return result; }; - var Inflate = class extends Zlib { - constructor(opts) { - super(opts, "Inflate"); + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/make-command.js +var makeCommand; +var init_make_command = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/make-command.js"() { + init_options(); + makeCommand = (syncFile, asyncFile, syncNoFile, asyncNoFile, validate) => { + return Object.assign((opt_ = [], entries, cb) => { + if (Array.isArray(opt_)) { + entries = opt_; + opt_ = {}; + } + if (typeof entries === "function") { + cb = entries; + entries = void 0; + } + if (!entries) { + entries = []; + } else { + entries = Array.from(entries); + } + const opt = dealias(opt_); + validate?.(opt, entries); + if (isSyncFile(opt)) { + if (typeof cb === "function") { + throw new TypeError("callback not supported for sync tar functions"); + } + return syncFile(opt, entries); + } else if (isAsyncFile(opt)) { + const p = asyncFile(opt, entries); + const c = cb ? cb : void 0; + return c ? p.then(() => c(), c) : p; + } else if (isSyncNoFile(opt)) { + if (typeof cb === "function") { + throw new TypeError("callback not supported for sync tar functions"); + } + return syncNoFile(opt, entries); + } else if (isAsyncNoFile(opt)) { + if (typeof cb === "function") { + throw new TypeError("callback only supported with file option"); + } + return asyncNoFile(opt, entries); + } else { + throw new Error("impossible options??"); + } + }, { + syncFile, + asyncFile, + syncNoFile, + asyncNoFile, + validate + }); + }; + } +}); + +// .yarn/cache/minizlib-npm-3.0.1-4bdabd978f-82f8bf70da.zip/node_modules/minizlib/dist/esm/constants.js +var import_zlib, realZlibConstants, constants; +var init_constants = __esm({ + ".yarn/cache/minizlib-npm-3.0.1-4bdabd978f-82f8bf70da.zip/node_modules/minizlib/dist/esm/constants.js"() { + import_zlib = __toESM(require("zlib"), 1); + realZlibConstants = import_zlib.default.constants || { ZLIB_VERNUM: 4736 }; + constants = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), { + Z_NO_FLUSH: 0, + Z_PARTIAL_FLUSH: 1, + Z_SYNC_FLUSH: 2, + Z_FULL_FLUSH: 3, + Z_FINISH: 4, + Z_BLOCK: 5, + Z_OK: 0, + Z_STREAM_END: 1, + Z_NEED_DICT: 2, + Z_ERRNO: -1, + Z_STREAM_ERROR: -2, + Z_DATA_ERROR: -3, + Z_MEM_ERROR: -4, + Z_BUF_ERROR: -5, + Z_VERSION_ERROR: -6, + Z_NO_COMPRESSION: 0, + Z_BEST_SPEED: 1, + Z_BEST_COMPRESSION: 9, + Z_DEFAULT_COMPRESSION: -1, + Z_FILTERED: 1, + Z_HUFFMAN_ONLY: 2, + Z_RLE: 3, + Z_FIXED: 4, + Z_DEFAULT_STRATEGY: 0, + DEFLATE: 1, + INFLATE: 2, + GZIP: 3, + GUNZIP: 4, + DEFLATERAW: 5, + INFLATERAW: 6, + UNZIP: 7, + BROTLI_DECODE: 8, + BROTLI_ENCODE: 9, + Z_MIN_WINDOWBITS: 8, + Z_MAX_WINDOWBITS: 15, + Z_DEFAULT_WINDOWBITS: 15, + Z_MIN_CHUNK: 64, + Z_MAX_CHUNK: Infinity, + Z_DEFAULT_CHUNK: 16384, + Z_MIN_MEMLEVEL: 1, + Z_MAX_MEMLEVEL: 9, + Z_DEFAULT_MEMLEVEL: 8, + Z_MIN_LEVEL: -1, + Z_MAX_LEVEL: 9, + Z_DEFAULT_LEVEL: -1, + BROTLI_OPERATION_PROCESS: 0, + BROTLI_OPERATION_FLUSH: 1, + BROTLI_OPERATION_FINISH: 2, + BROTLI_OPERATION_EMIT_METADATA: 3, + BROTLI_MODE_GENERIC: 0, + BROTLI_MODE_TEXT: 1, + BROTLI_MODE_FONT: 2, + BROTLI_DEFAULT_MODE: 0, + BROTLI_MIN_QUALITY: 0, + BROTLI_MAX_QUALITY: 11, + BROTLI_DEFAULT_QUALITY: 11, + BROTLI_MIN_WINDOW_BITS: 10, + BROTLI_MAX_WINDOW_BITS: 24, + BROTLI_LARGE_MAX_WINDOW_BITS: 30, + BROTLI_DEFAULT_WINDOW: 22, + BROTLI_MIN_INPUT_BLOCK_BITS: 16, + BROTLI_MAX_INPUT_BLOCK_BITS: 24, + BROTLI_PARAM_MODE: 0, + BROTLI_PARAM_QUALITY: 1, + BROTLI_PARAM_LGWIN: 2, + BROTLI_PARAM_LGBLOCK: 3, + BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: 4, + BROTLI_PARAM_SIZE_HINT: 5, + BROTLI_PARAM_LARGE_WINDOW: 6, + BROTLI_PARAM_NPOSTFIX: 7, + BROTLI_PARAM_NDIRECT: 8, + BROTLI_DECODER_RESULT_ERROR: 0, + BROTLI_DECODER_RESULT_SUCCESS: 1, + BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: 2, + BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: 3, + BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: 0, + BROTLI_DECODER_PARAM_LARGE_WINDOW: 1, + BROTLI_DECODER_NO_ERROR: 0, + BROTLI_DECODER_SUCCESS: 1, + BROTLI_DECODER_NEEDS_MORE_INPUT: 2, + BROTLI_DECODER_NEEDS_MORE_OUTPUT: 3, + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: -1, + BROTLI_DECODER_ERROR_FORMAT_RESERVED: -2, + BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: -3, + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: -4, + BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: -5, + BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: -6, + BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: -7, + BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: -8, + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: -9, + BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: -10, + BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: -11, + BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: -12, + BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: -13, + BROTLI_DECODER_ERROR_FORMAT_PADDING_1: -14, + BROTLI_DECODER_ERROR_FORMAT_PADDING_2: -15, + BROTLI_DECODER_ERROR_FORMAT_DISTANCE: -16, + BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: -19, + BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: -20, + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: -21, + BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: -22, + BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: -25, + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: -26, + BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: -27, + BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: -30, + BROTLI_DECODER_ERROR_UNREACHABLE: -31 + }, realZlibConstants)); + } +}); + +// .yarn/cache/minizlib-npm-3.0.1-4bdabd978f-82f8bf70da.zip/node_modules/minizlib/dist/esm/index.js +var import_assert2, import_buffer, import_zlib2, OriginalBufferConcat, _superWrite, ZlibError, _flushFlag, ZlibBase, Zlib, Gzip, Unzip, Brotli, BrotliCompress, BrotliDecompress; +var init_esm3 = __esm({ + ".yarn/cache/minizlib-npm-3.0.1-4bdabd978f-82f8bf70da.zip/node_modules/minizlib/dist/esm/index.js"() { + import_assert2 = __toESM(require("assert"), 1); + import_buffer = require("buffer"); + init_esm(); + import_zlib2 = __toESM(require("zlib"), 1); + init_constants(); + init_constants(); + OriginalBufferConcat = import_buffer.Buffer.concat; + _superWrite = Symbol("_superWrite"); + ZlibError = class extends Error { + code; + errno; + constructor(err) { + super("zlib: " + err.message); + this.code = err.code; + this.errno = err.errno; + if (!this.code) + this.code = "ZLIB_ERROR"; + this.message = "zlib: " + err.message; + Error.captureStackTrace(this, this.constructor); + } + get name() { + return "ZlibError"; } }; - var _portable = Symbol("_portable"); - var Gzip = class extends Zlib { - constructor(opts) { - super(opts, "Gzip"); - this[_portable] = opts && !!opts.portable; + _flushFlag = Symbol("flushFlag"); + ZlibBase = class extends Minipass { + #sawError = false; + #ended = false; + #flushFlag; + #finishFlushFlag; + #fullFlushFlag; + #handle; + #onError; + get sawError() { + return this.#sawError; + } + get handle() { + return this.#handle; + } + /* c8 ignore start */ + get flushFlag() { + return this.#flushFlag; + } + /* c8 ignore stop */ + constructor(opts, mode) { + if (!opts || typeof opts !== "object") + throw new TypeError("invalid options for ZlibBase constructor"); + super(opts); + this.#flushFlag = opts.flush ?? 0; + this.#finishFlushFlag = opts.finishFlush ?? 0; + this.#fullFlushFlag = opts.fullFlushFlag ?? 0; + try { + this.#handle = new import_zlib2.default[mode](opts); + } catch (er) { + throw new ZlibError(er); + } + this.#onError = (err) => { + if (this.#sawError) + return; + this.#sawError = true; + this.close(); + this.emit("error", err); + }; + this.#handle?.on("error", (er) => this.#onError(new ZlibError(er))); + this.once("end", () => this.close); + } + close() { + if (this.#handle) { + this.#handle.close(); + this.#handle = void 0; + this.emit("close"); + } + } + reset() { + if (!this.#sawError) { + (0, import_assert2.default)(this.#handle, "zlib binding closed"); + return this.#handle.reset?.(); + } + } + flush(flushFlag) { + if (this.ended) + return; + if (typeof flushFlag !== "number") + flushFlag = this.#fullFlushFlag; + this.write(Object.assign(import_buffer.Buffer.alloc(0), { [_flushFlag]: flushFlag })); + } + end(chunk, encoding, cb) { + if (typeof chunk === "function") { + cb = chunk; + encoding = void 0; + chunk = void 0; + } + if (typeof encoding === "function") { + cb = encoding; + encoding = void 0; + } + if (chunk) { + if (encoding) + this.write(chunk, encoding); + else + this.write(chunk); + } + this.flush(this.#finishFlushFlag); + this.#ended = true; + return super.end(cb); + } + get ended() { + return this.#ended; } + // overridden in the gzip classes to do portable writes [_superWrite](data) { - if (!this[_portable]) - return super[_superWrite](data); - this[_portable] = false; - data[9] = 255; - return super[_superWrite](data); + return super.write(data); } - }; - var Gunzip = class extends Zlib { - constructor(opts) { - super(opts, "Gunzip"); + write(chunk, encoding, cb) { + if (typeof encoding === "function") + cb = encoding, encoding = "utf8"; + if (typeof chunk === "string") + chunk = import_buffer.Buffer.from(chunk, encoding); + if (this.#sawError) + return; + (0, import_assert2.default)(this.#handle, "zlib binding closed"); + const nativeHandle = this.#handle._handle; + const originalNativeClose = nativeHandle.close; + nativeHandle.close = () => { + }; + const originalClose = this.#handle.close; + this.#handle.close = () => { + }; + import_buffer.Buffer.concat = (args) => args; + let result = void 0; + try { + const flushFlag = typeof chunk[_flushFlag] === "number" ? chunk[_flushFlag] : this.#flushFlag; + result = this.#handle._processChunk(chunk, flushFlag); + import_buffer.Buffer.concat = OriginalBufferConcat; + } catch (err) { + import_buffer.Buffer.concat = OriginalBufferConcat; + this.#onError(new ZlibError(err)); + } finally { + if (this.#handle) { + ; + this.#handle._handle = nativeHandle; + nativeHandle.close = originalNativeClose; + this.#handle.close = originalClose; + this.#handle.removeAllListeners("error"); + } + } + if (this.#handle) + this.#handle.on("error", (er) => this.#onError(new ZlibError(er))); + let writeReturn; + if (result) { + if (Array.isArray(result) && result.length > 0) { + const r = result[0]; + writeReturn = this[_superWrite](import_buffer.Buffer.from(r)); + for (let i = 1; i < result.length; i++) { + writeReturn = this[_superWrite](result[i]); + } + } else { + writeReturn = this[_superWrite](import_buffer.Buffer.from(result)); + } + } + if (cb) + cb(); + return writeReturn; } }; - var DeflateRaw = class extends Zlib { - constructor(opts) { - super(opts, "DeflateRaw"); + Zlib = class extends ZlibBase { + #level; + #strategy; + constructor(opts, mode) { + opts = opts || {}; + opts.flush = opts.flush || constants.Z_NO_FLUSH; + opts.finishFlush = opts.finishFlush || constants.Z_FINISH; + opts.fullFlushFlag = constants.Z_FULL_FLUSH; + super(opts, mode); + this.#level = opts.level; + this.#strategy = opts.strategy; + } + params(level, strategy) { + if (this.sawError) + return; + if (!this.handle) + throw new Error("cannot switch params when binding is closed"); + if (!this.handle.params) + throw new Error("not supported in this implementation"); + if (this.#level !== level || this.#strategy !== strategy) { + this.flush(constants.Z_SYNC_FLUSH); + (0, import_assert2.default)(this.handle, "zlib binding closed"); + const origFlush = this.handle.flush; + this.handle.flush = (flushFlag, cb) => { + if (typeof flushFlag === "function") { + cb = flushFlag; + flushFlag = this.flushFlag; + } + this.flush(flushFlag); + cb?.(); + }; + try { + ; + this.handle.params(level, strategy); + } finally { + this.handle.flush = origFlush; + } + if (this.handle) { + this.#level = level; + this.#strategy = strategy; + } + } } }; - var InflateRaw = class extends Zlib { + Gzip = class extends Zlib { + #portable; constructor(opts) { - super(opts, "InflateRaw"); + super(opts, "Gzip"); + this.#portable = opts && !!opts.portable; + } + [_superWrite](data) { + if (!this.#portable) + return super[_superWrite](data); + this.#portable = false; + data[9] = 255; + return super[_superWrite](data); } }; - var Unzip = class extends Zlib { + Unzip = class extends Zlib { constructor(opts) { super(opts, "Unzip"); } }; - var Brotli = class extends ZlibBase { + Brotli = class extends ZlibBase { constructor(opts, mode) { opts = opts || {}; opts.flush = opts.flush || constants.BROTLI_OPERATION_PROCESS; opts.finishFlush = opts.finishFlush || constants.BROTLI_OPERATION_FINISH; + opts.fullFlushFlag = constants.BROTLI_OPERATION_FLUSH; super(opts, mode); - this[_fullFlushFlag] = constants.BROTLI_OPERATION_FLUSH; } }; - var BrotliCompress = class extends Brotli { + BrotliCompress = class extends Brotli { constructor(opts) { super(opts, "BrotliCompress"); } }; - var BrotliDecompress = class extends Brotli { + BrotliDecompress = class extends Brotli { constructor(opts) { super(opts, "BrotliDecompress"); } }; - exports2.Deflate = Deflate; - exports2.Inflate = Inflate; - exports2.Gzip = Gzip; - exports2.Gunzip = Gunzip; - exports2.DeflateRaw = DeflateRaw; - exports2.InflateRaw = InflateRaw; - exports2.Unzip = Unzip; - if (typeof realZlib.BrotliCompress === "function") { - exports2.BrotliCompress = BrotliCompress; - exports2.BrotliDecompress = BrotliDecompress; - } else { - exports2.BrotliCompress = exports2.BrotliDecompress = class { - constructor() { - throw new Error("Brotli is not supported in this version of Node.js"); - } - }; - } } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/normalize-windows-path.js -var require_normalize_windows_path = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/normalize-windows-path.js"(exports2, module2) { - var platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform; - module2.exports = platform !== "win32" ? (p) => p : (p) => p && p.replace(/\\/g, "/"); +// .yarn/cache/yallist-npm-5.0.0-8732dd9f1c-a499c81ce6.zip/node_modules/yallist/dist/esm/index.js +function insertAfter(self2, node, value) { + const prev = node; + const next = node ? node.next : self2.head; + const inserted = new Node(value, prev, next, self2); + if (inserted.next === void 0) { + self2.tail = inserted; + } + if (inserted.prev === void 0) { + self2.head = inserted; + } + self2.length++; + return inserted; +} +function push(self2, item) { + self2.tail = new Node(item, self2.tail, void 0, self2); + if (!self2.head) { + self2.head = self2.tail; } -}); - -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/read-entry.js -var require_read_entry = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/read-entry.js"(exports2, module2) { - "use strict"; - var { Minipass } = require_minipass(); - var normPath = require_normalize_windows_path(); - var SLURP = Symbol("slurp"); - module2.exports = class ReadEntry extends Minipass { - constructor(header, ex, gex) { - super(); - this.pause(); - this.extended = ex; - this.globalExtended = gex; - this.header = header; - this.startBlockSize = 512 * Math.ceil(header.size / 512); - this.blockRemain = this.startBlockSize; - this.remain = header.size; - this.type = header.type; - this.meta = false; - this.ignore = false; - switch (this.type) { - case "File": - case "OldFile": - case "Link": - case "SymbolicLink": - case "CharacterDevice": - case "BlockDevice": - case "Directory": - case "FIFO": - case "ContiguousFile": - case "GNUDumpDir": - break; - case "NextFileHasLongLinkpath": - case "NextFileHasLongPath": - case "OldGnuLongPath": - case "GlobalExtendedHeader": - case "ExtendedHeader": - case "OldExtendedHeader": - this.meta = true; - break; - default: - this.ignore = true; + self2.length++; +} +function unshift(self2, item) { + self2.head = new Node(item, void 0, self2.head, self2); + if (!self2.tail) { + self2.tail = self2.head; + } + self2.length++; +} +var Yallist, Node; +var init_esm4 = __esm({ + ".yarn/cache/yallist-npm-5.0.0-8732dd9f1c-a499c81ce6.zip/node_modules/yallist/dist/esm/index.js"() { + Yallist = class _Yallist { + tail; + head; + length = 0; + static create(list2 = []) { + return new _Yallist(list2); + } + constructor(list2 = []) { + for (const item of list2) { + this.push(item); + } + } + *[Symbol.iterator]() { + for (let walker = this.head; walker; walker = walker.next) { + yield walker.value; } - this.path = normPath(header.path); - this.mode = header.mode; - if (this.mode) { - this.mode = this.mode & 4095; + } + removeNode(node) { + if (node.list !== this) { + throw new Error("removing node which does not belong to this list"); } - this.uid = header.uid; - this.gid = header.gid; - this.uname = header.uname; - this.gname = header.gname; - this.size = header.size; - this.mtime = header.mtime; - this.atime = header.atime; - this.ctime = header.ctime; - this.linkpath = normPath(header.linkpath); - this.uname = header.uname; - this.gname = header.gname; - if (ex) { - this[SLURP](ex); + const next = node.next; + const prev = node.prev; + if (next) { + next.prev = prev; } - if (gex) { - this[SLURP](gex, true); + if (prev) { + prev.next = next; + } + if (node === this.head) { + this.head = next; + } + if (node === this.tail) { + this.tail = prev; } + this.length--; + node.next = void 0; + node.prev = void 0; + node.list = void 0; + return next; } - write(data) { - const writeLen = data.length; - if (writeLen > this.blockRemain) { - throw new Error("writing more to entry than is appropriate"); + unshiftNode(node) { + if (node === this.head) { + return; } - const r = this.remain; - const br = this.blockRemain; - this.remain = Math.max(0, r - writeLen); - this.blockRemain = Math.max(0, br - writeLen); - if (this.ignore) { - return true; + if (node.list) { + node.list.removeNode(node); } - if (r >= writeLen) { - return super.write(data); + const head = this.head; + node.list = this; + node.next = head; + if (head) { + head.prev = node; + } + this.head = node; + if (!this.tail) { + this.tail = node; } - return super.write(data.slice(0, r)); + this.length++; } - [SLURP](ex, global2) { - for (const k in ex) { - if (ex[k] !== null && ex[k] !== void 0 && !(global2 && k === "path")) { - this[k] = k === "path" || k === "linkpath" ? normPath(ex[k]) : ex[k]; - } + pushNode(node) { + if (node === this.tail) { + return; + } + if (node.list) { + node.list.removeNode(node); + } + const tail = this.tail; + node.list = this; + node.prev = tail; + if (tail) { + tail.next = node; + } + this.tail = node; + if (!this.head) { + this.head = node; + } + this.length++; + } + push(...args) { + for (let i = 0, l = args.length; i < l; i++) { + push(this, args[i]); + } + return this.length; + } + unshift(...args) { + for (var i = 0, l = args.length; i < l; i++) { + unshift(this, args[i]); + } + return this.length; + } + pop() { + if (!this.tail) { + return void 0; + } + const res = this.tail.value; + const t = this.tail; + this.tail = this.tail.prev; + if (this.tail) { + this.tail.next = void 0; + } else { + this.head = void 0; + } + t.list = void 0; + this.length--; + return res; + } + shift() { + if (!this.head) { + return void 0; + } + const res = this.head.value; + const h = this.head; + this.head = this.head.next; + if (this.head) { + this.head.prev = void 0; + } else { + this.tail = void 0; + } + h.list = void 0; + this.length--; + return res; + } + forEach(fn2, thisp) { + thisp = thisp || this; + for (let walker = this.head, i = 0; !!walker; i++) { + fn2.call(thisp, walker.value, i, this); + walker = walker.next; + } + } + forEachReverse(fn2, thisp) { + thisp = thisp || this; + for (let walker = this.tail, i = this.length - 1; !!walker; i--) { + fn2.call(thisp, walker.value, i, this); + walker = walker.prev; + } + } + get(n) { + let i = 0; + let walker = this.head; + for (; !!walker && i < n; i++) { + walker = walker.next; + } + if (i === n && !!walker) { + return walker.value; + } + } + getReverse(n) { + let i = 0; + let walker = this.tail; + for (; !!walker && i < n; i++) { + walker = walker.prev; + } + if (i === n && !!walker) { + return walker.value; + } + } + map(fn2, thisp) { + thisp = thisp || this; + const res = new _Yallist(); + for (let walker = this.head; !!walker; ) { + res.push(fn2.call(thisp, walker.value, this)); + walker = walker.next; + } + return res; + } + mapReverse(fn2, thisp) { + thisp = thisp || this; + var res = new _Yallist(); + for (let walker = this.tail; !!walker; ) { + res.push(fn2.call(thisp, walker.value, this)); + walker = walker.prev; + } + return res; + } + reduce(fn2, initial) { + let acc; + let walker = this.head; + if (arguments.length > 1) { + acc = initial; + } else if (this.head) { + walker = this.head.next; + acc = this.head.value; + } else { + throw new TypeError("Reduce of empty list with no initial value"); + } + for (var i = 0; !!walker; i++) { + acc = fn2(acc, walker.value, i); + walker = walker.next; + } + return acc; + } + reduceReverse(fn2, initial) { + let acc; + let walker = this.tail; + if (arguments.length > 1) { + acc = initial; + } else if (this.tail) { + walker = this.tail.prev; + acc = this.tail.value; + } else { + throw new TypeError("Reduce of empty list with no initial value"); + } + for (let i = this.length - 1; !!walker; i--) { + acc = fn2(acc, walker.value, i); + walker = walker.prev; + } + return acc; + } + toArray() { + const arr = new Array(this.length); + for (let i = 0, walker = this.head; !!walker; i++) { + arr[i] = walker.value; + walker = walker.next; + } + return arr; + } + toArrayReverse() { + const arr = new Array(this.length); + for (let i = 0, walker = this.tail; !!walker; i++) { + arr[i] = walker.value; + walker = walker.prev; + } + return arr; + } + slice(from = 0, to = this.length) { + if (to < 0) { + to += this.length; + } + if (from < 0) { + from += this.length; + } + const ret = new _Yallist(); + if (to < from || to < 0) { + return ret; + } + if (from < 0) { + from = 0; + } + if (to > this.length) { + to = this.length; + } + let walker = this.head; + let i = 0; + for (i = 0; !!walker && i < from; i++) { + walker = walker.next; + } + for (; !!walker && i < to; i++, walker = walker.next) { + ret.push(walker.value); + } + return ret; + } + sliceReverse(from = 0, to = this.length) { + if (to < 0) { + to += this.length; + } + if (from < 0) { + from += this.length; + } + const ret = new _Yallist(); + if (to < from || to < 0) { + return ret; + } + if (from < 0) { + from = 0; + } + if (to > this.length) { + to = this.length; + } + let i = this.length; + let walker = this.tail; + for (; !!walker && i > to; i--) { + walker = walker.prev; + } + for (; !!walker && i > from; i--, walker = walker.prev) { + ret.push(walker.value); + } + return ret; + } + splice(start, deleteCount = 0, ...nodes) { + if (start > this.length) { + start = this.length - 1; + } + if (start < 0) { + start = this.length + start; + } + let walker = this.head; + for (let i = 0; !!walker && i < start; i++) { + walker = walker.next; + } + const ret = []; + for (let i = 0; !!walker && i < deleteCount; i++) { + ret.push(walker.value); + walker = this.removeNode(walker); + } + if (!walker) { + walker = this.tail; + } else if (walker !== this.tail) { + walker = walker.prev; + } + for (const v of nodes) { + walker = insertAfter(this, walker, v); + } + return ret; + } + reverse() { + const head = this.head; + const tail = this.tail; + for (let walker = head; !!walker; walker = walker.prev) { + const p = walker.prev; + walker.prev = walker.next; + walker.next = p; + } + this.head = tail; + this.tail = head; + return this; + } + }; + Node = class { + list; + next; + prev; + value; + constructor(value, prev, next, list2) { + this.list = list2; + this.value = value; + if (prev) { + prev.next = this; + this.prev = prev; + } else { + this.prev = void 0; + } + if (next) { + next.prev = this; + this.next = next; + } else { + this.next = void 0; } } }; } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/types.js -var require_types = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/types.js"(exports2) { - "use strict"; - exports2.name = /* @__PURE__ */ new Map([ - ["0", "File"], - // same as File - ["", "OldFile"], - ["1", "Link"], - ["2", "SymbolicLink"], - // Devices and FIFOs aren't fully supported - // they are parsed, but skipped when unpacking - ["3", "CharacterDevice"], - ["4", "BlockDevice"], - ["5", "Directory"], - ["6", "FIFO"], - // same as File - ["7", "ContiguousFile"], - // pax headers - ["g", "GlobalExtendedHeader"], - ["x", "ExtendedHeader"], - // vendor-specific stuff - // skip - ["A", "SolarisACL"], - // like 5, but with data, which should be skipped - ["D", "GNUDumpDir"], - // metadata only, skip - ["I", "Inode"], - // data = link path of next file - ["K", "NextFileHasLongLinkpath"], - // data = path of next file - ["L", "NextFileHasLongPath"], - // skip - ["M", "ContinuationFile"], - // like L - ["N", "OldGnuLongPath"], - // skip - ["S", "SparseFile"], - // skip - ["V", "TapeVolumeHeader"], - // like x - ["X", "OldExtendedHeader"] - ]); - exports2.code = new Map(Array.from(exports2.name).map((kv) => [kv[1], kv[0]])); - } -}); - -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/large-numbers.js -var require_large_numbers = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/large-numbers.js"(exports2, module2) { - "use strict"; - var encode = (num, buf) => { +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/large-numbers.js +var encode, encodePositive, encodeNegative, parse, twos, pos, onesComp, twosComp; +var init_large_numbers = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/large-numbers.js"() { + encode = (num, buf) => { if (!Number.isSafeInteger(num)) { throw Error("cannot encode number outside of javascript safe integer range"); } else if (num < 0) { @@ -13470,14 +14041,14 @@ var require_large_numbers = __commonJS({ } return buf; }; - var encodePositive = (num, buf) => { + encodePositive = (num, buf) => { buf[0] = 128; for (var i = buf.length; i > 1; i--) { buf[i - 1] = num & 255; num = Math.floor(num / 256); } }; - var encodeNegative = (num, buf) => { + encodeNegative = (num, buf) => { buf[0] = 255; var flipped = false; num = num * -1; @@ -13494,9 +14065,9 @@ var require_large_numbers = __commonJS({ } } }; - var parse = (buf) => { + parse = (buf) => { const pre = buf[0]; - const value = pre === 128 ? pos(buf.slice(1, buf.length)) : pre === 255 ? twos(buf) : null; + const value = pre === 128 ? pos(buf.subarray(1, buf.length)) : pre === 255 ? twos(buf) : null; if (value === null) { throw Error("invalid base256 encoding"); } @@ -13505,12 +14076,12 @@ var require_large_numbers = __commonJS({ } return value; }; - var twos = (buf) => { + twos = (buf) => { var len = buf.length; var sum = 0; var flipped = false; for (var i = len - 1; i > -1; i--) { - var byte = buf[i]; + var byte = Number(buf[i]); var f; if (flipped) { f = onesComp(byte); @@ -13526,60 +14097,104 @@ var require_large_numbers = __commonJS({ } return sum; }; - var pos = (buf) => { + pos = (buf) => { var len = buf.length; var sum = 0; for (var i = len - 1; i > -1; i--) { - var byte = buf[i]; + var byte = Number(buf[i]); if (byte !== 0) { sum += byte * Math.pow(256, len - i - 1); } } return sum; }; - var onesComp = (byte) => (255 ^ byte) & 255; - var twosComp = (byte) => (255 ^ byte) + 1 & 255; - module2.exports = { - encode, - parse - }; + onesComp = (byte) => (255 ^ byte) & 255; + twosComp = (byte) => (255 ^ byte) + 1 & 255; } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/header.js -var require_header = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/header.js"(exports2, module2) { - "use strict"; - var types = require_types(); - var pathModule = require("path").posix; - var large = require_large_numbers(); - var SLURP = Symbol("slurp"); - var TYPE = Symbol("type"); - var Header = class { - constructor(data, off, ex, gex) { - this.cksumValid = false; - this.needPax = false; - this.nullBlock = false; - this.block = null; - this.path = null; - this.mode = null; - this.uid = null; - this.gid = null; - this.size = null; - this.mtime = null; - this.cksum = null; - this[TYPE] = "0"; - this.linkpath = null; - this.uname = null; - this.gname = null; - this.devmaj = 0; - this.devmin = 0; - this.atime = null; - this.ctime = null; +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/types.js +var isCode, name, code; +var init_types = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/types.js"() { + isCode = (c) => name.has(c); + name = /* @__PURE__ */ new Map([ + ["0", "File"], + // same as File + ["", "OldFile"], + ["1", "Link"], + ["2", "SymbolicLink"], + // Devices and FIFOs aren't fully supported + // they are parsed, but skipped when unpacking + ["3", "CharacterDevice"], + ["4", "BlockDevice"], + ["5", "Directory"], + ["6", "FIFO"], + // same as File + ["7", "ContiguousFile"], + // pax headers + ["g", "GlobalExtendedHeader"], + ["x", "ExtendedHeader"], + // vendor-specific stuff + // skip + ["A", "SolarisACL"], + // like 5, but with data, which should be skipped + ["D", "GNUDumpDir"], + // metadata only, skip + ["I", "Inode"], + // data = link path of next file + ["K", "NextFileHasLongLinkpath"], + // data = path of next file + ["L", "NextFileHasLongPath"], + // skip + ["M", "ContinuationFile"], + // like L + ["N", "OldGnuLongPath"], + // skip + ["S", "SparseFile"], + // skip + ["V", "TapeVolumeHeader"], + // like x + ["X", "OldExtendedHeader"] + ]); + code = new Map(Array.from(name).map((kv) => [kv[1], kv[0]])); + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/header.js +var import_node_path, Header, splitPrefix, decString, decDate, numToDate, decNumber, nanUndef, decSmallNumber, MAXNUM, encNumber, encSmallNumber, octalString, padOctal, encDate, NULLS, encString; +var init_header = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/header.js"() { + import_node_path = require("node:path"); + init_large_numbers(); + init_types(); + Header = class { + cksumValid = false; + needPax = false; + nullBlock = false; + block; + path; + mode; + uid; + gid; + size; + cksum; + #type = "Unsupported"; + linkpath; + uname; + gname; + devmaj = 0; + devmin = 0; + atime; + ctime; + mtime; + charset; + comment; + constructor(data, off = 0, ex, gex) { if (Buffer.isBuffer(data)) { this.decode(data, off || 0, ex, gex); } else if (data) { - this.set(data); + this.#slurp(data); } } decode(buf, off, ex, gex) { @@ -13596,24 +14211,26 @@ var require_header = __commonJS({ this.size = decNumber(buf, off + 124, 12); this.mtime = decDate(buf, off + 136, 12); this.cksum = decNumber(buf, off + 148, 12); - this[SLURP](ex); - this[SLURP](gex, true); - this[TYPE] = decString(buf, off + 156, 1); - if (this[TYPE] === "") { - this[TYPE] = "0"; - } - if (this[TYPE] === "0" && this.path.slice(-1) === "/") { - this[TYPE] = "5"; - } - if (this[TYPE] === "5") { + if (gex) + this.#slurp(gex, true); + if (ex) + this.#slurp(ex); + const t = decString(buf, off + 156, 1); + if (isCode(t)) { + this.#type = t || "0"; + } + if (this.#type === "0" && this.path.slice(-1) === "/") { + this.#type = "5"; + } + if (this.#type === "5") { this.size = 0; } this.linkpath = decString(buf, off + 157, 100); - if (buf.slice(off + 257, off + 265).toString() === "ustar\x0000") { + if (buf.subarray(off + 257, off + 265).toString() === "ustar\x0000") { this.uname = decString(buf, off + 265, 32); this.gname = decString(buf, off + 297, 32); - this.devmaj = decNumber(buf, off + 329, 8); - this.devmin = decNumber(buf, off + 337, 8); + this.devmaj = decNumber(buf, off + 329, 8) ?? 0; + this.devmin = decNumber(buf, off + 337, 8) ?? 0; if (buf[off + 475] !== 0) { const prefix = decString(buf, off + 345, 155); this.path = prefix + "/" + this.path; @@ -13634,40 +14251,37 @@ var require_header = __commonJS({ sum += buf[i]; } this.cksumValid = sum === this.cksum; - if (this.cksum === null && sum === 8 * 32) { + if (this.cksum === void 0 && sum === 8 * 32) { this.nullBlock = true; } } - [SLURP](ex, global2) { - for (const k in ex) { - if (ex[k] !== null && ex[k] !== void 0 && !(global2 && k === "path")) { - this[k] = ex[k]; - } - } + #slurp(ex, gex = false) { + Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => { + return !(v === null || v === void 0 || k === "path" && gex || k === "linkpath" && gex || k === "global"); + }))); } - encode(buf, off) { + encode(buf, off = 0) { if (!buf) { buf = this.block = Buffer.alloc(512); - off = 0; } - if (!off) { - off = 0; + if (this.#type === "Unsupported") { + this.#type = "0"; } if (!(buf.length >= off + 512)) { throw new Error("need 512 bytes for header"); } const prefixSize = this.ctime || this.atime ? 130 : 155; const split = splitPrefix(this.path || "", prefixSize); - const path10 = split[0]; + const path16 = split[0]; const prefix = split[1]; - this.needPax = split[2]; - this.needPax = encString(buf, off, 100, path10) || this.needPax; + this.needPax = !!split[2]; + this.needPax = encString(buf, off, 100, path16) || this.needPax; this.needPax = encNumber(buf, off + 100, 8, this.mode) || this.needPax; this.needPax = encNumber(buf, off + 108, 8, this.uid) || this.needPax; this.needPax = encNumber(buf, off + 116, 8, this.gid) || this.needPax; this.needPax = encNumber(buf, off + 124, 12, this.size) || this.needPax; this.needPax = encDate(buf, off + 136, 12, this.mtime) || this.needPax; - buf[off + 156] = this[TYPE].charCodeAt(0); + buf[off + 156] = this.#type.charCodeAt(0); this.needPax = encString(buf, off + 157, 100, this.linkpath) || this.needPax; buf.write("ustar\x0000", off + 257, 8); this.needPax = encString(buf, off + 265, 32, this.uname) || this.needPax; @@ -13694,107 +14308,116 @@ var require_header = __commonJS({ this.cksumValid = true; return this.needPax; } - set(data) { - for (const i in data) { - if (data[i] !== null && data[i] !== void 0) { - this[i] = data[i]; - } - } - } get type() { - return types.name.get(this[TYPE]) || this[TYPE]; + return this.#type === "Unsupported" ? this.#type : name.get(this.#type); } get typeKey() { - return this[TYPE]; + return this.#type; } set type(type) { - if (types.code.has(type)) { - this[TYPE] = types.code.get(type); + const c = String(code.get(type)); + if (isCode(c) || c === "Unsupported") { + this.#type = c; + } else if (isCode(type)) { + this.#type = type; } else { - this[TYPE] = type; + throw new TypeError("invalid entry type: " + type); } } }; - var splitPrefix = (p, prefixSize) => { + splitPrefix = (p, prefixSize) => { const pathSize = 100; let pp = p; let prefix = ""; - let ret; - const root = pathModule.parse(p).root || "."; + let ret = void 0; + const root = import_node_path.posix.parse(p).root || "."; if (Buffer.byteLength(pp) < pathSize) { ret = [pp, prefix, false]; } else { - prefix = pathModule.dirname(pp); - pp = pathModule.basename(pp); + prefix = import_node_path.posix.dirname(pp); + pp = import_node_path.posix.basename(pp); do { if (Buffer.byteLength(pp) <= pathSize && Buffer.byteLength(prefix) <= prefixSize) { ret = [pp, prefix, false]; } else if (Buffer.byteLength(pp) > pathSize && Buffer.byteLength(prefix) <= prefixSize) { ret = [pp.slice(0, pathSize - 1), prefix, true]; } else { - pp = pathModule.join(pathModule.basename(prefix), pp); - prefix = pathModule.dirname(prefix); + pp = import_node_path.posix.join(import_node_path.posix.basename(prefix), pp); + prefix = import_node_path.posix.dirname(prefix); } - } while (prefix !== root && !ret); + } while (prefix !== root && ret === void 0); if (!ret) { ret = [p.slice(0, pathSize - 1), "", true]; } } return ret; }; - var decString = (buf, off, size) => buf.slice(off, off + size).toString("utf8").replace(/\0.*/, ""); - var decDate = (buf, off, size) => numToDate(decNumber(buf, off, size)); - var numToDate = (num) => num === null ? null : new Date(num * 1e3); - var decNumber = (buf, off, size) => buf[off] & 128 ? large.parse(buf.slice(off, off + size)) : decSmallNumber(buf, off, size); - var nanNull = (value) => isNaN(value) ? null : value; - var decSmallNumber = (buf, off, size) => nanNull(parseInt( - buf.slice(off, off + size).toString("utf8").replace(/\0.*$/, "").trim(), - 8 - )); - var MAXNUM = { + decString = (buf, off, size) => buf.subarray(off, off + size).toString("utf8").replace(/\0.*/, ""); + decDate = (buf, off, size) => numToDate(decNumber(buf, off, size)); + numToDate = (num) => num === void 0 ? void 0 : new Date(num * 1e3); + decNumber = (buf, off, size) => Number(buf[off]) & 128 ? parse(buf.subarray(off, off + size)) : decSmallNumber(buf, off, size); + nanUndef = (value) => isNaN(value) ? void 0 : value; + decSmallNumber = (buf, off, size) => nanUndef(parseInt(buf.subarray(off, off + size).toString("utf8").replace(/\0.*$/, "").trim(), 8)); + MAXNUM = { 12: 8589934591, 8: 2097151 }; - var encNumber = (buf, off, size, number) => number === null ? false : number > MAXNUM[size] || number < 0 ? (large.encode(number, buf.slice(off, off + size)), true) : (encSmallNumber(buf, off, size, number), false); - var encSmallNumber = (buf, off, size, number) => buf.write(octalString(number, size), off, size, "ascii"); - var octalString = (number, size) => padOctal(Math.floor(number).toString(8), size); - var padOctal = (string, size) => (string.length === size - 1 ? string : new Array(size - string.length - 1).join("0") + string + " ") + "\0"; - var encDate = (buf, off, size, date) => date === null ? false : encNumber(buf, off, size, date.getTime() / 1e3); - var NULLS = new Array(156).join("\0"); - var encString = (buf, off, size, string) => string === null ? false : (buf.write(string + NULLS, off, size, "utf8"), string.length !== Buffer.byteLength(string) || string.length > size); - module2.exports = Header; + encNumber = (buf, off, size, num) => num === void 0 ? false : num > MAXNUM[size] || num < 0 ? (encode(num, buf.subarray(off, off + size)), true) : (encSmallNumber(buf, off, size, num), false); + encSmallNumber = (buf, off, size, num) => buf.write(octalString(num, size), off, size, "ascii"); + octalString = (num, size) => padOctal(Math.floor(num).toString(8), size); + padOctal = (str, size) => (str.length === size - 1 ? str : new Array(size - str.length - 1).join("0") + str + " ") + "\0"; + encDate = (buf, off, size, date) => date === void 0 ? false : encNumber(buf, off, size, date.getTime() / 1e3); + NULLS = new Array(156).join("\0"); + encString = (buf, off, size, str) => str === void 0 ? false : (buf.write(str + NULLS, off, size, "utf8"), str.length !== Buffer.byteLength(str) || str.length > size); } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/pax.js -var require_pax = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/pax.js"(exports2, module2) { - "use strict"; - var Header = require_header(); - var path10 = require("path"); - var Pax = class { - constructor(obj, global2) { - this.atime = obj.atime || null; - this.charset = obj.charset || null; - this.comment = obj.comment || null; - this.ctime = obj.ctime || null; - this.gid = obj.gid || null; - this.gname = obj.gname || null; - this.linkpath = obj.linkpath || null; - this.mtime = obj.mtime || null; - this.path = obj.path || null; - this.size = obj.size || null; - this.uid = obj.uid || null; - this.uname = obj.uname || null; - this.dev = obj.dev || null; - this.ino = obj.ino || null; - this.nlink = obj.nlink || null; - this.global = global2 || false; +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/pax.js +var import_node_path2, Pax, merge, parseKV, parseKVLine; +var init_pax = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/pax.js"() { + import_node_path2 = require("node:path"); + init_header(); + Pax = class _Pax { + atime; + mtime; + ctime; + charset; + comment; + gid; + uid; + gname; + uname; + linkpath; + dev; + ino; + nlink; + path; + size; + mode; + global; + constructor(obj, global2 = false) { + this.atime = obj.atime; + this.charset = obj.charset; + this.comment = obj.comment; + this.ctime = obj.ctime; + this.dev = obj.dev; + this.gid = obj.gid; + this.global = global2; + this.gname = obj.gname; + this.ino = obj.ino; + this.linkpath = obj.linkpath; + this.mtime = obj.mtime; + this.nlink = obj.nlink; + this.path = obj.path; + this.size = obj.size; + this.uid = obj.uid; + this.uname = obj.uname; } encode() { const body = this.encodeBody(); if (body === "") { - return null; + return Buffer.allocUnsafe(0); } const bodyLen = Buffer.byteLength(body); const bufLen = 512 * Math.ceil(1 + bodyLen / 512); @@ -13806,20 +14429,22 @@ var require_pax = __commonJS({ // XXX split the path // then the path should be PaxHeader + basename, but less than 99, // prepend with the dirname - path: ("PaxHeader/" + path10.basename(this.path)).slice(0, 99), + /* c8 ignore start */ + path: ("PaxHeader/" + (0, import_node_path2.basename)(this.path ?? "")).slice(0, 99), + /* c8 ignore stop */ mode: this.mode || 420, - uid: this.uid || null, - gid: this.gid || null, + uid: this.uid, + gid: this.gid, size: bodyLen, - mtime: this.mtime || null, + mtime: this.mtime, type: this.global ? "GlobalExtendedHeader" : "ExtendedHeader", linkpath: "", uname: this.uname || "", gname: this.gname || "", devmaj: 0, devmin: 0, - atime: this.atime || null, - ctime: this.ctime || null + atime: this.atime, + ctime: this.ctime }).encode(buf); buf.write(body, 512, bodyLen, "utf8"); for (let i = bodyLen + 512; i < buf.length; i++) { @@ -13831,10 +14456,11 @@ var require_pax = __commonJS({ return this.encodeField("path") + this.encodeField("ctime") + this.encodeField("atime") + this.encodeField("dev") + this.encodeField("ino") + this.encodeField("nlink") + this.encodeField("charset") + this.encodeField("comment") + this.encodeField("gid") + this.encodeField("gname") + this.encodeField("linkpath") + this.encodeField("mtime") + this.encodeField("size") + this.encodeField("uid") + this.encodeField("uname"); } encodeField(field) { - if (this[field] === null || this[field] === void 0) { + if (this[field] === void 0) { return ""; } - const v = this[field] instanceof Date ? this[field].getTime() / 1e3 : this[field]; + const r = this[field]; + const v = r instanceof Date ? r.getTime() / 1e3 : r; const s = " " + (field === "dev" || field === "ino" || field === "nlink" ? "SCHILY." : "") + field + "=" + v + "\n"; const byteLen = Buffer.byteLength(s); let digits = Math.floor(Math.log(byteLen) / Math.log(10)) + 1; @@ -13844,5781 +14470,5127 @@ var require_pax = __commonJS({ const len = digits + byteLen; return len + s; } + static parse(str, ex, g = false) { + return new _Pax(merge(parseKV(str), ex), g); + } }; - Pax.parse = (string, ex, g) => new Pax(merge(parseKV(string), ex), g); - var merge = (a, b) => b ? Object.keys(a).reduce((s, k) => (s[k] = a[k], s), b) : a; - var parseKV = (string) => string.replace(/\n$/, "").split("\n").reduce(parseKVLine, /* @__PURE__ */ Object.create(null)); - var parseKVLine = (set, line) => { + merge = (a, b) => b ? Object.assign({}, b, a) : a; + parseKV = (str) => str.replace(/\n$/, "").split("\n").reduce(parseKVLine, /* @__PURE__ */ Object.create(null)); + parseKVLine = (set, line) => { const n = parseInt(line, 10); if (n !== Buffer.byteLength(line) + 1) { return set; } line = line.slice((n + " ").length); const kv = line.split("="); - const k = kv.shift().replace(/^SCHILY\.(dev|ino|nlink)/, "$1"); - if (!k) { + const r = kv.shift(); + if (!r) { return set; } + const k = r.replace(/^SCHILY\.(dev|ino|nlink)/, "$1"); const v = kv.join("="); - set[k] = /^([A-Z]+\.)?([mac]|birth|creation)time$/.test(k) ? new Date(v * 1e3) : /^[0-9]+$/.test(v) ? +v : v; + set[k] = /^([A-Z]+\.)?([mac]|birth|creation)time$/.test(k) ? new Date(Number(v) * 1e3) : /^[0-9]+$/.test(v) ? +v : v; return set; }; - module2.exports = Pax; - } -}); - -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/strip-trailing-slashes.js -var require_strip_trailing_slashes = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/strip-trailing-slashes.js"(exports2, module2) { - module2.exports = (str) => { - let i = str.length - 1; - let slashesStart = -1; - while (i > -1 && str.charAt(i) === "/") { - slashesStart = i; - i--; - } - return slashesStart === -1 ? str : str.slice(0, slashesStart); - }; - } -}); - -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/warn-mixin.js -var require_warn_mixin = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/warn-mixin.js"(exports2, module2) { - "use strict"; - module2.exports = (Base) => class extends Base { - warn(code, message, data = {}) { - if (this.file) { - data.file = this.file; - } - if (this.cwd) { - data.cwd = this.cwd; - } - data.code = message instanceof Error && message.code || code; - data.tarCode = code; - if (!this.strict && data.recoverable !== false) { - if (message instanceof Error) { - data = Object.assign(message, data); - message = message.message; - } - this.emit("warn", data.tarCode, message, data); - } else if (message instanceof Error) { - this.emit("error", Object.assign(message, data)); - } else { - this.emit("error", Object.assign(new Error(`${code}: ${message}`), data)); - } - } - }; } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/winchars.js -var require_winchars = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/winchars.js"(exports2, module2) { - "use strict"; - var raw = [ - "|", - "<", - ">", - "?", - ":" - ]; - var win = raw.map((char) => String.fromCharCode(61440 + char.charCodeAt(0))); - var toWin = new Map(raw.map((char, i) => [char, win[i]])); - var toRaw = new Map(win.map((char, i) => [char, raw[i]])); - module2.exports = { - encode: (s) => raw.reduce((s2, c) => s2.split(c).join(toWin.get(c)), s), - decode: (s) => win.reduce((s2, c) => s2.split(c).join(toRaw.get(c)), s) - }; +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/normalize-windows-path.js +var platform, normalizeWindowsPath; +var init_normalize_windows_path = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/normalize-windows-path.js"() { + platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform; + normalizeWindowsPath = platform !== "win32" ? (p) => p : (p) => p && p.replace(/\\/g, "/"); } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/strip-absolute-path.js -var require_strip_absolute_path = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/strip-absolute-path.js"(exports2, module2) { - var { isAbsolute, parse } = require("path").win32; - module2.exports = (path10) => { - let r = ""; - let parsed = parse(path10); - while (isAbsolute(path10) || parsed.root) { - const root = path10.charAt(0) === "/" && path10.slice(0, 4) !== "//?/" ? "/" : parsed.root; - path10 = path10.slice(root.length); - r += root; - parsed = parse(path10); +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/read-entry.js +var ReadEntry; +var init_read_entry = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/read-entry.js"() { + init_esm(); + init_normalize_windows_path(); + ReadEntry = class extends Minipass { + extended; + globalExtended; + header; + startBlockSize; + blockRemain; + remain; + type; + meta = false; + ignore = false; + path; + mode; + uid; + gid; + uname; + gname; + size = 0; + mtime; + atime; + ctime; + linkpath; + dev; + ino; + nlink; + invalid = false; + absolute; + unsupported = false; + constructor(header, ex, gex) { + super({}); + this.pause(); + this.extended = ex; + this.globalExtended = gex; + this.header = header; + this.remain = header.size ?? 0; + this.startBlockSize = 512 * Math.ceil(this.remain / 512); + this.blockRemain = this.startBlockSize; + this.type = header.type; + switch (this.type) { + case "File": + case "OldFile": + case "Link": + case "SymbolicLink": + case "CharacterDevice": + case "BlockDevice": + case "Directory": + case "FIFO": + case "ContiguousFile": + case "GNUDumpDir": + break; + case "NextFileHasLongLinkpath": + case "NextFileHasLongPath": + case "OldGnuLongPath": + case "GlobalExtendedHeader": + case "ExtendedHeader": + case "OldExtendedHeader": + this.meta = true; + break; + default: + this.ignore = true; + } + if (!header.path) { + throw new Error("no path provided for tar.ReadEntry"); + } + this.path = normalizeWindowsPath(header.path); + this.mode = header.mode; + if (this.mode) { + this.mode = this.mode & 4095; + } + this.uid = header.uid; + this.gid = header.gid; + this.uname = header.uname; + this.gname = header.gname; + this.size = this.remain; + this.mtime = header.mtime; + this.atime = header.atime; + this.ctime = header.ctime; + this.linkpath = header.linkpath ? normalizeWindowsPath(header.linkpath) : void 0; + this.uname = header.uname; + this.gname = header.gname; + if (ex) { + this.#slurp(ex); + } + if (gex) { + this.#slurp(gex, true); + } + } + write(data) { + const writeLen = data.length; + if (writeLen > this.blockRemain) { + throw new Error("writing more to entry than is appropriate"); + } + const r = this.remain; + const br = this.blockRemain; + this.remain = Math.max(0, r - writeLen); + this.blockRemain = Math.max(0, br - writeLen); + if (this.ignore) { + return true; + } + if (r >= writeLen) { + return super.write(data); + } + return super.write(data.subarray(0, r)); + } + #slurp(ex, gex = false) { + if (ex.path) + ex.path = normalizeWindowsPath(ex.path); + if (ex.linkpath) + ex.linkpath = normalizeWindowsPath(ex.linkpath); + Object.assign(this, Object.fromEntries(Object.entries(ex).filter(([k, v]) => { + return !(v === null || v === void 0 || k === "path" && gex); + }))); } - return [r, path10]; }; } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/mode-fix.js -var require_mode_fix = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/mode-fix.js"(exports2, module2) { - "use strict"; - module2.exports = (mode, isDir, portable) => { - mode &= 4095; - if (portable) { - mode = (mode | 384) & ~18; - } - if (isDir) { - if (mode & 256) { - mode |= 64; - } - if (mode & 32) { - mode |= 8; - } - if (mode & 4) { - mode |= 1; - } +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/warn-method.js +var warnMethod; +var init_warn_method = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/warn-method.js"() { + warnMethod = (self2, code2, message, data = {}) => { + if (self2.file) { + data.file = self2.file; + } + if (self2.cwd) { + data.cwd = self2.cwd; + } + data.code = message instanceof Error && message.code || code2; + data.tarCode = code2; + if (!self2.strict && data.recoverable !== false) { + if (message instanceof Error) { + data = Object.assign(message, data); + message = message.message; + } + self2.emit("warn", code2, message, data); + } else if (message instanceof Error) { + self2.emit("error", Object.assign(message, data)); + } else { + self2.emit("error", Object.assign(new Error(`${code2}: ${message}`), data)); } - return mode; }; } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/write-entry.js -var require_write_entry = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/write-entry.js"(exports2, module2) { - "use strict"; - var { Minipass } = require_minipass(); - var Pax = require_pax(); - var Header = require_header(); - var fs8 = require("fs"); - var path10 = require("path"); - var normPath = require_normalize_windows_path(); - var stripSlash = require_strip_trailing_slashes(); - var prefixPath = (path11, prefix) => { - if (!prefix) { - return normPath(path11); - } - path11 = normPath(path11).replace(/^\.(\/|$)/, ""); - return stripSlash(prefix) + "/" + path11; - }; - var maxReadSize = 16 * 1024 * 1024; - var PROCESS = Symbol("process"); - var FILE = Symbol("file"); - var DIRECTORY = Symbol("directory"); - var SYMLINK = Symbol("symlink"); - var HARDLINK = Symbol("hardlink"); - var HEADER = Symbol("header"); - var READ = Symbol("read"); - var LSTAT = Symbol("lstat"); - var ONLSTAT = Symbol("onlstat"); - var ONREAD = Symbol("onread"); - var ONREADLINK = Symbol("onreadlink"); - var OPENFILE = Symbol("openfile"); - var ONOPENFILE = Symbol("onopenfile"); - var CLOSE = Symbol("close"); - var MODE = Symbol("mode"); - var AWAITDRAIN = Symbol("awaitDrain"); - var ONDRAIN = Symbol("ondrain"); - var PREFIX = Symbol("prefix"); - var HAD_ERROR = Symbol("hadError"); - var warner = require_warn_mixin(); - var winchars = require_winchars(); - var stripAbsolutePath = require_strip_absolute_path(); - var modeFix = require_mode_fix(); - var WriteEntry = warner(class WriteEntry extends Minipass { - constructor(p, opt) { - opt = opt || {}; - super(opt); - if (typeof p !== "string") { - throw new TypeError("path is required"); +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/parse.js +var import_events3, maxMetaEntrySize, gzipHeader, STATE, WRITEENTRY, READENTRY, NEXTENTRY, PROCESSENTRY, EX, GEX, META, EMITMETA, BUFFER2, QUEUE, ENDED, EMITTEDEND, EMIT, UNZIP, CONSUMECHUNK, CONSUMECHUNKSUB, CONSUMEBODY, CONSUMEMETA, CONSUMEHEADER, CONSUMING, BUFFERCONCAT, MAYBEEND, WRITING, ABORTED2, DONE, SAW_VALID_ENTRY, SAW_NULL_BLOCK, SAW_EOF, CLOSESTREAM, noop, Parser; +var init_parse = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/parse.js"() { + import_events3 = require("events"); + init_esm3(); + init_esm4(); + init_header(); + init_pax(); + init_read_entry(); + init_warn_method(); + maxMetaEntrySize = 1024 * 1024; + gzipHeader = Buffer.from([31, 139]); + STATE = Symbol("state"); + WRITEENTRY = Symbol("writeEntry"); + READENTRY = Symbol("readEntry"); + NEXTENTRY = Symbol("nextEntry"); + PROCESSENTRY = Symbol("processEntry"); + EX = Symbol("extendedHeader"); + GEX = Symbol("globalExtendedHeader"); + META = Symbol("meta"); + EMITMETA = Symbol("emitMeta"); + BUFFER2 = Symbol("buffer"); + QUEUE = Symbol("queue"); + ENDED = Symbol("ended"); + EMITTEDEND = Symbol("emittedEnd"); + EMIT = Symbol("emit"); + UNZIP = Symbol("unzip"); + CONSUMECHUNK = Symbol("consumeChunk"); + CONSUMECHUNKSUB = Symbol("consumeChunkSub"); + CONSUMEBODY = Symbol("consumeBody"); + CONSUMEMETA = Symbol("consumeMeta"); + CONSUMEHEADER = Symbol("consumeHeader"); + CONSUMING = Symbol("consuming"); + BUFFERCONCAT = Symbol("bufferConcat"); + MAYBEEND = Symbol("maybeEnd"); + WRITING = Symbol("writing"); + ABORTED2 = Symbol("aborted"); + DONE = Symbol("onDone"); + SAW_VALID_ENTRY = Symbol("sawValidEntry"); + SAW_NULL_BLOCK = Symbol("sawNullBlock"); + SAW_EOF = Symbol("sawEOF"); + CLOSESTREAM = Symbol("closeStream"); + noop = () => true; + Parser = class extends import_events3.EventEmitter { + file; + strict; + maxMetaEntrySize; + filter; + brotli; + writable = true; + readable = false; + [QUEUE] = new Yallist(); + [BUFFER2]; + [READENTRY]; + [WRITEENTRY]; + [STATE] = "begin"; + [META] = ""; + [EX]; + [GEX]; + [ENDED] = false; + [UNZIP]; + [ABORTED2] = false; + [SAW_VALID_ENTRY]; + [SAW_NULL_BLOCK] = false; + [SAW_EOF] = false; + [WRITING] = false; + [CONSUMING] = false; + [EMITTEDEND] = false; + constructor(opt = {}) { + super(); + this.file = opt.file || ""; + this.on(DONE, () => { + if (this[STATE] === "begin" || this[SAW_VALID_ENTRY] === false) { + this.warn("TAR_BAD_ARCHIVE", "Unrecognized archive format"); + } + }); + if (opt.ondone) { + this.on(DONE, opt.ondone); + } else { + this.on(DONE, () => { + this.emit("prefinish"); + this.emit("finish"); + this.emit("end"); + }); } - this.path = normPath(p); - this.portable = !!opt.portable; - this.myuid = process.getuid && process.getuid() || 0; - this.myuser = process.env.USER || ""; - this.maxReadSize = opt.maxReadSize || maxReadSize; - this.linkCache = opt.linkCache || /* @__PURE__ */ new Map(); - this.statCache = opt.statCache || /* @__PURE__ */ new Map(); - this.preservePaths = !!opt.preservePaths; - this.cwd = normPath(opt.cwd || process.cwd()); this.strict = !!opt.strict; - this.noPax = !!opt.noPax; - this.noMtime = !!opt.noMtime; - this.mtime = opt.mtime || null; - this.prefix = opt.prefix ? normPath(opt.prefix) : null; - this.fd = null; - this.blockLen = null; - this.blockRemain = null; - this.buf = null; - this.offset = null; - this.length = null; - this.pos = null; - this.remain = null; + this.maxMetaEntrySize = opt.maxMetaEntrySize || maxMetaEntrySize; + this.filter = typeof opt.filter === "function" ? opt.filter : noop; + const isTBR = opt.file && (opt.file.endsWith(".tar.br") || opt.file.endsWith(".tbr")); + this.brotli = !opt.gzip && opt.brotli !== void 0 ? opt.brotli : isTBR ? void 0 : false; + this.on("end", () => this[CLOSESTREAM]()); if (typeof opt.onwarn === "function") { this.on("warn", opt.onwarn); } - let pathWarn = false; - if (!this.preservePaths) { - const [root, stripped] = stripAbsolutePath(this.path); - if (root) { - this.path = stripped; - pathWarn = root; - } - } - this.win32 = !!opt.win32 || process.platform === "win32"; - if (this.win32) { - this.path = winchars.decode(this.path.replace(/\\/g, "/")); - p = p.replace(/\\/g, "/"); + if (typeof opt.onReadEntry === "function") { + this.on("entry", opt.onReadEntry); } - this.absolute = normPath(opt.absolute || path10.resolve(this.cwd, p)); - if (this.path === "") { - this.path = "./"; + } + warn(code2, message, data = {}) { + warnMethod(this, code2, message, data); + } + [CONSUMEHEADER](chunk, position) { + if (this[SAW_VALID_ENTRY] === void 0) { + this[SAW_VALID_ENTRY] = false; } - if (pathWarn) { - this.warn("TAR_ENTRY_INFO", `stripping ${pathWarn} from absolute path`, { - entry: this, - path: pathWarn + this.path - }); + let header; + try { + header = new Header(chunk, position, this[EX], this[GEX]); + } catch (er) { + return this.warn("TAR_ENTRY_INVALID", er); } - if (this.statCache.has(this.absolute)) { - this[ONLSTAT](this.statCache.get(this.absolute)); + if (header.nullBlock) { + if (this[SAW_NULL_BLOCK]) { + this[SAW_EOF] = true; + if (this[STATE] === "begin") { + this[STATE] = "header"; + } + this[EMIT]("eof"); + } else { + this[SAW_NULL_BLOCK] = true; + this[EMIT]("nullBlock"); + } } else { - this[LSTAT](); + this[SAW_NULL_BLOCK] = false; + if (!header.cksumValid) { + this.warn("TAR_ENTRY_INVALID", "checksum failure", { header }); + } else if (!header.path) { + this.warn("TAR_ENTRY_INVALID", "path is required", { header }); + } else { + const type = header.type; + if (/^(Symbolic)?Link$/.test(type) && !header.linkpath) { + this.warn("TAR_ENTRY_INVALID", "linkpath required", { + header + }); + } else if (!/^(Symbolic)?Link$/.test(type) && !/^(Global)?ExtendedHeader$/.test(type) && header.linkpath) { + this.warn("TAR_ENTRY_INVALID", "linkpath forbidden", { + header + }); + } else { + const entry = this[WRITEENTRY] = new ReadEntry(header, this[EX], this[GEX]); + if (!this[SAW_VALID_ENTRY]) { + if (entry.remain) { + const onend = () => { + if (!entry.invalid) { + this[SAW_VALID_ENTRY] = true; + } + }; + entry.on("end", onend); + } else { + this[SAW_VALID_ENTRY] = true; + } + } + if (entry.meta) { + if (entry.size > this.maxMetaEntrySize) { + entry.ignore = true; + this[EMIT]("ignoredEntry", entry); + this[STATE] = "ignore"; + entry.resume(); + } else if (entry.size > 0) { + this[META] = ""; + entry.on("data", (c) => this[META] += c); + this[STATE] = "meta"; + } + } else { + this[EX] = void 0; + entry.ignore = entry.ignore || !this.filter(entry.path, entry); + if (entry.ignore) { + this[EMIT]("ignoredEntry", entry); + this[STATE] = entry.remain ? "ignore" : "header"; + entry.resume(); + } else { + if (entry.remain) { + this[STATE] = "body"; + } else { + this[STATE] = "header"; + entry.end(); + } + if (!this[READENTRY]) { + this[QUEUE].push(entry); + this[NEXTENTRY](); + } else { + this[QUEUE].push(entry); + } + } + } + } + } } } - emit(ev, ...data) { - if (ev === "error") { - this[HAD_ERROR] = true; - } - return super.emit(ev, ...data); + [CLOSESTREAM]() { + queueMicrotask(() => this.emit("close")); } - [LSTAT]() { - fs8.lstat(this.absolute, (er, stat) => { - if (er) { - return this.emit("error", er); + [PROCESSENTRY](entry) { + let go = true; + if (!entry) { + this[READENTRY] = void 0; + go = false; + } else if (Array.isArray(entry)) { + const [ev, ...args] = entry; + this.emit(ev, ...args); + } else { + this[READENTRY] = entry; + this.emit("entry", entry); + if (!entry.emittedEnd) { + entry.on("end", () => this[NEXTENTRY]()); + go = false; } - this[ONLSTAT](stat); - }); - } - [ONLSTAT](stat) { - this.statCache.set(this.absolute, stat); - this.stat = stat; - if (!stat.isFile()) { - stat.size = 0; } - this.type = getType(stat); - this.emit("stat", stat); - this[PROCESS](); + return go; } - [PROCESS]() { - switch (this.type) { - case "File": - return this[FILE](); - case "Directory": - return this[DIRECTORY](); - case "SymbolicLink": - return this[SYMLINK](); - default: - return this.end(); + [NEXTENTRY]() { + do { + } while (this[PROCESSENTRY](this[QUEUE].shift())); + if (!this[QUEUE].length) { + const re = this[READENTRY]; + const drainNow = !re || re.flowing || re.size === re.remain; + if (drainNow) { + if (!this[WRITING]) { + this.emit("drain"); + } + } else { + re.once("drain", () => this.emit("drain")); + } } } - [MODE](mode) { - return modeFix(mode, this.type === "Directory", this.portable); - } - [PREFIX](path11) { - return prefixPath(path11, this.prefix); - } - [HEADER]() { - if (this.type === "Directory" && this.portable) { - this.noMtime = true; + [CONSUMEBODY](chunk, position) { + const entry = this[WRITEENTRY]; + if (!entry) { + throw new Error("attempt to consume body without entry??"); } - this.header = new Header({ - path: this[PREFIX](this.path), - // only apply the prefix to hard links. - linkpath: this.type === "Link" ? this[PREFIX](this.linkpath) : this.linkpath, - // only the permissions and setuid/setgid/sticky bitflags - // not the higher-order bits that specify file type - mode: this[MODE](this.stat.mode), - uid: this.portable ? null : this.stat.uid, - gid: this.portable ? null : this.stat.gid, - size: this.stat.size, - mtime: this.noMtime ? null : this.mtime || this.stat.mtime, - type: this.type, - uname: this.portable ? null : this.stat.uid === this.myuid ? this.myuser : "", - atime: this.portable ? null : this.stat.atime, - ctime: this.portable ? null : this.stat.ctime - }); - if (this.header.encode() && !this.noPax) { - super.write(new Pax({ - atime: this.portable ? null : this.header.atime, - ctime: this.portable ? null : this.header.ctime, - gid: this.portable ? null : this.header.gid, - mtime: this.noMtime ? null : this.mtime || this.header.mtime, - path: this[PREFIX](this.path), - linkpath: this.type === "Link" ? this[PREFIX](this.linkpath) : this.linkpath, - size: this.header.size, - uid: this.portable ? null : this.header.uid, - uname: this.portable ? null : this.header.uname, - dev: this.portable ? null : this.stat.dev, - ino: this.portable ? null : this.stat.ino, - nlink: this.portable ? null : this.stat.nlink - }).encode()); + const br = entry.blockRemain ?? 0; + const c = br >= chunk.length && position === 0 ? chunk : chunk.subarray(position, position + br); + entry.write(c); + if (!entry.blockRemain) { + this[STATE] = "header"; + this[WRITEENTRY] = void 0; + entry.end(); } - super.write(this.header.block); + return c.length; } - [DIRECTORY]() { - if (this.path.slice(-1) !== "/") { - this.path += "/"; + [CONSUMEMETA](chunk, position) { + const entry = this[WRITEENTRY]; + const ret = this[CONSUMEBODY](chunk, position); + if (!this[WRITEENTRY] && entry) { + this[EMITMETA](entry); } - this.stat.size = 0; - this[HEADER](); - this.end(); - } - [SYMLINK]() { - fs8.readlink(this.absolute, (er, linkpath) => { - if (er) { - return this.emit("error", er); - } - this[ONREADLINK](linkpath); - }); - } - [ONREADLINK](linkpath) { - this.linkpath = normPath(linkpath); - this[HEADER](); - this.end(); - } - [HARDLINK](linkpath) { - this.type = "Link"; - this.linkpath = normPath(path10.relative(this.cwd, linkpath)); - this.stat.size = 0; - this[HEADER](); - this.end(); + return ret; } - [FILE]() { - if (this.stat.nlink > 1) { - const linkKey = this.stat.dev + ":" + this.stat.ino; - if (this.linkCache.has(linkKey)) { - const linkpath = this.linkCache.get(linkKey); - if (linkpath.indexOf(this.cwd) === 0) { - return this[HARDLINK](linkpath); - } - } - this.linkCache.set(linkKey, this.absolute); - } - this[HEADER](); - if (this.stat.size === 0) { - return this.end(); + [EMIT](ev, data, extra) { + if (!this[QUEUE].length && !this[READENTRY]) { + this.emit(ev, data, extra); + } else { + this[QUEUE].push([ev, data, extra]); } - this[OPENFILE](); } - [OPENFILE]() { - fs8.open(this.absolute, "r", (er, fd) => { - if (er) { - return this.emit("error", er); + [EMITMETA](entry) { + this[EMIT]("meta", this[META]); + switch (entry.type) { + case "ExtendedHeader": + case "OldExtendedHeader": + this[EX] = Pax.parse(this[META], this[EX], false); + break; + case "GlobalExtendedHeader": + this[GEX] = Pax.parse(this[META], this[GEX], true); + break; + case "NextFileHasLongPath": + case "OldGnuLongPath": { + const ex = this[EX] ?? /* @__PURE__ */ Object.create(null); + this[EX] = ex; + ex.path = this[META].replace(/\0.*/, ""); + break; } - this[ONOPENFILE](fd); - }); - } - [ONOPENFILE](fd) { - this.fd = fd; - if (this[HAD_ERROR]) { - return this[CLOSE](); - } - this.blockLen = 512 * Math.ceil(this.stat.size / 512); - this.blockRemain = this.blockLen; - const bufLen = Math.min(this.blockLen, this.maxReadSize); - this.buf = Buffer.allocUnsafe(bufLen); - this.offset = 0; - this.pos = 0; - this.remain = this.stat.size; - this.length = this.buf.length; - this[READ](); - } - [READ]() { - const { fd, buf, offset, length, pos } = this; - fs8.read(fd, buf, offset, length, pos, (er, bytesRead) => { - if (er) { - return this[CLOSE](() => this.emit("error", er)); + case "NextFileHasLongLinkpath": { + const ex = this[EX] || /* @__PURE__ */ Object.create(null); + this[EX] = ex; + ex.linkpath = this[META].replace(/\0.*/, ""); + break; } - this[ONREAD](bytesRead); - }); + default: + throw new Error("unknown meta: " + entry.type); + } } - [CLOSE](cb) { - fs8.close(this.fd, cb); + abort(error) { + this[ABORTED2] = true; + this.emit("abort", error); + this.warn("TAR_ABORT", error, { recoverable: false }); } - [ONREAD](bytesRead) { - if (bytesRead <= 0 && this.remain > 0) { - const er = new Error("encountered unexpected EOF"); - er.path = this.absolute; - er.syscall = "read"; - er.code = "EOF"; - return this[CLOSE](() => this.emit("error", er)); + write(chunk, encoding, cb) { + if (typeof encoding === "function") { + cb = encoding; + encoding = void 0; + } + if (typeof chunk === "string") { + chunk = Buffer.from( + chunk, + /* c8 ignore next */ + typeof encoding === "string" ? encoding : "utf8" + ); } - if (bytesRead > this.remain) { - const er = new Error("did not encounter expected EOF"); - er.path = this.absolute; - er.syscall = "read"; - er.code = "EOF"; - return this[CLOSE](() => this.emit("error", er)); + if (this[ABORTED2]) { + cb?.(); + return false; } - if (bytesRead === this.remain) { - for (let i = bytesRead; i < this.length && bytesRead < this.blockRemain; i++) { - this.buf[i + this.offset] = 0; - bytesRead++; - this.remain++; + const needSniff = this[UNZIP] === void 0 || this.brotli === void 0 && this[UNZIP] === false; + if (needSniff && chunk) { + if (this[BUFFER2]) { + chunk = Buffer.concat([this[BUFFER2], chunk]); + this[BUFFER2] = void 0; + } + if (chunk.length < gzipHeader.length) { + this[BUFFER2] = chunk; + cb?.(); + return true; + } + for (let i = 0; this[UNZIP] === void 0 && i < gzipHeader.length; i++) { + if (chunk[i] !== gzipHeader[i]) { + this[UNZIP] = false; + } + } + const maybeBrotli = this.brotli === void 0; + if (this[UNZIP] === false && maybeBrotli) { + if (chunk.length < 512) { + if (this[ENDED]) { + this.brotli = true; + } else { + this[BUFFER2] = chunk; + cb?.(); + return true; + } + } else { + try { + new Header(chunk.subarray(0, 512)); + this.brotli = false; + } catch (_) { + this.brotli = true; + } + } + } + if (this[UNZIP] === void 0 || this[UNZIP] === false && this.brotli) { + const ended = this[ENDED]; + this[ENDED] = false; + this[UNZIP] = this[UNZIP] === void 0 ? new Unzip({}) : new BrotliDecompress({}); + this[UNZIP].on("data", (chunk2) => this[CONSUMECHUNK](chunk2)); + this[UNZIP].on("error", (er) => this.abort(er)); + this[UNZIP].on("end", () => { + this[ENDED] = true; + this[CONSUMECHUNK](); + }); + this[WRITING] = true; + const ret2 = !!this[UNZIP][ended ? "end" : "write"](chunk); + this[WRITING] = false; + cb?.(); + return ret2; } } - const writeBuf = this.offset === 0 && bytesRead === this.buf.length ? this.buf : this.buf.slice(this.offset, this.offset + bytesRead); - const flushed = this.write(writeBuf); - if (!flushed) { - this[AWAITDRAIN](() => this[ONDRAIN]()); + this[WRITING] = true; + if (this[UNZIP]) { + this[UNZIP].write(chunk); } else { - this[ONDRAIN](); + this[CONSUMECHUNK](chunk); } + this[WRITING] = false; + const ret = this[QUEUE].length ? false : this[READENTRY] ? this[READENTRY].flowing : true; + if (!ret && !this[QUEUE].length) { + this[READENTRY]?.once("drain", () => this.emit("drain")); + } + cb?.(); + return ret; } - [AWAITDRAIN](cb) { - this.once("drain", cb); + [BUFFERCONCAT](c) { + if (c && !this[ABORTED2]) { + this[BUFFER2] = this[BUFFER2] ? Buffer.concat([this[BUFFER2], c]) : c; + } } - write(writeBuf) { - if (this.blockRemain < writeBuf.length) { - const er = new Error("writing more data than expected"); - er.path = this.absolute; - return this.emit("error", er); + [MAYBEEND]() { + if (this[ENDED] && !this[EMITTEDEND] && !this[ABORTED2] && !this[CONSUMING]) { + this[EMITTEDEND] = true; + const entry = this[WRITEENTRY]; + if (entry && entry.blockRemain) { + const have = this[BUFFER2] ? this[BUFFER2].length : 0; + this.warn("TAR_BAD_ARCHIVE", `Truncated input (needed ${entry.blockRemain} more bytes, only ${have} available)`, { entry }); + if (this[BUFFER2]) { + entry.write(this[BUFFER2]); + } + entry.end(); + } + this[EMIT](DONE); } - this.remain -= writeBuf.length; - this.blockRemain -= writeBuf.length; - this.pos += writeBuf.length; - this.offset += writeBuf.length; - return super.write(writeBuf); } - [ONDRAIN]() { - if (!this.remain) { - if (this.blockRemain) { - super.write(Buffer.alloc(this.blockRemain)); + [CONSUMECHUNK](chunk) { + if (this[CONSUMING] && chunk) { + this[BUFFERCONCAT](chunk); + } else if (!chunk && !this[BUFFER2]) { + this[MAYBEEND](); + } else if (chunk) { + this[CONSUMING] = true; + if (this[BUFFER2]) { + this[BUFFERCONCAT](chunk); + const c = this[BUFFER2]; + this[BUFFER2] = void 0; + this[CONSUMECHUNKSUB](c); + } else { + this[CONSUMECHUNKSUB](chunk); } - return this[CLOSE]((er) => er ? this.emit("error", er) : this.end()); + while (this[BUFFER2] && this[BUFFER2]?.length >= 512 && !this[ABORTED2] && !this[SAW_EOF]) { + const c = this[BUFFER2]; + this[BUFFER2] = void 0; + this[CONSUMECHUNKSUB](c); + } + this[CONSUMING] = false; } - if (this.offset >= this.length) { - this.buf = Buffer.allocUnsafe(Math.min(this.blockRemain, this.buf.length)); - this.offset = 0; + if (!this[BUFFER2] || this[ENDED]) { + this[MAYBEEND](); } - this.length = this.buf.length - this.offset; - this[READ](); } - }); - var WriteEntrySync = class extends WriteEntry { - [LSTAT]() { - this[ONLSTAT](fs8.lstatSync(this.absolute)); - } - [SYMLINK]() { - this[ONREADLINK](fs8.readlinkSync(this.absolute)); - } - [OPENFILE]() { - this[ONOPENFILE](fs8.openSync(this.absolute, "r")); - } - [READ]() { - let threw = true; - try { - const { fd, buf, offset, length, pos } = this; - const bytesRead = fs8.readSync(fd, buf, offset, length, pos); - this[ONREAD](bytesRead); - threw = false; - } finally { - if (threw) { - try { - this[CLOSE](() => { - }); - } catch (er) { - } + [CONSUMECHUNKSUB](chunk) { + let position = 0; + const length = chunk.length; + while (position + 512 <= length && !this[ABORTED2] && !this[SAW_EOF]) { + switch (this[STATE]) { + case "begin": + case "header": + this[CONSUMEHEADER](chunk, position); + position += 512; + break; + case "ignore": + case "body": + position += this[CONSUMEBODY](chunk, position); + break; + case "meta": + position += this[CONSUMEMETA](chunk, position); + break; + default: + throw new Error("invalid state: " + this[STATE]); + } + } + if (position < length) { + if (this[BUFFER2]) { + this[BUFFER2] = Buffer.concat([ + chunk.subarray(position), + this[BUFFER2] + ]); + } else { + this[BUFFER2] = chunk.subarray(position); } } } - [AWAITDRAIN](cb) { - cb(); - } - [CLOSE](cb) { - fs8.closeSync(this.fd); - cb(); + end(chunk, encoding, cb) { + if (typeof chunk === "function") { + cb = chunk; + encoding = void 0; + chunk = void 0; + } + if (typeof encoding === "function") { + cb = encoding; + encoding = void 0; + } + if (typeof chunk === "string") { + chunk = Buffer.from(chunk, encoding); + } + if (cb) + this.once("finish", cb); + if (!this[ABORTED2]) { + if (this[UNZIP]) { + if (chunk) + this[UNZIP].write(chunk); + this[UNZIP].end(); + } else { + this[ENDED] = true; + if (this.brotli === void 0) + chunk = chunk || Buffer.alloc(0); + if (chunk) + this.write(chunk); + this[MAYBEEND](); + } + } + return this; } }; - var WriteEntryTar = warner(class WriteEntryTar extends Minipass { - constructor(readEntry, opt) { - opt = opt || {}; - super(opt); - this.preservePaths = !!opt.preservePaths; - this.portable = !!opt.portable; - this.strict = !!opt.strict; - this.noPax = !!opt.noPax; - this.noMtime = !!opt.noMtime; - this.readEntry = readEntry; - this.type = readEntry.type; - if (this.type === "Directory" && this.portable) { - this.noMtime = true; - } - this.prefix = opt.prefix || null; - this.path = normPath(readEntry.path); - this.mode = this[MODE](readEntry.mode); - this.uid = this.portable ? null : readEntry.uid; - this.gid = this.portable ? null : readEntry.gid; - this.uname = this.portable ? null : readEntry.uname; - this.gname = this.portable ? null : readEntry.gname; - this.size = readEntry.size; - this.mtime = this.noMtime ? null : opt.mtime || readEntry.mtime; - this.atime = this.portable ? null : readEntry.atime; - this.ctime = this.portable ? null : readEntry.ctime; - this.linkpath = normPath(readEntry.linkpath); - if (typeof opt.onwarn === "function") { - this.on("warn", opt.onwarn); - } - let pathWarn = false; - if (!this.preservePaths) { - const [root, stripped] = stripAbsolutePath(this.path); - if (root) { - this.path = stripped; - pathWarn = root; + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/strip-trailing-slashes.js +var stripTrailingSlashes; +var init_strip_trailing_slashes = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/strip-trailing-slashes.js"() { + stripTrailingSlashes = (str) => { + let i = str.length - 1; + let slashesStart = -1; + while (i > -1 && str.charAt(i) === "/") { + slashesStart = i; + i--; + } + return slashesStart === -1 ? str : str.slice(0, slashesStart); + }; + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/list.js +var list_exports = {}; +__export(list_exports, { + filesFilter: () => filesFilter, + list: () => list +}); +var import_node_fs, import_path2, onReadEntryFunction, filesFilter, listFileSync, listFile, list; +var init_list = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/list.js"() { + init_esm2(); + import_node_fs = __toESM(require("node:fs"), 1); + import_path2 = require("path"); + init_make_command(); + init_parse(); + init_strip_trailing_slashes(); + onReadEntryFunction = (opt) => { + const onReadEntry = opt.onReadEntry; + opt.onReadEntry = onReadEntry ? (e) => { + onReadEntry(e); + e.resume(); + } : (e) => e.resume(); + }; + filesFilter = (opt, files) => { + const map = new Map(files.map((f) => [stripTrailingSlashes(f), true])); + const filter = opt.filter; + const mapHas = (file, r = "") => { + const root = r || (0, import_path2.parse)(file).root || "."; + let ret; + if (file === root) + ret = false; + else { + const m = map.get(file); + if (m !== void 0) { + ret = m; + } else { + ret = mapHas((0, import_path2.dirname)(file), root); } } - this.remain = readEntry.size; - this.blockRemain = readEntry.startBlockSize; - this.header = new Header({ - path: this[PREFIX](this.path), - linkpath: this.type === "Link" ? this[PREFIX](this.linkpath) : this.linkpath, - // only the permissions and setuid/setgid/sticky bitflags - // not the higher-order bits that specify file type - mode: this.mode, - uid: this.portable ? null : this.uid, - gid: this.portable ? null : this.gid, - size: this.size, - mtime: this.noMtime ? null : this.mtime, - type: this.type, - uname: this.portable ? null : this.uname, - atime: this.portable ? null : this.atime, - ctime: this.portable ? null : this.ctime - }); - if (pathWarn) { - this.warn("TAR_ENTRY_INFO", `stripping ${pathWarn} from absolute path`, { - entry: this, - path: pathWarn + this.path - }); - } - if (this.header.encode() && !this.noPax) { - super.write(new Pax({ - atime: this.portable ? null : this.atime, - ctime: this.portable ? null : this.ctime, - gid: this.portable ? null : this.gid, - mtime: this.noMtime ? null : this.mtime, - path: this[PREFIX](this.path), - linkpath: this.type === "Link" ? this[PREFIX](this.linkpath) : this.linkpath, - size: this.size, - uid: this.portable ? null : this.uid, - uname: this.portable ? null : this.uname, - dev: this.portable ? null : this.readEntry.dev, - ino: this.portable ? null : this.readEntry.ino, - nlink: this.portable ? null : this.readEntry.nlink - }).encode()); - } - super.write(this.header.block); - readEntry.pipe(this); - } - [PREFIX](path11) { - return prefixPath(path11, this.prefix); - } - [MODE](mode) { - return modeFix(mode, this.type === "Directory", this.portable); - } - write(data) { - const writeLen = data.length; - if (writeLen > this.blockRemain) { - throw new Error("writing more to entry than is appropriate"); + map.set(file, ret); + return ret; + }; + opt.filter = filter ? (file, entry) => filter(file, entry) && mapHas(stripTrailingSlashes(file)) : (file) => mapHas(stripTrailingSlashes(file)); + }; + listFileSync = (opt) => { + const p = new Parser(opt); + const file = opt.file; + let fd; + try { + const stat2 = import_node_fs.default.statSync(file); + const readSize = opt.maxReadSize || 16 * 1024 * 1024; + if (stat2.size < readSize) { + p.end(import_node_fs.default.readFileSync(file)); + } else { + let pos2 = 0; + const buf = Buffer.allocUnsafe(readSize); + fd = import_node_fs.default.openSync(file, "r"); + while (pos2 < stat2.size) { + const bytesRead = import_node_fs.default.readSync(fd, buf, 0, readSize, pos2); + pos2 += bytesRead; + p.write(buf.subarray(0, bytesRead)); + } + p.end(); } - this.blockRemain -= writeLen; - return super.write(data); - } - end() { - if (this.blockRemain) { - super.write(Buffer.alloc(this.blockRemain)); + } finally { + if (typeof fd === "number") { + try { + import_node_fs.default.closeSync(fd); + } catch (er) { + } } - return super.end(); } + }; + listFile = (opt, _files) => { + const parse5 = new Parser(opt); + const readSize = opt.maxReadSize || 16 * 1024 * 1024; + const file = opt.file; + const p = new Promise((resolve2, reject) => { + parse5.on("error", reject); + parse5.on("end", resolve2); + import_node_fs.default.stat(file, (er, stat2) => { + if (er) { + reject(er); + } else { + const stream = new ReadStream(file, { + readSize, + size: stat2.size + }); + stream.on("error", reject); + stream.pipe(parse5); + } + }); + }); + return p; + }; + list = makeCommand(listFileSync, listFile, (opt) => new Parser(opt), (opt) => new Parser(opt), (opt, files) => { + if (files?.length) + filesFilter(opt, files); + if (!opt.noResume) + onReadEntryFunction(opt); }); - WriteEntry.Sync = WriteEntrySync; - WriteEntry.Tar = WriteEntryTar; - var getType = (stat) => stat.isFile() ? "File" : stat.isDirectory() ? "Directory" : stat.isSymbolicLink() ? "SymbolicLink" : "Unsupported"; - module2.exports = WriteEntry; } }); -// .yarn/cache/yallist-npm-4.0.0-b493d9e907-2286b5e8db.zip/node_modules/yallist/iterator.js -var require_iterator = __commonJS({ - ".yarn/cache/yallist-npm-4.0.0-b493d9e907-2286b5e8db.zip/node_modules/yallist/iterator.js"(exports2, module2) { - "use strict"; - module2.exports = function(Yallist) { - Yallist.prototype[Symbol.iterator] = function* () { - for (let walker = this.head; walker; walker = walker.next) { - yield walker.value; - } - }; - }; +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/get-write-flag.js +var import_fs3, platform2, isWindows, O_CREAT, O_TRUNC, O_WRONLY, UV_FS_O_FILEMAP, fMapEnabled, fMapLimit, fMapFlag, getWriteFlag; +var init_get_write_flag = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/get-write-flag.js"() { + import_fs3 = __toESM(require("fs"), 1); + platform2 = process.env.__FAKE_PLATFORM__ || process.platform; + isWindows = platform2 === "win32"; + ({ O_CREAT, O_TRUNC, O_WRONLY } = import_fs3.default.constants); + UV_FS_O_FILEMAP = Number(process.env.__FAKE_FS_O_FILENAME__) || import_fs3.default.constants.UV_FS_O_FILEMAP || 0; + fMapEnabled = isWindows && !!UV_FS_O_FILEMAP; + fMapLimit = 512 * 1024; + fMapFlag = UV_FS_O_FILEMAP | O_TRUNC | O_CREAT | O_WRONLY; + getWriteFlag = !fMapEnabled ? () => "w" : (size) => size < fMapLimit ? fMapFlag : "w"; } }); -// .yarn/cache/yallist-npm-4.0.0-b493d9e907-2286b5e8db.zip/node_modules/yallist/yallist.js -var require_yallist = __commonJS({ - ".yarn/cache/yallist-npm-4.0.0-b493d9e907-2286b5e8db.zip/node_modules/yallist/yallist.js"(exports2, module2) { - "use strict"; - module2.exports = Yallist; - Yallist.Node = Node; - Yallist.create = Yallist; - function Yallist(list) { - var self2 = this; - if (!(self2 instanceof Yallist)) { - self2 = new Yallist(); - } - self2.tail = null; - self2.head = null; - self2.length = 0; - if (list && typeof list.forEach === "function") { - list.forEach(function(item) { - self2.push(item); - }); - } else if (arguments.length > 0) { - for (var i = 0, l = arguments.length; i < l; i++) { - self2.push(arguments[i]); - } - } - return self2; - } - Yallist.prototype.removeNode = function(node) { - if (node.list !== this) { - throw new Error("removing node which does not belong to this list"); - } - var next = node.next; - var prev = node.prev; - if (next) { - next.prev = prev; - } - if (prev) { - prev.next = next; - } - if (node === this.head) { - this.head = next; - } - if (node === this.tail) { - this.tail = prev; +// .yarn/cache/chownr-npm-3.0.0-5275e85d25-43925b8770.zip/node_modules/chownr/dist/esm/index.js +var import_node_fs2, import_node_path3, lchownSync, chown, chownrKid, chownr, chownrKidSync, chownrSync; +var init_esm5 = __esm({ + ".yarn/cache/chownr-npm-3.0.0-5275e85d25-43925b8770.zip/node_modules/chownr/dist/esm/index.js"() { + import_node_fs2 = __toESM(require("node:fs"), 1); + import_node_path3 = __toESM(require("node:path"), 1); + lchownSync = (path16, uid, gid) => { + try { + return import_node_fs2.default.lchownSync(path16, uid, gid); + } catch (er) { + if (er?.code !== "ENOENT") + throw er; } - node.list.length--; - node.next = null; - node.prev = null; - node.list = null; - return next; }; - Yallist.prototype.unshiftNode = function(node) { - if (node === this.head) { - return; - } - if (node.list) { - node.list.removeNode(node); - } - var head = this.head; - node.list = this; - node.next = head; - if (head) { - head.prev = node; - } - this.head = node; - if (!this.tail) { - this.tail = node; - } - this.length++; + chown = (cpath, uid, gid, cb) => { + import_node_fs2.default.lchown(cpath, uid, gid, (er) => { + cb(er && er?.code !== "ENOENT" ? er : null); + }); }; - Yallist.prototype.pushNode = function(node) { - if (node === this.tail) { - return; - } - if (node.list) { - node.list.removeNode(node); - } - var tail = this.tail; - node.list = this; - node.prev = tail; - if (tail) { - tail.next = node; - } - this.tail = node; - if (!this.head) { - this.head = node; + chownrKid = (p, child, uid, gid, cb) => { + if (child.isDirectory()) { + chownr(import_node_path3.default.resolve(p, child.name), uid, gid, (er) => { + if (er) + return cb(er); + const cpath = import_node_path3.default.resolve(p, child.name); + chown(cpath, uid, gid, cb); + }); + } else { + const cpath = import_node_path3.default.resolve(p, child.name); + chown(cpath, uid, gid, cb); } - this.length++; }; - Yallist.prototype.push = function() { - for (var i = 0, l = arguments.length; i < l; i++) { - push(this, arguments[i]); - } - return this.length; + chownr = (p, uid, gid, cb) => { + import_node_fs2.default.readdir(p, { withFileTypes: true }, (er, children) => { + if (er) { + if (er.code === "ENOENT") + return cb(); + else if (er.code !== "ENOTDIR" && er.code !== "ENOTSUP") + return cb(er); + } + if (er || !children.length) + return chown(p, uid, gid, cb); + let len = children.length; + let errState = null; + const then = (er2) => { + if (errState) + return; + if (er2) + return cb(errState = er2); + if (--len === 0) + return chown(p, uid, gid, cb); + }; + for (const child of children) { + chownrKid(p, child, uid, gid, then); + } + }); }; - Yallist.prototype.unshift = function() { - for (var i = 0, l = arguments.length; i < l; i++) { - unshift(this, arguments[i]); - } - return this.length; + chownrKidSync = (p, child, uid, gid) => { + if (child.isDirectory()) + chownrSync(import_node_path3.default.resolve(p, child.name), uid, gid); + lchownSync(import_node_path3.default.resolve(p, child.name), uid, gid); }; - Yallist.prototype.pop = function() { - if (!this.tail) { - return void 0; + chownrSync = (p, uid, gid) => { + let children; + try { + children = import_node_fs2.default.readdirSync(p, { withFileTypes: true }); + } catch (er) { + const e = er; + if (e?.code === "ENOENT") + return; + else if (e?.code === "ENOTDIR" || e?.code === "ENOTSUP") + return lchownSync(p, uid, gid); + else + throw e; } - var res = this.tail.value; - this.tail = this.tail.prev; - if (this.tail) { - this.tail.next = null; - } else { - this.head = null; + for (const child of children) { + chownrKidSync(p, child, uid, gid); } - this.length--; - return res; + return lchownSync(p, uid, gid); }; - Yallist.prototype.shift = function() { - if (!this.head) { - return void 0; - } - var res = this.head.value; - this.head = this.head.next; - if (this.head) { - this.head.prev = null; + } +}); + +// .yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/opts-arg.js +var import_fs4, optsArg; +var init_opts_arg = __esm({ + ".yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/opts-arg.js"() { + import_fs4 = require("fs"); + optsArg = (opts) => { + if (!opts) { + opts = { mode: 511 }; + } else if (typeof opts === "object") { + opts = { mode: 511, ...opts }; + } else if (typeof opts === "number") { + opts = { mode: opts }; + } else if (typeof opts === "string") { + opts = { mode: parseInt(opts, 8) }; } else { - this.tail = null; - } - this.length--; - return res; - }; - Yallist.prototype.forEach = function(fn2, thisp) { - thisp = thisp || this; - for (var walker = this.head, i = 0; walker !== null; i++) { - fn2.call(thisp, walker.value, i, this); - walker = walker.next; - } - }; - Yallist.prototype.forEachReverse = function(fn2, thisp) { - thisp = thisp || this; - for (var walker = this.tail, i = this.length - 1; walker !== null; i--) { - fn2.call(thisp, walker.value, i, this); - walker = walker.prev; + throw new TypeError("invalid options argument"); } + const resolved = opts; + const optsFs = opts.fs || {}; + opts.mkdir = opts.mkdir || optsFs.mkdir || import_fs4.mkdir; + opts.mkdirAsync = opts.mkdirAsync ? opts.mkdirAsync : async (path16, options) => { + return new Promise((res, rej) => resolved.mkdir(path16, options, (er, made) => er ? rej(er) : res(made))); + }; + opts.stat = opts.stat || optsFs.stat || import_fs4.stat; + opts.statAsync = opts.statAsync ? opts.statAsync : async (path16) => new Promise((res, rej) => resolved.stat(path16, (err, stats) => err ? rej(err) : res(stats))); + opts.statSync = opts.statSync || optsFs.statSync || import_fs4.statSync; + opts.mkdirSync = opts.mkdirSync || optsFs.mkdirSync || import_fs4.mkdirSync; + return resolved; }; - Yallist.prototype.get = function(n) { - for (var i = 0, walker = this.head; walker !== null && i < n; i++) { - walker = walker.next; + } +}); + +// .yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/mkdirp-manual.js +var import_path3, mkdirpManualSync, mkdirpManual; +var init_mkdirp_manual = __esm({ + ".yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/mkdirp-manual.js"() { + import_path3 = require("path"); + init_opts_arg(); + mkdirpManualSync = (path16, options, made) => { + const parent = (0, import_path3.dirname)(path16); + const opts = { ...optsArg(options), recursive: false }; + if (parent === path16) { + try { + return opts.mkdirSync(path16, opts); + } catch (er) { + const fer = er; + if (fer && fer.code !== "EISDIR") { + throw er; + } + return; + } } - if (i === n && walker !== null) { - return walker.value; + try { + opts.mkdirSync(path16, opts); + return made || path16; + } catch (er) { + const fer = er; + if (fer && fer.code === "ENOENT") { + return mkdirpManualSync(path16, opts, mkdirpManualSync(parent, opts, made)); + } + if (fer && fer.code !== "EEXIST" && fer && fer.code !== "EROFS") { + throw er; + } + try { + if (!opts.statSync(path16).isDirectory()) + throw er; + } catch (_) { + throw er; + } } }; - Yallist.prototype.getReverse = function(n) { - for (var i = 0, walker = this.tail; walker !== null && i < n; i++) { - walker = walker.prev; + mkdirpManual = Object.assign(async (path16, options, made) => { + const opts = optsArg(options); + opts.recursive = false; + const parent = (0, import_path3.dirname)(path16); + if (parent === path16) { + return opts.mkdirAsync(path16, opts).catch((er) => { + const fer = er; + if (fer && fer.code !== "EISDIR") { + throw er; + } + }); } - if (i === n && walker !== null) { - return walker.value; + return opts.mkdirAsync(path16, opts).then(() => made || path16, async (er) => { + const fer = er; + if (fer && fer.code === "ENOENT") { + return mkdirpManual(parent, opts).then((made2) => mkdirpManual(path16, opts, made2)); + } + if (fer && fer.code !== "EEXIST" && fer.code !== "EROFS") { + throw er; + } + return opts.statAsync(path16).then((st) => { + if (st.isDirectory()) { + return made; + } else { + throw er; + } + }, () => { + throw er; + }); + }); + }, { sync: mkdirpManualSync }); + } +}); + +// .yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/find-made.js +var import_path4, findMade, findMadeSync; +var init_find_made = __esm({ + ".yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/find-made.js"() { + import_path4 = require("path"); + findMade = async (opts, parent, path16) => { + if (path16 === parent) { + return; } + return opts.statAsync(parent).then( + (st) => st.isDirectory() ? path16 : void 0, + // will fail later + // will fail later + (er) => { + const fer = er; + return fer && fer.code === "ENOENT" ? findMade(opts, (0, import_path4.dirname)(parent), parent) : void 0; + } + ); }; - Yallist.prototype.map = function(fn2, thisp) { - thisp = thisp || this; - var res = new Yallist(); - for (var walker = this.head; walker !== null; ) { - res.push(fn2.call(thisp, walker.value, this)); - walker = walker.next; + findMadeSync = (opts, parent, path16) => { + if (path16 === parent) { + return void 0; } - return res; - }; - Yallist.prototype.mapReverse = function(fn2, thisp) { - thisp = thisp || this; - var res = new Yallist(); - for (var walker = this.tail; walker !== null; ) { - res.push(fn2.call(thisp, walker.value, this)); - walker = walker.prev; + try { + return opts.statSync(parent).isDirectory() ? path16 : void 0; + } catch (er) { + const fer = er; + return fer && fer.code === "ENOENT" ? findMadeSync(opts, (0, import_path4.dirname)(parent), parent) : void 0; } - return res; }; - Yallist.prototype.reduce = function(fn2, initial) { - var acc; - var walker = this.head; - if (arguments.length > 1) { - acc = initial; - } else if (this.head) { - walker = this.head.next; - acc = this.head.value; - } else { - throw new TypeError("Reduce of empty list with no initial value"); - } - for (var i = 0; walker !== null; i++) { - acc = fn2(acc, walker.value, i); - walker = walker.next; - } - return acc; - }; - Yallist.prototype.reduceReverse = function(fn2, initial) { - var acc; - var walker = this.tail; - if (arguments.length > 1) { - acc = initial; - } else if (this.tail) { - walker = this.tail.prev; - acc = this.tail.value; - } else { - throw new TypeError("Reduce of empty list with no initial value"); - } - for (var i = this.length - 1; walker !== null; i--) { - acc = fn2(acc, walker.value, i); - walker = walker.prev; + } +}); + +// .yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/mkdirp-native.js +var import_path5, mkdirpNativeSync, mkdirpNative; +var init_mkdirp_native = __esm({ + ".yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/mkdirp-native.js"() { + import_path5 = require("path"); + init_find_made(); + init_mkdirp_manual(); + init_opts_arg(); + mkdirpNativeSync = (path16, options) => { + const opts = optsArg(options); + opts.recursive = true; + const parent = (0, import_path5.dirname)(path16); + if (parent === path16) { + return opts.mkdirSync(path16, opts); } - return acc; - }; - Yallist.prototype.toArray = function() { - var arr = new Array(this.length); - for (var i = 0, walker = this.head; walker !== null; i++) { - arr[i] = walker.value; - walker = walker.next; + const made = findMadeSync(opts, path16); + try { + opts.mkdirSync(path16, opts); + return made; + } catch (er) { + const fer = er; + if (fer && fer.code === "ENOENT") { + return mkdirpManualSync(path16, opts); + } else { + throw er; + } } - return arr; }; - Yallist.prototype.toArrayReverse = function() { - var arr = new Array(this.length); - for (var i = 0, walker = this.tail; walker !== null; i++) { - arr[i] = walker.value; - walker = walker.prev; + mkdirpNative = Object.assign(async (path16, options) => { + const opts = { ...optsArg(options), recursive: true }; + const parent = (0, import_path5.dirname)(path16); + if (parent === path16) { + return await opts.mkdirAsync(path16, opts); } - return arr; - }; - Yallist.prototype.slice = function(from, to) { - to = to || this.length; - if (to < 0) { - to += this.length; - } - from = from || 0; - if (from < 0) { - from += this.length; - } - var ret = new Yallist(); - if (to < from || to < 0) { - return ret; - } - if (from < 0) { - from = 0; - } - if (to > this.length) { - to = this.length; - } - for (var i = 0, walker = this.head; walker !== null && i < from; i++) { - walker = walker.next; + return findMade(opts, path16).then((made) => opts.mkdirAsync(path16, opts).then((m) => made || m).catch((er) => { + const fer = er; + if (fer && fer.code === "ENOENT") { + return mkdirpManual(path16, opts); + } else { + throw er; + } + })); + }, { sync: mkdirpNativeSync }); + } +}); + +// .yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/path-arg.js +var import_path6, platform3, pathArg; +var init_path_arg = __esm({ + ".yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/path-arg.js"() { + import_path6 = require("path"); + platform3 = process.env.__TESTING_MKDIRP_PLATFORM__ || process.platform; + pathArg = (path16) => { + if (/\0/.test(path16)) { + throw Object.assign(new TypeError("path must be a string without null bytes"), { + path: path16, + code: "ERR_INVALID_ARG_VALUE" + }); } - for (; walker !== null && i < to; i++, walker = walker.next) { - ret.push(walker.value); + path16 = (0, import_path6.resolve)(path16); + if (platform3 === "win32") { + const badWinChars = /[*|"<>?:]/; + const { root } = (0, import_path6.parse)(path16); + if (badWinChars.test(path16.substring(root.length))) { + throw Object.assign(new Error("Illegal characters in path."), { + path: path16, + code: "EINVAL" + }); + } } - return ret; + return path16; }; - Yallist.prototype.sliceReverse = function(from, to) { - to = to || this.length; - if (to < 0) { - to += this.length; - } - from = from || 0; - if (from < 0) { - from += this.length; - } - var ret = new Yallist(); - if (to < from || to < 0) { - return ret; - } - if (from < 0) { - from = 0; - } - if (to > this.length) { - to = this.length; - } - for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) { - walker = walker.prev; + } +}); + +// .yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/use-native.js +var import_fs5, version2, versArr, hasNative, useNativeSync, useNative; +var init_use_native = __esm({ + ".yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/use-native.js"() { + import_fs5 = require("fs"); + init_opts_arg(); + version2 = process.env.__TESTING_MKDIRP_NODE_VERSION__ || process.version; + versArr = version2.replace(/^v/, "").split("."); + hasNative = +versArr[0] > 10 || +versArr[0] === 10 && +versArr[1] >= 12; + useNativeSync = !hasNative ? () => false : (opts) => optsArg(opts).mkdirSync === import_fs5.mkdirSync; + useNative = Object.assign(!hasNative ? () => false : (opts) => optsArg(opts).mkdir === import_fs5.mkdir, { + sync: useNativeSync + }); + } +}); + +// .yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/index.js +var mkdirpSync, mkdirp; +var init_mjs = __esm({ + ".yarn/cache/mkdirp-npm-3.0.1-f94bfa769e-9f2b975e92.zip/node_modules/mkdirp/dist/mjs/index.js"() { + init_mkdirp_manual(); + init_mkdirp_native(); + init_opts_arg(); + init_path_arg(); + init_use_native(); + init_mkdirp_manual(); + init_mkdirp_native(); + init_use_native(); + mkdirpSync = (path16, opts) => { + path16 = pathArg(path16); + const resolved = optsArg(opts); + return useNativeSync(resolved) ? mkdirpNativeSync(path16, resolved) : mkdirpManualSync(path16, resolved); + }; + mkdirp = Object.assign(async (path16, opts) => { + path16 = pathArg(path16); + const resolved = optsArg(opts); + return useNative(resolved) ? mkdirpNative(path16, resolved) : mkdirpManual(path16, resolved); + }, { + mkdirpSync, + mkdirpNative, + mkdirpNativeSync, + mkdirpManual, + mkdirpManualSync, + sync: mkdirpSync, + native: mkdirpNative, + nativeSync: mkdirpNativeSync, + manual: mkdirpManual, + manualSync: mkdirpManualSync, + useNative, + useNativeSync + }); + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/cwd-error.js +var CwdError; +var init_cwd_error = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/cwd-error.js"() { + CwdError = class extends Error { + path; + code; + syscall = "chdir"; + constructor(path16, code2) { + super(`${code2}: Cannot cd into '${path16}'`); + this.path = path16; + this.code = code2; } - for (; walker !== null && i > from; i--, walker = walker.prev) { - ret.push(walker.value); + get name() { + return "CwdError"; } - return ret; }; - Yallist.prototype.splice = function(start, deleteCount, ...nodes) { - if (start > this.length) { - start = this.length - 1; + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/symlink-error.js +var SymlinkError; +var init_symlink_error = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/symlink-error.js"() { + SymlinkError = class extends Error { + path; + symlink; + syscall = "symlink"; + code = "TAR_SYMLINK_ERROR"; + constructor(symlink, path16) { + super("TAR_SYMLINK_ERROR: Cannot extract through symbolic link"); + this.symlink = symlink; + this.path = path16; } - if (start < 0) { - start = this.length + start; + get name() { + return "SymlinkError"; } - for (var i = 0, walker = this.head; walker !== null && i < start; i++) { - walker = walker.next; + }; + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/mkdir.js +var import_fs6, import_node_path4, cGet, cSet, checkCwd, mkdir3, mkdir_, onmkdir, checkCwdSync, mkdirSync4; +var init_mkdir = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/mkdir.js"() { + init_esm5(); + import_fs6 = __toESM(require("fs"), 1); + init_mjs(); + import_node_path4 = __toESM(require("node:path"), 1); + init_cwd_error(); + init_normalize_windows_path(); + init_symlink_error(); + cGet = (cache, key) => cache.get(normalizeWindowsPath(key)); + cSet = (cache, key, val) => cache.set(normalizeWindowsPath(key), val); + checkCwd = (dir, cb) => { + import_fs6.default.stat(dir, (er, st) => { + if (er || !st.isDirectory()) { + er = new CwdError(dir, er?.code || "ENOTDIR"); + } + cb(er); + }); + }; + mkdir3 = (dir, opt, cb) => { + dir = normalizeWindowsPath(dir); + const umask = opt.umask ?? 18; + const mode = opt.mode | 448; + const needChmod = (mode & umask) !== 0; + const uid = opt.uid; + const gid = opt.gid; + const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid); + const preserve = opt.preserve; + const unlink = opt.unlink; + const cache = opt.cache; + const cwd = normalizeWindowsPath(opt.cwd); + const done = (er, created) => { + if (er) { + cb(er); + } else { + cSet(cache, dir, true); + if (created && doChown) { + chownr(created, uid, gid, (er2) => done(er2)); + } else if (needChmod) { + import_fs6.default.chmod(dir, mode, cb); + } else { + cb(); + } + } + }; + if (cache && cGet(cache, dir) === true) { + return done(); } - var ret = []; - for (var i = 0; walker && i < deleteCount; i++) { - ret.push(walker.value); - walker = this.removeNode(walker); + if (dir === cwd) { + return checkCwd(dir, done); } - if (walker === null) { - walker = this.tail; + if (preserve) { + return mkdirp(dir, { mode }).then( + (made) => done(null, made ?? void 0), + // oh, ts + done + ); } - if (walker !== this.head && walker !== this.tail) { - walker = walker.prev; + const sub = normalizeWindowsPath(import_node_path4.default.relative(cwd, dir)); + const parts = sub.split("/"); + mkdir_(cwd, parts, mode, cache, unlink, cwd, void 0, done); + }; + mkdir_ = (base, parts, mode, cache, unlink, cwd, created, cb) => { + if (!parts.length) { + return cb(null, created); } - for (var i = 0; i < nodes.length; i++) { - walker = insert(this, walker, nodes[i]); + const p = parts.shift(); + const part = normalizeWindowsPath(import_node_path4.default.resolve(base + "/" + p)); + if (cGet(cache, part)) { + return mkdir_(part, parts, mode, cache, unlink, cwd, created, cb); } - return ret; + import_fs6.default.mkdir(part, mode, onmkdir(part, parts, mode, cache, unlink, cwd, created, cb)); }; - Yallist.prototype.reverse = function() { - var head = this.head; - var tail = this.tail; - for (var walker = head; walker !== null; walker = walker.prev) { - var p = walker.prev; - walker.prev = walker.next; - walker.next = p; + onmkdir = (part, parts, mode, cache, unlink, cwd, created, cb) => (er) => { + if (er) { + import_fs6.default.lstat(part, (statEr, st) => { + if (statEr) { + statEr.path = statEr.path && normalizeWindowsPath(statEr.path); + cb(statEr); + } else if (st.isDirectory()) { + mkdir_(part, parts, mode, cache, unlink, cwd, created, cb); + } else if (unlink) { + import_fs6.default.unlink(part, (er2) => { + if (er2) { + return cb(er2); + } + import_fs6.default.mkdir(part, mode, onmkdir(part, parts, mode, cache, unlink, cwd, created, cb)); + }); + } else if (st.isSymbolicLink()) { + return cb(new SymlinkError(part, part + "/" + parts.join("/"))); + } else { + cb(er); + } + }); + } else { + created = created || part; + mkdir_(part, parts, mode, cache, unlink, cwd, created, cb); } - this.head = tail; - this.tail = head; - return this; }; - function insert(self2, node, value) { - var inserted = node === self2.head ? new Node(value, null, node, self2) : new Node(value, node, node.next, self2); - if (inserted.next === null) { - self2.tail = inserted; + checkCwdSync = (dir) => { + let ok = false; + let code2 = void 0; + try { + ok = import_fs6.default.statSync(dir).isDirectory(); + } catch (er) { + code2 = er?.code; + } finally { + if (!ok) { + throw new CwdError(dir, code2 ?? "ENOTDIR"); + } } - if (inserted.prev === null) { - self2.head = inserted; + }; + mkdirSync4 = (dir, opt) => { + dir = normalizeWindowsPath(dir); + const umask = opt.umask ?? 18; + const mode = opt.mode | 448; + const needChmod = (mode & umask) !== 0; + const uid = opt.uid; + const gid = opt.gid; + const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid); + const preserve = opt.preserve; + const unlink = opt.unlink; + const cache = opt.cache; + const cwd = normalizeWindowsPath(opt.cwd); + const done = (created2) => { + cSet(cache, dir, true); + if (created2 && doChown) { + chownrSync(created2, uid, gid); + } + if (needChmod) { + import_fs6.default.chmodSync(dir, mode); + } + }; + if (cache && cGet(cache, dir) === true) { + return done(); } - self2.length++; - return inserted; - } - function push(self2, item) { - self2.tail = new Node(item, self2.tail, null, self2); - if (!self2.head) { - self2.head = self2.tail; + if (dir === cwd) { + checkCwdSync(cwd); + return done(); } - self2.length++; - } - function unshift(self2, item) { - self2.head = new Node(item, null, self2.head, self2); - if (!self2.tail) { - self2.tail = self2.head; + if (preserve) { + return done(mkdirpSync(dir, mode) ?? void 0); } - self2.length++; - } - function Node(value, prev, next, list) { - if (!(this instanceof Node)) { - return new Node(value, prev, next, list); + const sub = normalizeWindowsPath(import_node_path4.default.relative(cwd, dir)); + const parts = sub.split("/"); + let created = void 0; + for (let p = parts.shift(), part = cwd; p && (part += "/" + p); p = parts.shift()) { + part = normalizeWindowsPath(import_node_path4.default.resolve(part)); + if (cGet(cache, part)) { + continue; + } + try { + import_fs6.default.mkdirSync(part, mode); + created = created || part; + cSet(cache, part, true); + } catch (er) { + const st = import_fs6.default.lstatSync(part); + if (st.isDirectory()) { + cSet(cache, part, true); + continue; + } else if (unlink) { + import_fs6.default.unlinkSync(part); + import_fs6.default.mkdirSync(part, mode); + created = created || part; + cSet(cache, part, true); + continue; + } else if (st.isSymbolicLink()) { + return new SymlinkError(part, part + "/" + parts.join("/")); + } + } } - this.list = list; - this.value = value; - if (prev) { - prev.next = this; - this.prev = prev; - } else { - this.prev = null; + return done(created); + }; + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/normalize-unicode.js +var normalizeCache, hasOwnProperty, normalizeUnicode; +var init_normalize_unicode = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/normalize-unicode.js"() { + normalizeCache = /* @__PURE__ */ Object.create(null); + ({ hasOwnProperty } = Object.prototype); + normalizeUnicode = (s) => { + if (!hasOwnProperty.call(normalizeCache, s)) { + normalizeCache[s] = s.normalize("NFD"); } - if (next) { - next.prev = this; - this.next = next; - } else { - this.next = null; + return normalizeCache[s]; + }; + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/strip-absolute-path.js +var import_node_path5, isAbsolute, parse4, stripAbsolutePath; +var init_strip_absolute_path = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/strip-absolute-path.js"() { + import_node_path5 = require("node:path"); + ({ isAbsolute, parse: parse4 } = import_node_path5.win32); + stripAbsolutePath = (path16) => { + let r = ""; + let parsed = parse4(path16); + while (isAbsolute(path16) || parsed.root) { + const root = path16.charAt(0) === "/" && path16.slice(0, 4) !== "//?/" ? "/" : parsed.root; + path16 = path16.slice(root.length); + r += root; + parsed = parse4(path16); } - } - try { - require_iterator()(Yallist); - } catch (er) { - } + return [r, path16]; + }; } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/pack.js -var require_pack = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/pack.js"(exports2, module2) { - "use strict"; - var PackJob = class { - constructor(path11, absolute) { - this.path = path11 || "./"; - this.absolute = absolute; - this.entry = null; - this.stat = null; - this.readdir = null; - this.pending = false; - this.ignore = false; - this.piped = false; - } - }; - var { Minipass } = require_minipass(); - var zlib = require_minizlib(); - var ReadEntry = require_read_entry(); - var WriteEntry = require_write_entry(); - var WriteEntrySync = WriteEntry.Sync; - var WriteEntryTar = WriteEntry.Tar; - var Yallist = require_yallist(); - var EOF = Buffer.alloc(1024); - var ONSTAT = Symbol("onStat"); - var ENDED = Symbol("ended"); - var QUEUE = Symbol("queue"); - var CURRENT = Symbol("current"); - var PROCESS = Symbol("process"); - var PROCESSING = Symbol("processing"); - var PROCESSJOB = Symbol("processJob"); - var JOBS = Symbol("jobs"); - var JOBDONE = Symbol("jobDone"); - var ADDFSENTRY = Symbol("addFSEntry"); - var ADDTARENTRY = Symbol("addTarEntry"); - var STAT = Symbol("stat"); - var READDIR = Symbol("readdir"); - var ONREADDIR = Symbol("onreaddir"); - var PIPE = Symbol("pipe"); - var ENTRY = Symbol("entry"); - var ENTRYOPT = Symbol("entryOpt"); - var WRITEENTRYCLASS = Symbol("writeEntryClass"); - var WRITE = Symbol("write"); - var ONDRAIN = Symbol("ondrain"); - var fs8 = require("fs"); - var path10 = require("path"); - var warner = require_warn_mixin(); - var normPath = require_normalize_windows_path(); - var Pack = warner(class Pack extends Minipass { - constructor(opt) { - super(opt); - opt = opt || /* @__PURE__ */ Object.create(null); - this.opt = opt; - this.file = opt.file || ""; - this.cwd = opt.cwd || process.cwd(); - this.maxReadSize = opt.maxReadSize; - this.preservePaths = !!opt.preservePaths; - this.strict = !!opt.strict; - this.noPax = !!opt.noPax; - this.prefix = normPath(opt.prefix || ""); - this.linkCache = opt.linkCache || /* @__PURE__ */ new Map(); - this.statCache = opt.statCache || /* @__PURE__ */ new Map(); - this.readdirCache = opt.readdirCache || /* @__PURE__ */ new Map(); - this[WRITEENTRYCLASS] = WriteEntry; - if (typeof opt.onwarn === "function") { - this.on("warn", opt.onwarn); - } - this.portable = !!opt.portable; - this.zip = null; - if (opt.gzip || opt.brotli) { - if (opt.gzip && opt.brotli) { - throw new TypeError("gzip and brotli are mutually exclusive"); - } - if (opt.gzip) { - if (typeof opt.gzip !== "object") { - opt.gzip = {}; - } - if (this.portable) { - opt.gzip.portable = true; - } - this.zip = new zlib.Gzip(opt.gzip); +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/winchars.js +var raw, win, toWin, toRaw, encode2, decode; +var init_winchars = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/winchars.js"() { + raw = ["|", "<", ">", "?", ":"]; + win = raw.map((char) => String.fromCharCode(61440 + char.charCodeAt(0))); + toWin = new Map(raw.map((char, i) => [char, win[i]])); + toRaw = new Map(win.map((char, i) => [char, raw[i]])); + encode2 = (s) => raw.reduce((s2, c) => s2.split(c).join(toWin.get(c)), s); + decode = (s) => win.reduce((s2, c) => s2.split(c).join(toRaw.get(c)), s); + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/path-reservations.js +var import_node_path6, platform4, isWindows2, getDirs, PathReservations; +var init_path_reservations = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/path-reservations.js"() { + import_node_path6 = require("node:path"); + init_normalize_unicode(); + init_strip_trailing_slashes(); + platform4 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform; + isWindows2 = platform4 === "win32"; + getDirs = (path16) => { + const dirs = path16.split("/").slice(0, -1).reduce((set, path17) => { + const s = set[set.length - 1]; + if (s !== void 0) { + path17 = (0, import_node_path6.join)(s, path17); + } + set.push(path17 || "/"); + return set; + }, []); + return dirs; + }; + PathReservations = class { + // path => [function or Set] + // A Set object means a directory reservation + // A fn is a direct reservation on that path + #queues = /* @__PURE__ */ new Map(); + // fn => {paths:[path,...], dirs:[path, ...]} + #reservations = /* @__PURE__ */ new Map(); + // functions currently running + #running = /* @__PURE__ */ new Set(); + reserve(paths, fn2) { + paths = isWindows2 ? ["win32 parallelization disabled"] : paths.map((p) => { + return stripTrailingSlashes((0, import_node_path6.join)(normalizeUnicode(p))).toLowerCase(); + }); + const dirs = new Set(paths.map((path16) => getDirs(path16)).reduce((a, b) => a.concat(b))); + this.#reservations.set(fn2, { dirs, paths }); + for (const p of paths) { + const q = this.#queues.get(p); + if (!q) { + this.#queues.set(p, [fn2]); + } else { + q.push(fn2); } - if (opt.brotli) { - if (typeof opt.brotli !== "object") { - opt.brotli = {}; + } + for (const dir of dirs) { + const q = this.#queues.get(dir); + if (!q) { + this.#queues.set(dir, [/* @__PURE__ */ new Set([fn2])]); + } else { + const l = q[q.length - 1]; + if (l instanceof Set) { + l.add(fn2); + } else { + q.push(/* @__PURE__ */ new Set([fn2])); } - this.zip = new zlib.BrotliCompress(opt.brotli); } - this.zip.on("data", (chunk) => super.write(chunk)); - this.zip.on("end", (_) => super.end()); - this.zip.on("drain", (_) => this[ONDRAIN]()); - this.on("resume", (_) => this.zip.resume()); - } else { - this.on("drain", this[ONDRAIN]); } - this.noDirRecurse = !!opt.noDirRecurse; - this.follow = !!opt.follow; - this.noMtime = !!opt.noMtime; - this.mtime = opt.mtime || null; - this.filter = typeof opt.filter === "function" ? opt.filter : (_) => true; - this[QUEUE] = new Yallist(); - this[JOBS] = 0; - this.jobs = +opt.jobs || 4; - this[PROCESSING] = false; - this[ENDED] = false; + return this.#run(fn2); } - [WRITE](chunk) { - return super.write(chunk); + // return the queues for each path the function cares about + // fn => {paths, dirs} + #getQueues(fn2) { + const res = this.#reservations.get(fn2); + if (!res) { + throw new Error("function does not have any path reservations"); + } + return { + paths: res.paths.map((path16) => this.#queues.get(path16)), + dirs: [...res.dirs].map((path16) => this.#queues.get(path16)) + }; } - add(path11) { - this.write(path11); - return this; + // check if fn is first in line for all its paths, and is + // included in the first set for all its dir queues + check(fn2) { + const { paths, dirs } = this.#getQueues(fn2); + return paths.every((q) => q && q[0] === fn2) && dirs.every((q) => q && q[0] instanceof Set && q[0].has(fn2)); } - end(path11) { - if (path11) { - this.write(path11); + // run the function if it's first in line and not already running + #run(fn2) { + if (this.#running.has(fn2) || !this.check(fn2)) { + return false; } - this[ENDED] = true; - this[PROCESS](); - return this; + this.#running.add(fn2); + fn2(() => this.#clear(fn2)); + return true; } - write(path11) { - if (this[ENDED]) { - throw new Error("write after end"); + #clear(fn2) { + if (!this.#running.has(fn2)) { + return false; } - if (path11 instanceof ReadEntry) { - this[ADDTARENTRY](path11); - } else { - this[ADDFSENTRY](path11); + const res = this.#reservations.get(fn2); + if (!res) { + throw new Error("invalid reservation"); } - return this.flowing; - } - [ADDTARENTRY](p) { - const absolute = normPath(path10.resolve(this.cwd, p.path)); - if (!this.filter(p.path, p)) { - p.resume(); - } else { - const job = new PackJob(p.path, absolute, false); - job.entry = new WriteEntryTar(p, this[ENTRYOPT](job)); - job.entry.on("end", (_) => this[JOBDONE](job)); - this[JOBS] += 1; - this[QUEUE].push(job); + const { paths, dirs } = res; + const next = /* @__PURE__ */ new Set(); + for (const path16 of paths) { + const q = this.#queues.get(path16); + if (!q || q?.[0] !== fn2) { + continue; + } + const q0 = q[1]; + if (!q0) { + this.#queues.delete(path16); + continue; + } + q.shift(); + if (typeof q0 === "function") { + next.add(q0); + } else { + for (const f of q0) { + next.add(f); + } + } } - this[PROCESS](); - } - [ADDFSENTRY](p) { - const absolute = normPath(path10.resolve(this.cwd, p)); - this[QUEUE].push(new PackJob(p, absolute)); - this[PROCESS](); - } - [STAT](job) { - job.pending = true; - this[JOBS] += 1; - const stat = this.follow ? "stat" : "lstat"; - fs8[stat](job.absolute, (er, stat2) => { - job.pending = false; - this[JOBS] -= 1; - if (er) { - this.emit("error", er); + for (const dir of dirs) { + const q = this.#queues.get(dir); + const q0 = q?.[0]; + if (!q || !(q0 instanceof Set)) + continue; + if (q0.size === 1 && q.length === 1) { + this.#queues.delete(dir); + continue; + } else if (q0.size === 1) { + q.shift(); + const n = q[0]; + if (typeof n === "function") { + next.add(n); + } } else { - this[ONSTAT](job, stat2); + q0.delete(fn2); } - }); + } + this.#running.delete(fn2); + next.forEach((fn3) => this.#run(fn3)); + return true; } - [ONSTAT](job, stat) { - this.statCache.set(job.absolute, stat); - job.stat = stat; - if (!this.filter(job.path, stat)) { - job.ignore = true; + }; + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/unpack.js +var import_node_assert, import_node_crypto, import_node_fs3, import_node_path7, ONENTRY, CHECKFS, CHECKFS2, PRUNECACHE, ISREUSABLE, MAKEFS, FILE, DIRECTORY, LINK, SYMLINK, HARDLINK, UNSUPPORTED, CHECKPATH, MKDIR, ONERROR, PENDING, PEND, UNPEND, ENDED2, MAYBECLOSE, SKIP, DOCHOWN, UID, GID, CHECKED_CWD, platform5, isWindows3, DEFAULT_MAX_DEPTH, unlinkFile, unlinkFileSync, uint32, cacheKeyNormalize, pruneCache, dropCache, Unpack, callSync, UnpackSync; +var init_unpack = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/unpack.js"() { + init_esm2(); + import_node_assert = __toESM(require("node:assert"), 1); + import_node_crypto = require("node:crypto"); + import_node_fs3 = __toESM(require("node:fs"), 1); + import_node_path7 = __toESM(require("node:path"), 1); + init_get_write_flag(); + init_mkdir(); + init_normalize_unicode(); + init_normalize_windows_path(); + init_parse(); + init_strip_absolute_path(); + init_strip_trailing_slashes(); + init_winchars(); + init_path_reservations(); + ONENTRY = Symbol("onEntry"); + CHECKFS = Symbol("checkFs"); + CHECKFS2 = Symbol("checkFs2"); + PRUNECACHE = Symbol("pruneCache"); + ISREUSABLE = Symbol("isReusable"); + MAKEFS = Symbol("makeFs"); + FILE = Symbol("file"); + DIRECTORY = Symbol("directory"); + LINK = Symbol("link"); + SYMLINK = Symbol("symlink"); + HARDLINK = Symbol("hardlink"); + UNSUPPORTED = Symbol("unsupported"); + CHECKPATH = Symbol("checkPath"); + MKDIR = Symbol("mkdir"); + ONERROR = Symbol("onError"); + PENDING = Symbol("pending"); + PEND = Symbol("pend"); + UNPEND = Symbol("unpend"); + ENDED2 = Symbol("ended"); + MAYBECLOSE = Symbol("maybeClose"); + SKIP = Symbol("skip"); + DOCHOWN = Symbol("doChown"); + UID = Symbol("uid"); + GID = Symbol("gid"); + CHECKED_CWD = Symbol("checkedCwd"); + platform5 = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform; + isWindows3 = platform5 === "win32"; + DEFAULT_MAX_DEPTH = 1024; + unlinkFile = (path16, cb) => { + if (!isWindows3) { + return import_node_fs3.default.unlink(path16, cb); + } + const name2 = path16 + ".DELETE." + (0, import_node_crypto.randomBytes)(16).toString("hex"); + import_node_fs3.default.rename(path16, name2, (er) => { + if (er) { + return cb(er); } - this[PROCESS](); + import_node_fs3.default.unlink(name2, cb); + }); + }; + unlinkFileSync = (path16) => { + if (!isWindows3) { + return import_node_fs3.default.unlinkSync(path16); } - [READDIR](job) { - job.pending = true; - this[JOBS] += 1; - fs8.readdir(job.absolute, (er, entries) => { - job.pending = false; - this[JOBS] -= 1; - if (er) { - return this.emit("error", er); - } - this[ONREADDIR](job, entries); - }); + const name2 = path16 + ".DELETE." + (0, import_node_crypto.randomBytes)(16).toString("hex"); + import_node_fs3.default.renameSync(path16, name2); + import_node_fs3.default.unlinkSync(name2); + }; + uint32 = (a, b, c) => a !== void 0 && a === a >>> 0 ? a : b !== void 0 && b === b >>> 0 ? b : c; + cacheKeyNormalize = (path16) => stripTrailingSlashes(normalizeWindowsPath(normalizeUnicode(path16))).toLowerCase(); + pruneCache = (cache, abs) => { + abs = cacheKeyNormalize(abs); + for (const path16 of cache.keys()) { + const pnorm = cacheKeyNormalize(path16); + if (pnorm === abs || pnorm.indexOf(abs + "/") === 0) { + cache.delete(path16); + } } - [ONREADDIR](job, entries) { - this.readdirCache.set(job.absolute, entries); - job.readdir = entries; - this[PROCESS](); + }; + dropCache = (cache) => { + for (const key of cache.keys()) { + cache.delete(key); } - [PROCESS]() { - if (this[PROCESSING]) { - return; - } - this[PROCESSING] = true; - for (let w = this[QUEUE].head; w !== null && this[JOBS] < this.jobs; w = w.next) { - this[PROCESSJOB](w.value); - if (w.value.ignore) { - const p = w.next; - this[QUEUE].removeNode(w); - w.next = p; + }; + Unpack = class extends Parser { + [ENDED2] = false; + [CHECKED_CWD] = false; + [PENDING] = 0; + reservations = new PathReservations(); + transform; + writable = true; + readable = false; + dirCache; + uid; + gid; + setOwner; + preserveOwner; + processGid; + processUid; + maxDepth; + forceChown; + win32; + newer; + keep; + noMtime; + preservePaths; + unlink; + cwd; + strip; + processUmask; + umask; + dmode; + fmode; + chmod; + constructor(opt = {}) { + opt.ondone = () => { + this[ENDED2] = true; + this[MAYBECLOSE](); + }; + super(opt); + this.transform = opt.transform; + this.dirCache = opt.dirCache || /* @__PURE__ */ new Map(); + this.chmod = !!opt.chmod; + if (typeof opt.uid === "number" || typeof opt.gid === "number") { + if (typeof opt.uid !== "number" || typeof opt.gid !== "number") { + throw new TypeError("cannot set owner without number uid and gid"); } - } - this[PROCESSING] = false; - if (this[ENDED] && !this[QUEUE].length && this[JOBS] === 0) { - if (this.zip) { - this.zip.end(EOF); - } else { - super.write(EOF); - super.end(); + if (opt.preserveOwner) { + throw new TypeError("cannot preserve owner in archive and also set owner explicitly"); } + this.uid = opt.uid; + this.gid = opt.gid; + this.setOwner = true; + } else { + this.uid = void 0; + this.gid = void 0; + this.setOwner = false; } + if (opt.preserveOwner === void 0 && typeof opt.uid !== "number") { + this.preserveOwner = !!(process.getuid && process.getuid() === 0); + } else { + this.preserveOwner = !!opt.preserveOwner; + } + this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : void 0; + this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : void 0; + this.maxDepth = typeof opt.maxDepth === "number" ? opt.maxDepth : DEFAULT_MAX_DEPTH; + this.forceChown = opt.forceChown === true; + this.win32 = !!opt.win32 || isWindows3; + this.newer = !!opt.newer; + this.keep = !!opt.keep; + this.noMtime = !!opt.noMtime; + this.preservePaths = !!opt.preservePaths; + this.unlink = !!opt.unlink; + this.cwd = normalizeWindowsPath(import_node_path7.default.resolve(opt.cwd || process.cwd())); + this.strip = Number(opt.strip) || 0; + this.processUmask = !this.chmod ? 0 : typeof opt.processUmask === "number" ? opt.processUmask : process.umask(); + this.umask = typeof opt.umask === "number" ? opt.umask : this.processUmask; + this.dmode = opt.dmode || 511 & ~this.umask; + this.fmode = opt.fmode || 438 & ~this.umask; + this.on("entry", (entry) => this[ONENTRY](entry)); } - get [CURRENT]() { - return this[QUEUE] && this[QUEUE].head && this[QUEUE].head.value; - } - [JOBDONE](job) { - this[QUEUE].shift(); - this[JOBS] -= 1; - this[PROCESS](); + // a bad or damaged archive is a warning for Parser, but an error + // when extracting. Mark those errors as unrecoverable, because + // the Unpack contract cannot be met. + warn(code2, msg, data = {}) { + if (code2 === "TAR_BAD_ARCHIVE" || code2 === "TAR_ABORT") { + data.recoverable = false; + } + return super.warn(code2, msg, data); } - [PROCESSJOB](job) { - if (job.pending) { - return; + [MAYBECLOSE]() { + if (this[ENDED2] && this[PENDING] === 0) { + this.emit("prefinish"); + this.emit("finish"); + this.emit("end"); } - if (job.entry) { - if (job === this[CURRENT] && !job.piped) { - this[PIPE](job); + } + [CHECKPATH](entry) { + const p = normalizeWindowsPath(entry.path); + const parts = p.split("/"); + if (this.strip) { + if (parts.length < this.strip) { + return false; } - return; - } - if (!job.stat) { - if (this.statCache.has(job.absolute)) { - this[ONSTAT](job, this.statCache.get(job.absolute)); - } else { - this[STAT](job); + if (entry.type === "Link") { + const linkparts = normalizeWindowsPath(String(entry.linkpath)).split("/"); + if (linkparts.length >= this.strip) { + entry.linkpath = linkparts.slice(this.strip).join("/"); + } else { + return false; + } } + parts.splice(0, this.strip); + entry.path = parts.join("/"); } - if (!job.stat) { - return; - } - if (job.ignore) { - return; + if (isFinite(this.maxDepth) && parts.length > this.maxDepth) { + this.warn("TAR_ENTRY_ERROR", "path excessively deep", { + entry, + path: p, + depth: parts.length, + maxDepth: this.maxDepth + }); + return false; } - if (!this.noDirRecurse && job.stat.isDirectory() && !job.readdir) { - if (this.readdirCache.has(job.absolute)) { - this[ONREADDIR](job, this.readdirCache.get(job.absolute)); - } else { - this[READDIR](job); + if (!this.preservePaths) { + if (parts.includes("..") || /* c8 ignore next */ + isWindows3 && /^[a-z]:\.\.$/i.test(parts[0] ?? "")) { + this.warn("TAR_ENTRY_ERROR", `path contains '..'`, { + entry, + path: p + }); + return false; } - if (!job.readdir) { - return; + const [root, stripped] = stripAbsolutePath(p); + if (root) { + entry.path = String(stripped); + this.warn("TAR_ENTRY_INFO", `stripping ${root} from absolute path`, { + entry, + path: p + }); } } - job.entry = this[ENTRY](job); - if (!job.entry) { - job.ignore = true; - return; + if (import_node_path7.default.isAbsolute(entry.path)) { + entry.absolute = normalizeWindowsPath(import_node_path7.default.resolve(entry.path)); + } else { + entry.absolute = normalizeWindowsPath(import_node_path7.default.resolve(this.cwd, entry.path)); } - if (job === this[CURRENT] && !job.piped) { - this[PIPE](job); + if (!this.preservePaths && typeof entry.absolute === "string" && entry.absolute.indexOf(this.cwd + "/") !== 0 && entry.absolute !== this.cwd) { + this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", { + entry, + path: normalizeWindowsPath(entry.path), + resolvedPath: entry.absolute, + cwd: this.cwd + }); + return false; } - } - [ENTRYOPT](job) { - return { - onwarn: (code, msg, data) => this.warn(code, msg, data), - noPax: this.noPax, - cwd: this.cwd, - absolute: job.absolute, - preservePaths: this.preservePaths, - maxReadSize: this.maxReadSize, - strict: this.strict, - portable: this.portable, - linkCache: this.linkCache, - statCache: this.statCache, - noMtime: this.noMtime, - mtime: this.mtime, - prefix: this.prefix - }; - } - [ENTRY](job) { - this[JOBS] += 1; - try { - return new this[WRITEENTRYCLASS](job.path, this[ENTRYOPT](job)).on("end", () => this[JOBDONE](job)).on("error", (er) => this.emit("error", er)); - } catch (er) { - this.emit("error", er); + if (entry.absolute === this.cwd && entry.type !== "Directory" && entry.type !== "GNUDumpDir") { + return false; } - } - [ONDRAIN]() { - if (this[CURRENT] && this[CURRENT].entry) { - this[CURRENT].entry.resume(); + if (this.win32) { + const { root: aRoot } = import_node_path7.default.win32.parse(String(entry.absolute)); + entry.absolute = aRoot + encode2(String(entry.absolute).slice(aRoot.length)); + const { root: pRoot } = import_node_path7.default.win32.parse(entry.path); + entry.path = pRoot + encode2(entry.path.slice(pRoot.length)); } + return true; } - // like .pipe() but using super, because our write() is special - [PIPE](job) { - job.piped = true; - if (job.readdir) { - job.readdir.forEach((entry) => { - const p = job.path; - const base = p === "./" ? "" : p.replace(/\/*$/, "/"); - this[ADDFSENTRY](base + entry); - }); + [ONENTRY](entry) { + if (!this[CHECKPATH](entry)) { + return entry.resume(); } - const source = job.entry; - const zip = this.zip; - if (zip) { - source.on("data", (chunk) => { - if (!zip.write(chunk)) { - source.pause(); - } - }); - } else { - source.on("data", (chunk) => { - if (!super.write(chunk)) { - source.pause(); + import_node_assert.default.equal(typeof entry.absolute, "string"); + switch (entry.type) { + case "Directory": + case "GNUDumpDir": + if (entry.mode) { + entry.mode = entry.mode | 448; } - }); + case "File": + case "OldFile": + case "ContiguousFile": + case "Link": + case "SymbolicLink": + return this[CHECKFS](entry); + case "CharacterDevice": + case "BlockDevice": + case "FIFO": + default: + return this[UNSUPPORTED](entry); } } - pause() { - if (this.zip) { - this.zip.pause(); + [ONERROR](er, entry) { + if (er.name === "CwdError") { + this.emit("error", er); + } else { + this.warn("TAR_ENTRY_ERROR", er, { entry }); + this[UNPEND](); + entry.resume(); } - return super.pause(); - } - }); - var PackSync = class extends Pack { - constructor(opt) { - super(opt); - this[WRITEENTRYCLASS] = WriteEntrySync; } - // pause/resume are no-ops in sync streams. - pause() { + [MKDIR](dir, mode, cb) { + mkdir3(normalizeWindowsPath(dir), { + uid: this.uid, + gid: this.gid, + processUid: this.processUid, + processGid: this.processGid, + umask: this.processUmask, + preserve: this.preservePaths, + unlink: this.unlink, + cache: this.dirCache, + cwd: this.cwd, + mode + }, cb); } - resume() { + [DOCHOWN](entry) { + return this.forceChown || this.preserveOwner && (typeof entry.uid === "number" && entry.uid !== this.processUid || typeof entry.gid === "number" && entry.gid !== this.processGid) || typeof this.uid === "number" && this.uid !== this.processUid || typeof this.gid === "number" && this.gid !== this.processGid; } - [STAT](job) { - const stat = this.follow ? "statSync" : "lstatSync"; - this[ONSTAT](job, fs8[stat](job.absolute)); + [UID](entry) { + return uint32(this.uid, entry.uid, this.processUid); } - [READDIR](job, stat) { - this[ONREADDIR](job, fs8.readdirSync(job.absolute)); + [GID](entry) { + return uint32(this.gid, entry.gid, this.processGid); } - // gotta get it all in this tick - [PIPE](job) { - const source = job.entry; - const zip = this.zip; - if (job.readdir) { - job.readdir.forEach((entry) => { - const p = job.path; - const base = p === "./" ? "" : p.replace(/\/*$/, "/"); - this[ADDFSENTRY](base + entry); - }); - } - if (zip) { - source.on("data", (chunk) => { - zip.write(chunk); - }); - } else { - source.on("data", (chunk) => { - super[WRITE](chunk); + [FILE](entry, fullyDone) { + const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.fmode; + const stream = new WriteStream(String(entry.absolute), { + // slight lie, but it can be numeric flags + flags: getWriteFlag(entry.size), + mode, + autoClose: false + }); + stream.on("error", (er) => { + if (stream.fd) { + import_node_fs3.default.close(stream.fd, () => { + }); + } + stream.write = () => true; + this[ONERROR](er, entry); + fullyDone(); + }); + let actions = 1; + const done = (er) => { + if (er) { + if (stream.fd) { + import_node_fs3.default.close(stream.fd, () => { + }); + } + this[ONERROR](er, entry); + fullyDone(); + return; + } + if (--actions === 0) { + if (stream.fd !== void 0) { + import_node_fs3.default.close(stream.fd, (er2) => { + if (er2) { + this[ONERROR](er2, entry); + } else { + this[UNPEND](); + } + fullyDone(); + }); + } + } + }; + stream.on("finish", () => { + const abs = String(entry.absolute); + const fd = stream.fd; + if (typeof fd === "number" && entry.mtime && !this.noMtime) { + actions++; + const atime = entry.atime || /* @__PURE__ */ new Date(); + const mtime = entry.mtime; + import_node_fs3.default.futimes(fd, atime, mtime, (er) => er ? import_node_fs3.default.utimes(abs, atime, mtime, (er2) => done(er2 && er)) : done()); + } + if (typeof fd === "number" && this[DOCHOWN](entry)) { + actions++; + const uid = this[UID](entry); + const gid = this[GID](entry); + if (typeof uid === "number" && typeof gid === "number") { + import_node_fs3.default.fchown(fd, uid, gid, (er) => er ? import_node_fs3.default.chown(abs, uid, gid, (er2) => done(er2 && er)) : done()); + } + } + done(); + }); + const tx = this.transform ? this.transform(entry) || entry : entry; + if (tx !== entry) { + tx.on("error", (er) => { + this[ONERROR](er, entry); + fullyDone(); }); + entry.pipe(tx); } + tx.pipe(stream); } - }; - Pack.Sync = PackSync; - module2.exports = Pack; - } -}); - -// .yarn/cache/fs-minipass-npm-2.1.0-501ef87306-703d16522b.zip/node_modules/fs-minipass/index.js -var require_fs_minipass = __commonJS({ - ".yarn/cache/fs-minipass-npm-2.1.0-501ef87306-703d16522b.zip/node_modules/fs-minipass/index.js"(exports2) { - "use strict"; - var MiniPass = require_minipass2(); - var EE = require("events").EventEmitter; - var fs8 = require("fs"); - var writev = fs8.writev; - if (!writev) { - const binding = process.binding("fs"); - const FSReqWrap = binding.FSReqWrap || binding.FSReqCallback; - writev = (fd, iovec, pos, cb) => { - const done = (er, bw) => cb(er, bw, iovec); - const req = new FSReqWrap(); - req.oncomplete = done; - binding.writeBuffers(fd, iovec, pos, req); - }; - } - var _autoClose = Symbol("_autoClose"); - var _close = Symbol("_close"); - var _ended = Symbol("_ended"); - var _fd = Symbol("_fd"); - var _finished = Symbol("_finished"); - var _flags = Symbol("_flags"); - var _flush = Symbol("_flush"); - var _handleChunk = Symbol("_handleChunk"); - var _makeBuf = Symbol("_makeBuf"); - var _mode = Symbol("_mode"); - var _needDrain = Symbol("_needDrain"); - var _onerror = Symbol("_onerror"); - var _onopen = Symbol("_onopen"); - var _onread = Symbol("_onread"); - var _onwrite = Symbol("_onwrite"); - var _open = Symbol("_open"); - var _path = Symbol("_path"); - var _pos = Symbol("_pos"); - var _queue = Symbol("_queue"); - var _read = Symbol("_read"); - var _readSize = Symbol("_readSize"); - var _reading = Symbol("_reading"); - var _remain = Symbol("_remain"); - var _size = Symbol("_size"); - var _write = Symbol("_write"); - var _writing = Symbol("_writing"); - var _defaultFlag = Symbol("_defaultFlag"); - var _errored = Symbol("_errored"); - var ReadStream = class extends MiniPass { - constructor(path10, opt) { - opt = opt || {}; - super(opt); - this.readable = true; - this.writable = false; - if (typeof path10 !== "string") - throw new TypeError("path must be a string"); - this[_errored] = false; - this[_fd] = typeof opt.fd === "number" ? opt.fd : null; - this[_path] = path10; - this[_readSize] = opt.readSize || 16 * 1024 * 1024; - this[_reading] = false; - this[_size] = typeof opt.size === "number" ? opt.size : Infinity; - this[_remain] = this[_size]; - this[_autoClose] = typeof opt.autoClose === "boolean" ? opt.autoClose : true; - if (typeof this[_fd] === "number") - this[_read](); - else - this[_open](); - } - get fd() { - return this[_fd]; - } - get path() { - return this[_path]; + [DIRECTORY](entry, fullyDone) { + const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.dmode; + this[MKDIR](String(entry.absolute), mode, (er) => { + if (er) { + this[ONERROR](er, entry); + fullyDone(); + return; + } + let actions = 1; + const done = () => { + if (--actions === 0) { + fullyDone(); + this[UNPEND](); + entry.resume(); + } + }; + if (entry.mtime && !this.noMtime) { + actions++; + import_node_fs3.default.utimes(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime, done); + } + if (this[DOCHOWN](entry)) { + actions++; + import_node_fs3.default.chown(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry)), done); + } + done(); + }); } - write() { - throw new TypeError("this is a readable stream"); + [UNSUPPORTED](entry) { + entry.unsupported = true; + this.warn("TAR_ENTRY_UNSUPPORTED", `unsupported entry type: ${entry.type}`, { entry }); + entry.resume(); } - end() { - throw new TypeError("this is a readable stream"); + [SYMLINK](entry, done) { + this[LINK](entry, String(entry.linkpath), "symlink", done); } - [_open]() { - fs8.open(this[_path], "r", (er, fd) => this[_onopen](er, fd)); + [HARDLINK](entry, done) { + const linkpath = normalizeWindowsPath(import_node_path7.default.resolve(this.cwd, String(entry.linkpath))); + this[LINK](entry, linkpath, "link", done); } - [_onopen](er, fd) { - if (er) - this[_onerror](er); - else { - this[_fd] = fd; - this.emit("open", fd); - this[_read](); - } + [PEND]() { + this[PENDING]++; } - [_makeBuf]() { - return Buffer.allocUnsafe(Math.min(this[_readSize], this[_remain])); + [UNPEND]() { + this[PENDING]--; + this[MAYBECLOSE](); } - [_read]() { - if (!this[_reading]) { - this[_reading] = true; - const buf = this[_makeBuf](); - if (buf.length === 0) - return process.nextTick(() => this[_onread](null, 0, buf)); - fs8.read(this[_fd], buf, 0, buf.length, null, (er, br, buf2) => this[_onread](er, br, buf2)); - } + [SKIP](entry) { + this[UNPEND](); + entry.resume(); } - [_onread](er, br, buf) { - this[_reading] = false; - if (er) - this[_onerror](er); - else if (this[_handleChunk](br, buf)) - this[_read](); + // Check if we can reuse an existing filesystem entry safely and + // overwrite it, rather than unlinking and recreating + // Windows doesn't report a useful nlink, so we just never reuse entries + [ISREUSABLE](entry, st) { + return entry.type === "File" && !this.unlink && st.isFile() && st.nlink <= 1 && !isWindows3; } - [_close]() { - if (this[_autoClose] && typeof this[_fd] === "number") { - const fd = this[_fd]; - this[_fd] = null; - fs8.close(fd, (er) => er ? this.emit("error", er) : this.emit("close")); + // check if a thing is there, and if so, try to clobber it + [CHECKFS](entry) { + this[PEND](); + const paths = [entry.path]; + if (entry.linkpath) { + paths.push(entry.linkpath); } + this.reservations.reserve(paths, (done) => this[CHECKFS2](entry, done)); } - [_onerror](er) { - this[_reading] = true; - this[_close](); - this.emit("error", er); - } - [_handleChunk](br, buf) { - let ret = false; - this[_remain] -= br; - if (br > 0) - ret = super.write(br < buf.length ? buf.slice(0, br) : buf); - if (br === 0 || this[_remain] <= 0) { - ret = false; - this[_close](); - super.end(); + [PRUNECACHE](entry) { + if (entry.type === "SymbolicLink") { + dropCache(this.dirCache); + } else if (entry.type !== "Directory") { + pruneCache(this.dirCache, String(entry.absolute)); } - return ret; } - emit(ev, data) { - switch (ev) { - case "prefinish": - case "finish": - break; - case "drain": - if (typeof this[_fd] === "number") - this[_read](); - break; - case "error": - if (this[_errored]) + [CHECKFS2](entry, fullyDone) { + this[PRUNECACHE](entry); + const done = (er) => { + this[PRUNECACHE](entry); + fullyDone(er); + }; + const checkCwd2 = () => { + this[MKDIR](this.cwd, this.dmode, (er) => { + if (er) { + this[ONERROR](er, entry); + done(); return; - this[_errored] = true; - return super.emit(ev, data); - default: - return super.emit(ev, data); - } - } - }; - var ReadStreamSync = class extends ReadStream { - [_open]() { - let threw = true; - try { - this[_onopen](null, fs8.openSync(this[_path], "r")); - threw = false; - } finally { - if (threw) - this[_close](); - } - } - [_read]() { - let threw = true; - try { - if (!this[_reading]) { - this[_reading] = true; - do { - const buf = this[_makeBuf](); - const br = buf.length === 0 ? 0 : fs8.readSync(this[_fd], buf, 0, buf.length, null); - if (!this[_handleChunk](br, buf)) - break; - } while (true); - this[_reading] = false; + } + this[CHECKED_CWD] = true; + start(); + }); + }; + const start = () => { + if (entry.absolute !== this.cwd) { + const parent = normalizeWindowsPath(import_node_path7.default.dirname(String(entry.absolute))); + if (parent !== this.cwd) { + return this[MKDIR](parent, this.dmode, (er) => { + if (er) { + this[ONERROR](er, entry); + done(); + return; + } + afterMakeParent(); + }); + } } - threw = false; - } finally { - if (threw) - this[_close](); + afterMakeParent(); + }; + const afterMakeParent = () => { + import_node_fs3.default.lstat(String(entry.absolute), (lstatEr, st) => { + if (st && (this.keep || /* c8 ignore next */ + this.newer && st.mtime > (entry.mtime ?? st.mtime))) { + this[SKIP](entry); + done(); + return; + } + if (lstatEr || this[ISREUSABLE](entry, st)) { + return this[MAKEFS](null, entry, done); + } + if (st.isDirectory()) { + if (entry.type === "Directory") { + const needChmod = this.chmod && entry.mode && (st.mode & 4095) !== entry.mode; + const afterChmod = (er) => this[MAKEFS](er ?? null, entry, done); + if (!needChmod) { + return afterChmod(); + } + return import_node_fs3.default.chmod(String(entry.absolute), Number(entry.mode), afterChmod); + } + if (entry.absolute !== this.cwd) { + return import_node_fs3.default.rmdir(String(entry.absolute), (er) => this[MAKEFS](er ?? null, entry, done)); + } + } + if (entry.absolute === this.cwd) { + return this[MAKEFS](null, entry, done); + } + unlinkFile(String(entry.absolute), (er) => this[MAKEFS](er ?? null, entry, done)); + }); + }; + if (this[CHECKED_CWD]) { + start(); + } else { + checkCwd2(); } } - [_close]() { - if (this[_autoClose] && typeof this[_fd] === "number") { - const fd = this[_fd]; - this[_fd] = null; - fs8.closeSync(fd); - this.emit("close"); + [MAKEFS](er, entry, done) { + if (er) { + this[ONERROR](er, entry); + done(); + return; } - } - }; - var WriteStream = class extends EE { - constructor(path10, opt) { - opt = opt || {}; - super(opt); - this.readable = false; - this.writable = true; - this[_errored] = false; - this[_writing] = false; - this[_ended] = false; - this[_needDrain] = false; - this[_queue] = []; - this[_path] = path10; - this[_fd] = typeof opt.fd === "number" ? opt.fd : null; - this[_mode] = opt.mode === void 0 ? 438 : opt.mode; - this[_pos] = typeof opt.start === "number" ? opt.start : null; - this[_autoClose] = typeof opt.autoClose === "boolean" ? opt.autoClose : true; - const defaultFlag = this[_pos] !== null ? "r+" : "w"; - this[_defaultFlag] = opt.flags === void 0; - this[_flags] = this[_defaultFlag] ? defaultFlag : opt.flags; - if (this[_fd] === null) - this[_open](); - } - emit(ev, data) { - if (ev === "error") { - if (this[_errored]) - return; - this[_errored] = true; + switch (entry.type) { + case "File": + case "OldFile": + case "ContiguousFile": + return this[FILE](entry, done); + case "Link": + return this[HARDLINK](entry, done); + case "SymbolicLink": + return this[SYMLINK](entry, done); + case "Directory": + case "GNUDumpDir": + return this[DIRECTORY](entry, done); } - return super.emit(ev, data); - } - get fd() { - return this[_fd]; - } - get path() { - return this[_path]; - } - [_onerror](er) { - this[_close](); - this[_writing] = true; - this.emit("error", er); } - [_open]() { - fs8.open( - this[_path], - this[_flags], - this[_mode], - (er, fd) => this[_onopen](er, fd) - ); + [LINK](entry, linkpath, link, done) { + import_node_fs3.default[link](linkpath, String(entry.absolute), (er) => { + if (er) { + this[ONERROR](er, entry); + } else { + this[UNPEND](); + entry.resume(); + } + done(); + }); } - [_onopen](er, fd) { - if (this[_defaultFlag] && this[_flags] === "r+" && er && er.code === "ENOENT") { - this[_flags] = "w"; - this[_open](); - } else if (er) - this[_onerror](er); - else { - this[_fd] = fd; - this.emit("open", fd); - this[_flush](); - } + }; + callSync = (fn2) => { + try { + return [null, fn2()]; + } catch (er) { + return [er, null]; } - end(buf, enc) { - if (buf) - this.write(buf, enc); - this[_ended] = true; - if (!this[_writing] && !this[_queue].length && typeof this[_fd] === "number") - this[_onwrite](null, 0); - return this; + }; + UnpackSync = class extends Unpack { + sync = true; + [MAKEFS](er, entry) { + return super[MAKEFS](er, entry, () => { + }); } - write(buf, enc) { - if (typeof buf === "string") - buf = Buffer.from(buf, enc); - if (this[_ended]) { - this.emit("error", new Error("write() after end()")); - return false; - } - if (this[_fd] === null || this[_writing] || this[_queue].length) { - this[_queue].push(buf); - this[_needDrain] = true; - return false; + [CHECKFS](entry) { + this[PRUNECACHE](entry); + if (!this[CHECKED_CWD]) { + const er2 = this[MKDIR](this.cwd, this.dmode); + if (er2) { + return this[ONERROR](er2, entry); + } + this[CHECKED_CWD] = true; } - this[_writing] = true; - this[_write](buf); - return true; - } - [_write](buf) { - fs8.write(this[_fd], buf, 0, buf.length, this[_pos], (er, bw) => this[_onwrite](er, bw)); - } - [_onwrite](er, bw) { - if (er) - this[_onerror](er); - else { - if (this[_pos] !== null) - this[_pos] += bw; - if (this[_queue].length) - this[_flush](); - else { - this[_writing] = false; - if (this[_ended] && !this[_finished]) { - this[_finished] = true; - this[_close](); - this.emit("finish"); - } else if (this[_needDrain]) { - this[_needDrain] = false; - this.emit("drain"); + if (entry.absolute !== this.cwd) { + const parent = normalizeWindowsPath(import_node_path7.default.dirname(String(entry.absolute))); + if (parent !== this.cwd) { + const mkParent = this[MKDIR](parent, this.dmode); + if (mkParent) { + return this[ONERROR](mkParent, entry); } } } - } - [_flush]() { - if (this[_queue].length === 0) { - if (this[_ended]) - this[_onwrite](null, 0); - } else if (this[_queue].length === 1) - this[_write](this[_queue].pop()); - else { - const iovec = this[_queue]; - this[_queue] = []; - writev( - this[_fd], - iovec, - this[_pos], - (er, bw) => this[_onwrite](er, bw) - ); + const [lstatEr, st] = callSync(() => import_node_fs3.default.lstatSync(String(entry.absolute))); + if (st && (this.keep || /* c8 ignore next */ + this.newer && st.mtime > (entry.mtime ?? st.mtime))) { + return this[SKIP](entry); } - } - [_close]() { - if (this[_autoClose] && typeof this[_fd] === "number") { - const fd = this[_fd]; - this[_fd] = null; - fs8.close(fd, (er) => er ? this.emit("error", er) : this.emit("close")); + if (lstatEr || this[ISREUSABLE](entry, st)) { + return this[MAKEFS](null, entry); } + if (st.isDirectory()) { + if (entry.type === "Directory") { + const needChmod = this.chmod && entry.mode && (st.mode & 4095) !== entry.mode; + const [er3] = needChmod ? callSync(() => { + import_node_fs3.default.chmodSync(String(entry.absolute), Number(entry.mode)); + }) : []; + return this[MAKEFS](er3, entry); + } + const [er2] = callSync(() => import_node_fs3.default.rmdirSync(String(entry.absolute))); + this[MAKEFS](er2, entry); + } + const [er] = entry.absolute === this.cwd ? [] : callSync(() => unlinkFileSync(String(entry.absolute))); + this[MAKEFS](er, entry); } - }; - var WriteStreamSync = class extends WriteStream { - [_open]() { + [FILE](entry, done) { + const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.fmode; + const oner = (er) => { + let closeError; + try { + import_node_fs3.default.closeSync(fd); + } catch (e) { + closeError = e; + } + if (er || closeError) { + this[ONERROR](er || closeError, entry); + } + done(); + }; let fd; - if (this[_defaultFlag] && this[_flags] === "r+") { + try { + fd = import_node_fs3.default.openSync(String(entry.absolute), getWriteFlag(entry.size), mode); + } catch (er) { + return oner(er); + } + const tx = this.transform ? this.transform(entry) || entry : entry; + if (tx !== entry) { + tx.on("error", (er) => this[ONERROR](er, entry)); + entry.pipe(tx); + } + tx.on("data", (chunk) => { try { - fd = fs8.openSync(this[_path], this[_flags], this[_mode]); + import_node_fs3.default.writeSync(fd, chunk, 0, chunk.length); } catch (er) { - if (er.code === "ENOENT") { - this[_flags] = "w"; - return this[_open](); - } else - throw er; + oner(er); } - } else - fd = fs8.openSync(this[_path], this[_flags], this[_mode]); - this[_onopen](null, fd); - } - [_close]() { - if (this[_autoClose] && typeof this[_fd] === "number") { - const fd = this[_fd]; - this[_fd] = null; - fs8.closeSync(fd); - this.emit("close"); - } - } - [_write](buf) { - let threw = true; - try { - this[_onwrite]( - null, - fs8.writeSync(this[_fd], buf, 0, buf.length, this[_pos]) - ); - threw = false; - } finally { - if (threw) + }); + tx.on("end", () => { + let er = null; + if (entry.mtime && !this.noMtime) { + const atime = entry.atime || /* @__PURE__ */ new Date(); + const mtime = entry.mtime; try { - this[_close](); - } catch (_) { + import_node_fs3.default.futimesSync(fd, atime, mtime); + } catch (futimeser) { + try { + import_node_fs3.default.utimesSync(String(entry.absolute), atime, mtime); + } catch (utimeser) { + er = futimeser; + } + } + } + if (this[DOCHOWN](entry)) { + const uid = this[UID](entry); + const gid = this[GID](entry); + try { + import_node_fs3.default.fchownSync(fd, Number(uid), Number(gid)); + } catch (fchowner) { + try { + import_node_fs3.default.chownSync(String(entry.absolute), Number(uid), Number(gid)); + } catch (chowner) { + er = er || fchowner; + } } - } - } - }; - exports2.ReadStream = ReadStream; - exports2.ReadStreamSync = ReadStreamSync; - exports2.WriteStream = WriteStream; - exports2.WriteStreamSync = WriteStreamSync; - } -}); - -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/parse.js -var require_parse2 = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/parse.js"(exports2, module2) { - "use strict"; - var warner = require_warn_mixin(); - var Header = require_header(); - var EE = require("events"); - var Yallist = require_yallist(); - var maxMetaEntrySize = 1024 * 1024; - var Entry = require_read_entry(); - var Pax = require_pax(); - var zlib = require_minizlib(); - var { nextTick } = require("process"); - var gzipHeader = Buffer.from([31, 139]); - var STATE = Symbol("state"); - var WRITEENTRY = Symbol("writeEntry"); - var READENTRY = Symbol("readEntry"); - var NEXTENTRY = Symbol("nextEntry"); - var PROCESSENTRY = Symbol("processEntry"); - var EX = Symbol("extendedHeader"); - var GEX = Symbol("globalExtendedHeader"); - var META = Symbol("meta"); - var EMITMETA = Symbol("emitMeta"); - var BUFFER = Symbol("buffer"); - var QUEUE = Symbol("queue"); - var ENDED = Symbol("ended"); - var EMITTEDEND = Symbol("emittedEnd"); - var EMIT = Symbol("emit"); - var UNZIP = Symbol("unzip"); - var CONSUMECHUNK = Symbol("consumeChunk"); - var CONSUMECHUNKSUB = Symbol("consumeChunkSub"); - var CONSUMEBODY = Symbol("consumeBody"); - var CONSUMEMETA = Symbol("consumeMeta"); - var CONSUMEHEADER = Symbol("consumeHeader"); - var CONSUMING = Symbol("consuming"); - var BUFFERCONCAT = Symbol("bufferConcat"); - var MAYBEEND = Symbol("maybeEnd"); - var WRITING = Symbol("writing"); - var ABORTED = Symbol("aborted"); - var DONE = Symbol("onDone"); - var SAW_VALID_ENTRY = Symbol("sawValidEntry"); - var SAW_NULL_BLOCK = Symbol("sawNullBlock"); - var SAW_EOF = Symbol("sawEOF"); - var CLOSESTREAM = Symbol("closeStream"); - var noop = (_) => true; - module2.exports = warner(class Parser extends EE { - constructor(opt) { - opt = opt || {}; - super(opt); - this.file = opt.file || ""; - this[SAW_VALID_ENTRY] = null; - this.on(DONE, (_) => { - if (this[STATE] === "begin" || this[SAW_VALID_ENTRY] === false) { - this.warn("TAR_BAD_ARCHIVE", "Unrecognized archive format"); } + oner(er); }); - if (opt.ondone) { - this.on(DONE, opt.ondone); - } else { - this.on(DONE, (_) => { - this.emit("prefinish"); - this.emit("finish"); - this.emit("end"); - }); + } + [DIRECTORY](entry, done) { + const mode = typeof entry.mode === "number" ? entry.mode & 4095 : this.dmode; + const er = this[MKDIR](String(entry.absolute), mode); + if (er) { + this[ONERROR](er, entry); + done(); + return; } - this.strict = !!opt.strict; - this.maxMetaEntrySize = opt.maxMetaEntrySize || maxMetaEntrySize; - this.filter = typeof opt.filter === "function" ? opt.filter : noop; - const isTBR = opt.file && (opt.file.endsWith(".tar.br") || opt.file.endsWith(".tbr")); - this.brotli = !opt.gzip && opt.brotli !== void 0 ? opt.brotli : isTBR ? void 0 : false; - this.writable = true; - this.readable = false; - this[QUEUE] = new Yallist(); - this[BUFFER] = null; - this[READENTRY] = null; - this[WRITEENTRY] = null; - this[STATE] = "begin"; - this[META] = ""; - this[EX] = null; - this[GEX] = null; - this[ENDED] = false; - this[UNZIP] = null; - this[ABORTED] = false; - this[SAW_NULL_BLOCK] = false; - this[SAW_EOF] = false; - this.on("end", () => this[CLOSESTREAM]()); - if (typeof opt.onwarn === "function") { - this.on("warn", opt.onwarn); + if (entry.mtime && !this.noMtime) { + try { + import_node_fs3.default.utimesSync(String(entry.absolute), entry.atime || /* @__PURE__ */ new Date(), entry.mtime); + } catch (er2) { + } } - if (typeof opt.onentry === "function") { - this.on("entry", opt.onentry); + if (this[DOCHOWN](entry)) { + try { + import_node_fs3.default.chownSync(String(entry.absolute), Number(this[UID](entry)), Number(this[GID](entry))); + } catch (er2) { + } } + done(); + entry.resume(); } - [CONSUMEHEADER](chunk, position) { - if (this[SAW_VALID_ENTRY] === null) { - this[SAW_VALID_ENTRY] = false; + [MKDIR](dir, mode) { + try { + return mkdirSync4(normalizeWindowsPath(dir), { + uid: this.uid, + gid: this.gid, + processUid: this.processUid, + processGid: this.processGid, + umask: this.processUmask, + preserve: this.preservePaths, + unlink: this.unlink, + cache: this.dirCache, + cwd: this.cwd, + mode + }); + } catch (er) { + return er; } - let header; + } + [LINK](entry, linkpath, link, done) { + const ls = `${link}Sync`; try { - header = new Header(chunk, position, this[EX], this[GEX]); + import_node_fs3.default[ls](linkpath, String(entry.absolute)); + done(); + entry.resume(); } catch (er) { - return this.warn("TAR_ENTRY_INVALID", er); + return this[ONERROR](er, entry); } - if (header.nullBlock) { - if (this[SAW_NULL_BLOCK]) { - this[SAW_EOF] = true; - if (this[STATE] === "begin") { - this[STATE] = "header"; - } - this[EMIT]("eof"); - } else { - this[SAW_NULL_BLOCK] = true; - this[EMIT]("nullBlock"); - } - } else { - this[SAW_NULL_BLOCK] = false; - if (!header.cksumValid) { - this.warn("TAR_ENTRY_INVALID", "checksum failure", { header }); - } else if (!header.path) { - this.warn("TAR_ENTRY_INVALID", "path is required", { header }); + } + }; + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/extract.js +var extract_exports = {}; +__export(extract_exports, { + extract: () => extract +}); +var import_node_fs4, extractFileSync, extractFile, extract; +var init_extract = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/extract.js"() { + init_esm2(); + import_node_fs4 = __toESM(require("node:fs"), 1); + init_list(); + init_make_command(); + init_unpack(); + extractFileSync = (opt) => { + const u = new UnpackSync(opt); + const file = opt.file; + const stat2 = import_node_fs4.default.statSync(file); + const readSize = opt.maxReadSize || 16 * 1024 * 1024; + const stream = new ReadStreamSync(file, { + readSize, + size: stat2.size + }); + stream.pipe(u); + }; + extractFile = (opt, _) => { + const u = new Unpack(opt); + const readSize = opt.maxReadSize || 16 * 1024 * 1024; + const file = opt.file; + const p = new Promise((resolve2, reject) => { + u.on("error", reject); + u.on("close", resolve2); + import_node_fs4.default.stat(file, (er, stat2) => { + if (er) { + reject(er); } else { - const type = header.type; - if (/^(Symbolic)?Link$/.test(type) && !header.linkpath) { - this.warn("TAR_ENTRY_INVALID", "linkpath required", { header }); - } else if (!/^(Symbolic)?Link$/.test(type) && header.linkpath) { - this.warn("TAR_ENTRY_INVALID", "linkpath forbidden", { header }); - } else { - const entry = this[WRITEENTRY] = new Entry(header, this[EX], this[GEX]); - if (!this[SAW_VALID_ENTRY]) { - if (entry.remain) { - const onend = () => { - if (!entry.invalid) { - this[SAW_VALID_ENTRY] = true; - } - }; - entry.on("end", onend); - } else { - this[SAW_VALID_ENTRY] = true; - } - } - if (entry.meta) { - if (entry.size > this.maxMetaEntrySize) { - entry.ignore = true; - this[EMIT]("ignoredEntry", entry); - this[STATE] = "ignore"; - entry.resume(); - } else if (entry.size > 0) { - this[META] = ""; - entry.on("data", (c) => this[META] += c); - this[STATE] = "meta"; - } - } else { - this[EX] = null; - entry.ignore = entry.ignore || !this.filter(entry.path, entry); - if (entry.ignore) { - this[EMIT]("ignoredEntry", entry); - this[STATE] = entry.remain ? "ignore" : "header"; - entry.resume(); - } else { - if (entry.remain) { - this[STATE] = "body"; - } else { - this[STATE] = "header"; - entry.end(); - } - if (!this[READENTRY]) { - this[QUEUE].push(entry); - this[NEXTENTRY](); - } else { - this[QUEUE].push(entry); - } - } - } - } + const stream = new ReadStream(file, { + readSize, + size: stat2.size + }); + stream.on("error", reject); + stream.pipe(u); } - } - } - [CLOSESTREAM]() { - nextTick(() => this.emit("close")); + }); + }); + return p; + }; + extract = makeCommand(extractFileSync, extractFile, (opt) => new UnpackSync(opt), (opt) => new Unpack(opt), (opt, files) => { + if (files?.length) + filesFilter(opt, files); + }); + } +}); + +// .yarn/cache/v8-compile-cache-npm-2.4.0-5979f8e405-3878511925.zip/node_modules/v8-compile-cache/v8-compile-cache.js +var require_v8_compile_cache = __commonJS({ + ".yarn/cache/v8-compile-cache-npm-2.4.0-5979f8e405-3878511925.zip/node_modules/v8-compile-cache/v8-compile-cache.js"(exports2, module2) { + "use strict"; + var Module2 = require("module"); + var crypto = require("crypto"); + var fs17 = require("fs"); + var path16 = require("path"); + var vm = require("vm"); + var os3 = require("os"); + var hasOwnProperty2 = Object.prototype.hasOwnProperty; + var FileSystemBlobStore = class { + constructor(directory, prefix) { + const name2 = prefix ? slashEscape(prefix + ".") : ""; + this._blobFilename = path16.join(directory, name2 + "BLOB"); + this._mapFilename = path16.join(directory, name2 + "MAP"); + this._lockFilename = path16.join(directory, name2 + "LOCK"); + this._directory = directory; + this._load(); } - [PROCESSENTRY](entry) { - let go = true; - if (!entry) { - this[READENTRY] = null; - go = false; - } else if (Array.isArray(entry)) { - this.emit.apply(this, entry); - } else { - this[READENTRY] = entry; - this.emit("entry", entry); - if (!entry.emittedEnd) { - entry.on("end", (_) => this[NEXTENTRY]()); - go = false; - } + has(key, invalidationKey) { + if (hasOwnProperty2.call(this._memoryBlobs, key)) { + return this._invalidationKeys[key] === invalidationKey; + } else if (hasOwnProperty2.call(this._storedMap, key)) { + return this._storedMap[key][0] === invalidationKey; } - return go; + return false; } - [NEXTENTRY]() { - do { - } while (this[PROCESSENTRY](this[QUEUE].shift())); - if (!this[QUEUE].length) { - const re = this[READENTRY]; - const drainNow = !re || re.flowing || re.size === re.remain; - if (drainNow) { - if (!this[WRITING]) { - this.emit("drain"); - } - } else { - re.once("drain", (_) => this.emit("drain")); + get(key, invalidationKey) { + if (hasOwnProperty2.call(this._memoryBlobs, key)) { + if (this._invalidationKeys[key] === invalidationKey) { + return this._memoryBlobs[key]; + } + } else if (hasOwnProperty2.call(this._storedMap, key)) { + const mapping = this._storedMap[key]; + if (mapping[0] === invalidationKey) { + return this._storedBlob.slice(mapping[1], mapping[2]); } } } - [CONSUMEBODY](chunk, position) { - const entry = this[WRITEENTRY]; - const br = entry.blockRemain; - const c = br >= chunk.length && position === 0 ? chunk : chunk.slice(position, position + br); - entry.write(c); - if (!entry.blockRemain) { - this[STATE] = "header"; - this[WRITEENTRY] = null; - entry.end(); - } - return c.length; + set(key, invalidationKey, buffer) { + this._invalidationKeys[key] = invalidationKey; + this._memoryBlobs[key] = buffer; + this._dirty = true; } - [CONSUMEMETA](chunk, position) { - const entry = this[WRITEENTRY]; - const ret = this[CONSUMEBODY](chunk, position); - if (!this[WRITEENTRY]) { - this[EMITMETA](entry); + delete(key) { + if (hasOwnProperty2.call(this._memoryBlobs, key)) { + this._dirty = true; + delete this._memoryBlobs[key]; } - return ret; - } - [EMIT](ev, data, extra) { - if (!this[QUEUE].length && !this[READENTRY]) { - this.emit(ev, data, extra); - } else { - this[QUEUE].push([ev, data, extra]); + if (hasOwnProperty2.call(this._invalidationKeys, key)) { + this._dirty = true; + delete this._invalidationKeys[key]; } - } - [EMITMETA](entry) { - this[EMIT]("meta", this[META]); - switch (entry.type) { - case "ExtendedHeader": - case "OldExtendedHeader": - this[EX] = Pax.parse(this[META], this[EX], false); - break; - case "GlobalExtendedHeader": - this[GEX] = Pax.parse(this[META], this[GEX], true); - break; - case "NextFileHasLongPath": - case "OldGnuLongPath": - this[EX] = this[EX] || /* @__PURE__ */ Object.create(null); - this[EX].path = this[META].replace(/\0.*/, ""); - break; - case "NextFileHasLongLinkpath": - this[EX] = this[EX] || /* @__PURE__ */ Object.create(null); - this[EX].linkpath = this[META].replace(/\0.*/, ""); - break; - default: - throw new Error("unknown meta: " + entry.type); + if (hasOwnProperty2.call(this._storedMap, key)) { + this._dirty = true; + delete this._storedMap[key]; } } - abort(error) { - this[ABORTED] = true; - this.emit("abort", error); - this.warn("TAR_ABORT", error, { recoverable: false }); + isDirty() { + return this._dirty; } - write(chunk) { - if (this[ABORTED]) { - return; - } - const needSniff = this[UNZIP] === null || this.brotli === void 0 && this[UNZIP] === false; - if (needSniff && chunk) { - if (this[BUFFER]) { - chunk = Buffer.concat([this[BUFFER], chunk]); - this[BUFFER] = null; - } - if (chunk.length < gzipHeader.length) { - this[BUFFER] = chunk; - return true; - } - for (let i = 0; this[UNZIP] === null && i < gzipHeader.length; i++) { - if (chunk[i] !== gzipHeader[i]) { - this[UNZIP] = false; - } - } - const maybeBrotli = this.brotli === void 0; - if (this[UNZIP] === false && maybeBrotli) { - if (chunk.length < 512) { - if (this[ENDED]) { - this.brotli = true; - } else { - this[BUFFER] = chunk; - return true; - } - } else { - try { - new Header(chunk.slice(0, 512)); - this.brotli = false; - } catch (_) { - this.brotli = true; - } - } - } - if (this[UNZIP] === null || this[UNZIP] === false && this.brotli) { - const ended = this[ENDED]; - this[ENDED] = false; - this[UNZIP] = this[UNZIP] === null ? new zlib.Unzip() : new zlib.BrotliDecompress(); - this[UNZIP].on("data", (chunk2) => this[CONSUMECHUNK](chunk2)); - this[UNZIP].on("error", (er) => this.abort(er)); - this[UNZIP].on("end", (_) => { - this[ENDED] = true; - this[CONSUMECHUNK](); - }); - this[WRITING] = true; - const ret2 = this[UNZIP][ended ? "end" : "write"](chunk); - this[WRITING] = false; - return ret2; - } - } - this[WRITING] = true; - if (this[UNZIP]) { - this[UNZIP].write(chunk); - } else { - this[CONSUMECHUNK](chunk); + save() { + const dump = this._getDump(); + const blobToStore = Buffer.concat(dump[0]); + const mapToStore = JSON.stringify(dump[1]); + try { + mkdirpSync2(this._directory); + fs17.writeFileSync(this._lockFilename, "LOCK", { flag: "wx" }); + } catch (error) { + return false; } - this[WRITING] = false; - const ret = this[QUEUE].length ? false : this[READENTRY] ? this[READENTRY].flowing : true; - if (!ret && !this[QUEUE].length) { - this[READENTRY].once("drain", (_) => this.emit("drain")); + try { + fs17.writeFileSync(this._blobFilename, blobToStore); + fs17.writeFileSync(this._mapFilename, mapToStore); + } finally { + fs17.unlinkSync(this._lockFilename); } - return ret; + return true; } - [BUFFERCONCAT](c) { - if (c && !this[ABORTED]) { - this[BUFFER] = this[BUFFER] ? Buffer.concat([this[BUFFER], c]) : c; + _load() { + try { + this._storedBlob = fs17.readFileSync(this._blobFilename); + this._storedMap = JSON.parse(fs17.readFileSync(this._mapFilename)); + } catch (e) { + this._storedBlob = Buffer.alloc(0); + this._storedMap = {}; } + this._dirty = false; + this._memoryBlobs = {}; + this._invalidationKeys = {}; } - [MAYBEEND]() { - if (this[ENDED] && !this[EMITTEDEND] && !this[ABORTED] && !this[CONSUMING]) { - this[EMITTEDEND] = true; - const entry = this[WRITEENTRY]; - if (entry && entry.blockRemain) { - const have = this[BUFFER] ? this[BUFFER].length : 0; - this.warn("TAR_BAD_ARCHIVE", `Truncated input (needed ${entry.blockRemain} more bytes, only ${have} available)`, { entry }); - if (this[BUFFER]) { - entry.write(this[BUFFER]); - } - entry.end(); - } - this[EMIT](DONE); + _getDump() { + const buffers = []; + const newMap = {}; + let offset = 0; + function push2(key, invalidationKey, buffer) { + buffers.push(buffer); + newMap[key] = [invalidationKey, offset, offset + buffer.length]; + offset += buffer.length; } - } - [CONSUMECHUNK](chunk) { - if (this[CONSUMING]) { - this[BUFFERCONCAT](chunk); - } else if (!chunk && !this[BUFFER]) { - this[MAYBEEND](); - } else { - this[CONSUMING] = true; - if (this[BUFFER]) { - this[BUFFERCONCAT](chunk); - const c = this[BUFFER]; - this[BUFFER] = null; - this[CONSUMECHUNKSUB](c); - } else { - this[CONSUMECHUNKSUB](chunk); - } - while (this[BUFFER] && this[BUFFER].length >= 512 && !this[ABORTED] && !this[SAW_EOF]) { - const c = this[BUFFER]; - this[BUFFER] = null; - this[CONSUMECHUNKSUB](c); - } - this[CONSUMING] = false; + for (const key of Object.keys(this._memoryBlobs)) { + const buffer = this._memoryBlobs[key]; + const invalidationKey = this._invalidationKeys[key]; + push2(key, invalidationKey, buffer); } - if (!this[BUFFER] || this[ENDED]) { - this[MAYBEEND](); + for (const key of Object.keys(this._storedMap)) { + if (hasOwnProperty2.call(newMap, key)) continue; + const mapping = this._storedMap[key]; + const buffer = this._storedBlob.slice(mapping[1], mapping[2]); + push2(key, mapping[0], buffer); } + return [buffers, newMap]; } - [CONSUMECHUNKSUB](chunk) { - let position = 0; - const length = chunk.length; - while (position + 512 <= length && !this[ABORTED] && !this[SAW_EOF]) { - switch (this[STATE]) { - case "begin": - case "header": - this[CONSUMEHEADER](chunk, position); - position += 512; - break; - case "ignore": - case "body": - position += this[CONSUMEBODY](chunk, position); - break; - case "meta": - position += this[CONSUMEMETA](chunk, position); - break; - default: - throw new Error("invalid state: " + this[STATE]); + }; + var NativeCompileCache = class { + constructor() { + this._cacheStore = null; + this._previousModuleCompile = null; + } + setCacheStore(cacheStore) { + this._cacheStore = cacheStore; + } + install() { + const self2 = this; + const hasRequireResolvePaths = typeof require.resolve.paths === "function"; + this._previousModuleCompile = Module2.prototype._compile; + Module2.prototype._compile = function(content, filename) { + const mod = this; + function require2(id) { + return mod.require(id); } - } - if (position < length) { - if (this[BUFFER]) { - this[BUFFER] = Buffer.concat([chunk.slice(position), this[BUFFER]]); - } else { - this[BUFFER] = chunk.slice(position); + function resolve2(request, options) { + return Module2._resolveFilename(request, mod, false, options); } - } - } - end(chunk) { - if (!this[ABORTED]) { - if (this[UNZIP]) { - this[UNZIP].end(chunk); - } else { - this[ENDED] = true; - if (this.brotli === void 0) chunk = chunk || Buffer.alloc(0); - this.write(chunk); + require2.resolve = resolve2; + if (hasRequireResolvePaths) { + resolve2.paths = function paths(request) { + return Module2._resolveLookupPaths(request, mod, true); + }; } - } - } - }); - } -}); - -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/list.js -var require_list = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/list.js"(exports2, module2) { - "use strict"; - var hlo = require_high_level_opt(); - var Parser = require_parse2(); - var fs8 = require("fs"); - var fsm = require_fs_minipass(); - var path10 = require("path"); - var stripSlash = require_strip_trailing_slashes(); - module2.exports = (opt_, files, cb) => { - if (typeof opt_ === "function") { - cb = opt_, files = null, opt_ = {}; - } else if (Array.isArray(opt_)) { - files = opt_, opt_ = {}; - } - if (typeof files === "function") { - cb = files, files = null; - } - if (!files) { - files = []; - } else { - files = Array.from(files); - } - const opt = hlo(opt_); - if (opt.sync && typeof cb === "function") { - throw new TypeError("callback not supported for sync tar functions"); - } - if (!opt.file && typeof cb === "function") { - throw new TypeError("callback only supported with file option"); + require2.main = process.mainModule; + require2.extensions = Module2._extensions; + require2.cache = Module2._cache; + const dirname5 = path16.dirname(filename); + const compiledWrapper = self2._moduleCompile(filename, content); + const args = [mod.exports, require2, mod, filename, dirname5, process, global, Buffer]; + return compiledWrapper.apply(mod.exports, args); + }; } - if (files.length) { - filesFilter(opt, files); + uninstall() { + Module2.prototype._compile = this._previousModuleCompile; } - if (!opt.noResume) { - onentryFunction(opt); + _moduleCompile(filename, content) { + var contLen = content.length; + if (contLen >= 2) { + if (content.charCodeAt(0) === 35 && content.charCodeAt(1) === 33) { + if (contLen === 2) { + content = ""; + } else { + var i = 2; + for (; i < contLen; ++i) { + var code2 = content.charCodeAt(i); + if (code2 === 10 || code2 === 13) break; + } + if (i === contLen) { + content = ""; + } else { + content = content.slice(i); + } + } + } + } + var wrapper = Module2.wrap(content); + var invalidationKey = crypto.createHash("sha1").update(content, "utf8").digest("hex"); + var buffer = this._cacheStore.get(filename, invalidationKey); + var script = new vm.Script(wrapper, { + filename, + lineOffset: 0, + displayErrors: true, + cachedData: buffer, + produceCachedData: true + }); + if (script.cachedDataProduced) { + this._cacheStore.set(filename, invalidationKey, script.cachedData); + } else if (script.cachedDataRejected) { + this._cacheStore.delete(filename); + } + var compiledWrapper = script.runInThisContext({ + filename, + lineOffset: 0, + columnOffset: 0, + displayErrors: true + }); + return compiledWrapper; } - return opt.file && opt.sync ? listFileSync(opt) : opt.file ? listFile(opt, cb) : list(opt); - }; - var onentryFunction = (opt) => { - const onentry = opt.onentry; - opt.onentry = onentry ? (e) => { - onentry(e); - e.resume(); - } : (e) => e.resume(); - }; - var filesFilter = (opt, files) => { - const map = new Map(files.map((f) => [stripSlash(f), true])); - const filter = opt.filter; - const mapHas = (file, r) => { - const root = r || path10.parse(file).root || "."; - const ret = file === root ? false : map.has(file) ? map.get(file) : mapHas(path10.dirname(file), root); - map.set(file, ret); - return ret; - }; - opt.filter = filter ? (file, entry) => filter(file, entry) && mapHas(stripSlash(file)) : (file) => mapHas(stripSlash(file)); }; - var listFileSync = (opt) => { - const p = list(opt); - const file = opt.file; - let threw = true; - let fd; + function mkdirpSync2(p_) { + _mkdirpSync(path16.resolve(p_), 511); + } + function _mkdirpSync(p, mode) { try { - const stat = fs8.statSync(file); - const readSize = opt.maxReadSize || 16 * 1024 * 1024; - if (stat.size < readSize) { - p.end(fs8.readFileSync(file)); + fs17.mkdirSync(p, mode); + } catch (err0) { + if (err0.code === "ENOENT") { + _mkdirpSync(path16.dirname(p)); + _mkdirpSync(p); } else { - let pos = 0; - const buf = Buffer.allocUnsafe(readSize); - fd = fs8.openSync(file, "r"); - while (pos < stat.size) { - const bytesRead = fs8.readSync(fd, buf, 0, readSize, pos); - pos += bytesRead; - p.write(buf.slice(0, bytesRead)); - } - p.end(); - } - threw = false; - } finally { - if (threw && fd) { try { - fs8.closeSync(fd); - } catch (er) { + const stat2 = fs17.statSync(p); + if (!stat2.isDirectory()) { + throw err0; + } + } catch (err1) { + throw err0; } } } - }; - var listFile = (opt, cb) => { - const parse = new Parser(opt); - const readSize = opt.maxReadSize || 16 * 1024 * 1024; - const file = opt.file; - const p = new Promise((resolve, reject) => { - parse.on("error", reject); - parse.on("end", resolve); - fs8.stat(file, (er, stat) => { - if (er) { - reject(er); - } else { - const stream = new fsm.ReadStream(file, { - readSize, - size: stat.size - }); - stream.on("error", reject); - stream.pipe(parse); - } - }); + } + function slashEscape(str) { + const ESCAPE_LOOKUP = { + "\\": "zB", + ":": "zC", + "/": "zS", + "\0": "z0", + "z": "zZ" + }; + const ESCAPE_REGEX = /[\\:/\x00z]/g; + return str.replace(ESCAPE_REGEX, (match) => ESCAPE_LOOKUP[match]); + } + function supportsCachedData() { + const script = new vm.Script('""', { produceCachedData: true }); + return script.cachedDataProduced === true; + } + function getCacheDir() { + const v8_compile_cache_cache_dir = process.env.V8_COMPILE_CACHE_CACHE_DIR; + if (v8_compile_cache_cache_dir) { + return v8_compile_cache_cache_dir; + } + const dirname5 = typeof process.getuid === "function" ? "v8-compile-cache-" + process.getuid() : "v8-compile-cache"; + const arch = process.arch; + const version3 = typeof process.versions.v8 === "string" ? process.versions.v8 : typeof process.versions.chakracore === "string" ? "chakracore-" + process.versions.chakracore : "node-" + process.version; + const cacheDir = path16.join(os3.tmpdir(), dirname5, arch, version3); + return cacheDir; + } + function getMainName() { + const mainName = require.main && typeof require.main.filename === "string" ? require.main.filename : process.cwd(); + return mainName; + } + if (!process.env.DISABLE_V8_COMPILE_CACHE && supportsCachedData()) { + const cacheDir = getCacheDir(); + const prefix = getMainName(); + const blobStore = new FileSystemBlobStore(cacheDir, prefix); + const nativeCompileCache = new NativeCompileCache(); + nativeCompileCache.setCacheStore(blobStore); + nativeCompileCache.install(); + process.once("exit", () => { + if (blobStore.isDirty()) { + blobStore.save(); + } + nativeCompileCache.uninstall(); }); - return cb ? p.then(cb, cb) : p; + } + module2.exports.__TEST__ = { + FileSystemBlobStore, + NativeCompileCache, + mkdirpSync: mkdirpSync2, + slashEscape, + supportsCachedData, + getCacheDir, + getMainName }; - var list = (opt) => new Parser(opt); } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/create.js -var require_create = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/create.js"(exports2, module2) { +// .yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/posix.js +var require_posix = __commonJS({ + ".yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/posix.js"(exports2) { "use strict"; - var hlo = require_high_level_opt(); - var Pack = require_pack(); - var fsm = require_fs_minipass(); - var t = require_list(); - var path10 = require("path"); - module2.exports = (opt_, files, cb) => { - if (typeof files === "function") { - cb = files; - } - if (Array.isArray(opt_)) { - files = opt_, opt_ = {}; - } - if (!files || !Array.isArray(files) || !files.length) { - throw new TypeError("no files or directories specified"); - } - files = Array.from(files); - const opt = hlo(opt_); - if (opt.sync && typeof cb === "function") { - throw new TypeError("callback not supported for sync tar functions"); - } - if (!opt.file && typeof cb === "function") { - throw new TypeError("callback only supported with file option"); - } - return opt.file && opt.sync ? createFileSync(opt, files) : opt.file ? createFile(opt, files, cb) : opt.sync ? createSync(opt, files) : create(opt, files); - }; - var createFileSync = (opt, files) => { - const p = new Pack.Sync(opt); - const stream = new fsm.WriteStreamSync(opt.file, { - mode: opt.mode || 438 - }); - p.pipe(stream); - addFilesSync(p, files); - }; - var createFile = (opt, files, cb) => { - const p = new Pack(opt); - const stream = new fsm.WriteStream(opt.file, { - mode: opt.mode || 438 - }); - p.pipe(stream); - const promise = new Promise((res, rej) => { - stream.on("error", rej); - stream.on("close", res); - p.on("error", rej); - }); - addFilesAsync(p, files); - return cb ? promise.then(cb, cb) : promise; - }; - var addFilesSync = (p, files) => { - files.forEach((file) => { - if (file.charAt(0) === "@") { - t({ - file: path10.resolve(p.cwd, file.slice(1)), - sync: true, - noResume: true, - onentry: (entry) => p.add(entry) - }); - } else { - p.add(file); - } - }); - p.end(); - }; - var addFilesAsync = (p, files) => { - while (files.length) { - const file = files.shift(); - if (file.charAt(0) === "@") { - return t({ - file: path10.resolve(p.cwd, file.slice(1)), - noResume: true, - onentry: (entry) => p.add(entry) - }).then((_) => addFilesAsync(p, files)); - } else { - p.add(file); - } + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.sync = exports2.isexe = void 0; + var fs_1 = require("fs"); + var promises_1 = require("fs/promises"); + var isexe = async (path16, options = {}) => { + const { ignoreErrors = false } = options; + try { + return checkStat(await (0, promises_1.stat)(path16), options); + } catch (e) { + const er = e; + if (ignoreErrors || er.code === "EACCES") + return false; + throw er; } - p.end(); }; - var createSync = (opt, files) => { - const p = new Pack.Sync(opt); - addFilesSync(p, files); - return p; + exports2.isexe = isexe; + var sync = (path16, options = {}) => { + const { ignoreErrors = false } = options; + try { + return checkStat((0, fs_1.statSync)(path16), options); + } catch (e) { + const er = e; + if (ignoreErrors || er.code === "EACCES") + return false; + throw er; + } }; - var create = (opt, files) => { - const p = new Pack(opt); - addFilesAsync(p, files); - return p; + exports2.sync = sync; + var checkStat = (stat2, options) => stat2.isFile() && checkMode(stat2, options); + var checkMode = (stat2, options) => { + const myUid = options.uid ?? process.getuid?.(); + const myGroups = options.groups ?? process.getgroups?.() ?? []; + const myGid = options.gid ?? process.getgid?.() ?? myGroups[0]; + if (myUid === void 0 || myGid === void 0) { + throw new Error("cannot get uid or gid"); + } + const groups = /* @__PURE__ */ new Set([myGid, ...myGroups]); + const mod = stat2.mode; + const uid = stat2.uid; + const gid = stat2.gid; + const u = parseInt("100", 8); + const g = parseInt("010", 8); + const o = parseInt("001", 8); + const ug = u | g; + return !!(mod & o || mod & g && groups.has(gid) || mod & u && uid === myUid || mod & ug && myUid === 0); }; } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/replace.js -var require_replace = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/replace.js"(exports2, module2) { +// .yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/win32.js +var require_win32 = __commonJS({ + ".yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/win32.js"(exports2) { "use strict"; - var hlo = require_high_level_opt(); - var Pack = require_pack(); - var fs8 = require("fs"); - var fsm = require_fs_minipass(); - var t = require_list(); - var path10 = require("path"); - var Header = require_header(); - module2.exports = (opt_, files, cb) => { - const opt = hlo(opt_); - if (!opt.file) { - throw new TypeError("file is required"); - } - if (opt.gzip || opt.brotli || opt.file.endsWith(".br") || opt.file.endsWith(".tbr")) { - throw new TypeError("cannot append to compressed archives"); - } - if (!files || !Array.isArray(files) || !files.length) { - throw new TypeError("no files or directories specified"); - } - files = Array.from(files); - return opt.sync ? replaceSync(opt, files) : replace(opt, files, cb); - }; - var replaceSync = (opt, files) => { - const p = new Pack.Sync(opt); - let threw = true; - let fd; - let position; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.sync = exports2.isexe = void 0; + var fs_1 = require("fs"); + var promises_1 = require("fs/promises"); + var isexe = async (path16, options = {}) => { + const { ignoreErrors = false } = options; try { - try { - fd = fs8.openSync(opt.file, "r+"); - } catch (er) { - if (er.code === "ENOENT") { - fd = fs8.openSync(opt.file, "w+"); - } else { - throw er; - } - } - const st = fs8.fstatSync(fd); - const headBuf = Buffer.alloc(512); - POSITION: for (position = 0; position < st.size; position += 512) { - for (let bufPos = 0, bytes = 0; bufPos < 512; bufPos += bytes) { - bytes = fs8.readSync( - fd, - headBuf, - bufPos, - headBuf.length - bufPos, - position + bufPos - ); - if (position === 0 && headBuf[0] === 31 && headBuf[1] === 139) { - throw new Error("cannot append to compressed archives"); - } - if (!bytes) { - break POSITION; - } - } - const h = new Header(headBuf); - if (!h.cksumValid) { - break; - } - const entryBlockSize = 512 * Math.ceil(h.size / 512); - if (position + entryBlockSize + 512 > st.size) { - break; - } - position += entryBlockSize; - if (opt.mtimeCache) { - opt.mtimeCache.set(h.path, h.mtime); - } - } - threw = false; - streamSync(opt, p, position, fd, files); - } finally { - if (threw) { - try { - fs8.closeSync(fd); - } catch (er) { - } - } + return checkStat(await (0, promises_1.stat)(path16), path16, options); + } catch (e) { + const er = e; + if (ignoreErrors || er.code === "EACCES") + return false; + throw er; } }; - var streamSync = (opt, p, position, fd, files) => { - const stream = new fsm.WriteStreamSync(opt.file, { - fd, - start: position - }); - p.pipe(stream); - addFilesSync(p, files); - }; - var replace = (opt, files, cb) => { - files = Array.from(files); - const p = new Pack(opt); - const getPos = (fd, size, cb_) => { - const cb2 = (er, pos) => { - if (er) { - fs8.close(fd, (_) => cb_(er)); - } else { - cb_(null, pos); - } - }; - let position = 0; - if (size === 0) { - return cb2(null, 0); - } - let bufPos = 0; - const headBuf = Buffer.alloc(512); - const onread = (er, bytes) => { - if (er) { - return cb2(er); - } - bufPos += bytes; - if (bufPos < 512 && bytes) { - return fs8.read( - fd, - headBuf, - bufPos, - headBuf.length - bufPos, - position + bufPos, - onread - ); - } - if (position === 0 && headBuf[0] === 31 && headBuf[1] === 139) { - return cb2(new Error("cannot append to compressed archives")); - } - if (bufPos < 512) { - return cb2(null, position); - } - const h = new Header(headBuf); - if (!h.cksumValid) { - return cb2(null, position); - } - const entryBlockSize = 512 * Math.ceil(h.size / 512); - if (position + entryBlockSize + 512 > size) { - return cb2(null, position); - } - position += entryBlockSize + 512; - if (position >= size) { - return cb2(null, position); - } - if (opt.mtimeCache) { - opt.mtimeCache.set(h.path, h.mtime); - } - bufPos = 0; - fs8.read(fd, headBuf, 0, 512, position, onread); - }; - fs8.read(fd, headBuf, 0, 512, position, onread); - }; - const promise = new Promise((resolve, reject) => { - p.on("error", reject); - let flag = "r+"; - const onopen = (er, fd) => { - if (er && er.code === "ENOENT" && flag === "r+") { - flag = "w+"; - return fs8.open(opt.file, flag, onopen); - } - if (er) { - return reject(er); - } - fs8.fstat(fd, (er2, st) => { - if (er2) { - return fs8.close(fd, () => reject(er2)); - } - getPos(fd, st.size, (er3, position) => { - if (er3) { - return reject(er3); - } - const stream = new fsm.WriteStream(opt.file, { - fd, - start: position - }); - p.pipe(stream); - stream.on("error", reject); - stream.on("close", resolve); - addFilesAsync(p, files); - }); - }); - }; - fs8.open(opt.file, flag, onopen); - }); - return cb ? promise.then(cb, cb) : promise; - }; - var addFilesSync = (p, files) => { - files.forEach((file) => { - if (file.charAt(0) === "@") { - t({ - file: path10.resolve(p.cwd, file.slice(1)), - sync: true, - noResume: true, - onentry: (entry) => p.add(entry) - }); - } else { - p.add(file); - } - }); - p.end(); + exports2.isexe = isexe; + var sync = (path16, options = {}) => { + const { ignoreErrors = false } = options; + try { + return checkStat((0, fs_1.statSync)(path16), path16, options); + } catch (e) { + const er = e; + if (ignoreErrors || er.code === "EACCES") + return false; + throw er; + } }; - var addFilesAsync = (p, files) => { - while (files.length) { - const file = files.shift(); - if (file.charAt(0) === "@") { - return t({ - file: path10.resolve(p.cwd, file.slice(1)), - noResume: true, - onentry: (entry) => p.add(entry) - }).then((_) => addFilesAsync(p, files)); - } else { - p.add(file); + exports2.sync = sync; + var checkPathExt = (path16, options) => { + const { pathExt = process.env.PATHEXT || "" } = options; + const peSplit = pathExt.split(";"); + if (peSplit.indexOf("") !== -1) { + return true; + } + for (let i = 0; i < peSplit.length; i++) { + const p = peSplit[i].toLowerCase(); + const ext = path16.substring(path16.length - p.length).toLowerCase(); + if (p && ext === p) { + return true; } } - p.end(); + return false; }; + var checkStat = (stat2, path16, options) => stat2.isFile() && checkPathExt(path16, options); } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/update.js -var require_update = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/update.js"(exports2, module2) { +// .yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/options.js +var require_options = __commonJS({ + ".yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/options.js"(exports2) { "use strict"; - var hlo = require_high_level_opt(); - var r = require_replace(); - module2.exports = (opt_, files, cb) => { - const opt = hlo(opt_); - if (!opt.file) { - throw new TypeError("file is required"); - } - if (opt.gzip || opt.brotli || opt.file.endsWith(".br") || opt.file.endsWith(".tbr")) { - throw new TypeError("cannot append to compressed archives"); - } - if (!files || !Array.isArray(files) || !files.length) { - throw new TypeError("no files or directories specified"); - } - files = Array.from(files); - mtimeFilter(opt); - return r(opt, files, cb); - }; - var mtimeFilter = (opt) => { - const filter = opt.filter; - if (!opt.mtimeCache) { - opt.mtimeCache = /* @__PURE__ */ new Map(); - } - opt.filter = filter ? (path10, stat) => filter(path10, stat) && !(opt.mtimeCache.get(path10) > stat.mtime) : (path10, stat) => !(opt.mtimeCache.get(path10) > stat.mtime); - }; + Object.defineProperty(exports2, "__esModule", { value: true }); } }); -// .yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/lib/opts-arg.js -var require_opts_arg = __commonJS({ - ".yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/lib/opts-arg.js"(exports2, module2) { - var { promisify } = require("util"); - var fs8 = require("fs"); - var optsArg = (opts) => { - if (!opts) - opts = { mode: 511, fs: fs8 }; - else if (typeof opts === "object") - opts = { mode: 511, fs: fs8, ...opts }; - else if (typeof opts === "number") - opts = { mode: opts, fs: fs8 }; - else if (typeof opts === "string") - opts = { mode: parseInt(opts, 8), fs: fs8 }; - else - throw new TypeError("invalid options argument"); - opts.mkdir = opts.mkdir || opts.fs.mkdir || fs8.mkdir; - opts.mkdirAsync = promisify(opts.mkdir); - opts.stat = opts.stat || opts.fs.stat || fs8.stat; - opts.statAsync = promisify(opts.stat); - opts.statSync = opts.statSync || opts.fs.statSync || fs8.statSync; - opts.mkdirSync = opts.mkdirSync || opts.fs.mkdirSync || fs8.mkdirSync; - return opts; +// .yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/index.js +var require_cjs = __commonJS({ + ".yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/index.js"(exports2) { + "use strict"; + var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports2 && exports2.__importStar || function(mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) { + for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + } + __setModuleDefault(result, mod); + return result; }; - module2.exports = optsArg; + var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p); + }; + Object.defineProperty(exports2, "__esModule", { value: true }); + exports2.sync = exports2.isexe = exports2.posix = exports2.win32 = void 0; + var posix = __importStar(require_posix()); + exports2.posix = posix; + var win322 = __importStar(require_win32()); + exports2.win32 = win322; + __exportStar(require_options(), exports2); + var platform6 = process.env._ISEXE_TEST_PLATFORM_ || process.platform; + var impl = platform6 === "win32" ? win322 : posix; + exports2.isexe = impl.isexe; + exports2.sync = impl.sync; } }); -// .yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/lib/path-arg.js -var require_path_arg = __commonJS({ - ".yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/lib/path-arg.js"(exports2, module2) { - var platform = process.env.__TESTING_MKDIRP_PLATFORM__ || process.platform; - var { resolve, parse } = require("path"); - var pathArg = (path10) => { - if (/\0/.test(path10)) { - throw Object.assign( - new TypeError("path must be a string without null bytes"), - { - path: path10, - code: "ERR_INVALID_ARG_VALUE" - } - ); - } - path10 = resolve(path10); - if (platform === "win32") { - const badWinChars = /[*|"<>?:]/; - const { root } = parse(path10); - if (badWinChars.test(path10.substr(root.length))) { - throw Object.assign(new Error("Illegal characters in path."), { - path: path10, - code: "EINVAL" - }); +// .yarn/cache/which-npm-4.0.0-dd31cd4928-449fa5c44e.zip/node_modules/which/lib/index.js +var require_lib = __commonJS({ + ".yarn/cache/which-npm-4.0.0-dd31cd4928-449fa5c44e.zip/node_modules/which/lib/index.js"(exports2, module2) { + var { isexe, sync: isexeSync } = require_cjs(); + var { join: join3, delimiter, sep, posix } = require("path"); + var isWindows4 = process.platform === "win32"; + var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1")); + var rRel = new RegExp(`^\\.${rSlash.source}`); + var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" }); + var getPathInfo = (cmd, { + path: optPath = process.env.PATH, + pathExt: optPathExt = process.env.PATHEXT, + delimiter: optDelimiter = delimiter + }) => { + const pathEnv = cmd.match(rSlash) ? [""] : [ + // windows always checks the cwd first + ...isWindows4 ? [process.cwd()] : [], + ...(optPath || /* istanbul ignore next: very unusual */ + "").split(optDelimiter) + ]; + if (isWindows4) { + const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter); + const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]); + if (cmd.includes(".") && pathExt[0] !== "") { + pathExt.unshift(""); } + return { pathEnv, pathExt, pathExtExe }; } - return path10; + return { pathEnv, pathExt: [""] }; }; - module2.exports = pathArg; - } -}); - -// .yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/lib/find-made.js -var require_find_made = __commonJS({ - ".yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/lib/find-made.js"(exports2, module2) { - var { dirname } = require("path"); - var findMade = (opts, parent, path10 = void 0) => { - if (path10 === parent) - return Promise.resolve(); - return opts.statAsync(parent).then( - (st) => st.isDirectory() ? path10 : void 0, - // will fail later - (er) => er.code === "ENOENT" ? findMade(opts, dirname(parent), parent) : void 0 - ); + var getPathPart = (raw2, cmd) => { + const pathPart = /^".*"$/.test(raw2) ? raw2.slice(1, -1) : raw2; + const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : ""; + return prefix + join3(pathPart, cmd); }; - var findMadeSync = (opts, parent, path10 = void 0) => { - if (path10 === parent) - return void 0; - try { - return opts.statSync(parent).isDirectory() ? path10 : void 0; - } catch (er) { - return er.code === "ENOENT" ? findMadeSync(opts, dirname(parent), parent) : void 0; + var which3 = async (cmd, opt = {}) => { + const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt); + const found = []; + for (const envPart of pathEnv) { + const p = getPathPart(envPart, cmd); + for (const ext of pathExt) { + const withExt = p + ext; + const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true }); + if (is) { + if (!opt.all) { + return withExt; + } + found.push(withExt); + } + } } - }; - module2.exports = { findMade, findMadeSync }; - } -}); - -// .yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/lib/mkdirp-manual.js -var require_mkdirp_manual = __commonJS({ - ".yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/lib/mkdirp-manual.js"(exports2, module2) { - var { dirname } = require("path"); - var mkdirpManual = (path10, opts, made) => { - opts.recursive = false; - const parent = dirname(path10); - if (parent === path10) { - return opts.mkdirAsync(path10, opts).catch((er) => { - if (er.code !== "EISDIR") - throw er; - }); + if (opt.all && found.length) { + return found; } - return opts.mkdirAsync(path10, opts).then(() => made || path10, (er) => { - if (er.code === "ENOENT") - return mkdirpManual(parent, opts).then((made2) => mkdirpManual(path10, opts, made2)); - if (er.code !== "EEXIST" && er.code !== "EROFS") - throw er; - return opts.statAsync(path10).then((st) => { - if (st.isDirectory()) - return made; - else - throw er; - }, () => { - throw er; - }); - }); + if (opt.nothrow) { + return null; + } + throw getNotFoundError(cmd); }; - var mkdirpManualSync = (path10, opts, made) => { - const parent = dirname(path10); - opts.recursive = false; - if (parent === path10) { - try { - return opts.mkdirSync(path10, opts); - } catch (er) { - if (er.code !== "EISDIR") - throw er; - else - return; + var whichSync = (cmd, opt = {}) => { + const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt); + const found = []; + for (const pathEnvPart of pathEnv) { + const p = getPathPart(pathEnvPart, cmd); + for (const ext of pathExt) { + const withExt = p + ext; + const is = isexeSync(withExt, { pathExt: pathExtExe, ignoreErrors: true }); + if (is) { + if (!opt.all) { + return withExt; + } + found.push(withExt); + } } } - try { - opts.mkdirSync(path10, opts); - return made || path10; - } catch (er) { - if (er.code === "ENOENT") - return mkdirpManualSync(path10, opts, mkdirpManualSync(parent, opts, made)); - if (er.code !== "EEXIST" && er.code !== "EROFS") - throw er; - try { - if (!opts.statSync(path10).isDirectory()) - throw er; - } catch (_) { - throw er; - } + if (opt.all && found.length) { + return found; } - }; - module2.exports = { mkdirpManual, mkdirpManualSync }; - } -}); - -// .yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/lib/mkdirp-native.js -var require_mkdirp_native = __commonJS({ - ".yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/lib/mkdirp-native.js"(exports2, module2) { - var { dirname } = require("path"); - var { findMade, findMadeSync } = require_find_made(); - var { mkdirpManual, mkdirpManualSync } = require_mkdirp_manual(); - var mkdirpNative = (path10, opts) => { - opts.recursive = true; - const parent = dirname(path10); - if (parent === path10) - return opts.mkdirAsync(path10, opts); - return findMade(opts, path10).then((made) => opts.mkdirAsync(path10, opts).then(() => made).catch((er) => { - if (er.code === "ENOENT") - return mkdirpManual(path10, opts); - else - throw er; - })); - }; - var mkdirpNativeSync = (path10, opts) => { - opts.recursive = true; - const parent = dirname(path10); - if (parent === path10) - return opts.mkdirSync(path10, opts); - const made = findMadeSync(opts, path10); - try { - opts.mkdirSync(path10, opts); - return made; - } catch (er) { - if (er.code === "ENOENT") - return mkdirpManualSync(path10, opts); - else - throw er; + if (opt.nothrow) { + return null; } + throw getNotFoundError(cmd); }; - module2.exports = { mkdirpNative, mkdirpNativeSync }; + module2.exports = which3; + which3.sync = whichSync; } }); -// .yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/lib/use-native.js -var require_use_native = __commonJS({ - ".yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/lib/use-native.js"(exports2, module2) { - var fs8 = require("fs"); - var version2 = process.env.__TESTING_MKDIRP_NODE_VERSION__ || process.version; - var versArr = version2.replace(/^v/, "").split("."); - var hasNative = +versArr[0] > 10 || +versArr[0] === 10 && +versArr[1] >= 12; - var useNative = !hasNative ? () => false : (opts) => opts.mkdir === fs8.mkdir; - var useNativeSync = !hasNative ? () => false : (opts) => opts.mkdirSync === fs8.mkdirSync; - module2.exports = { useNative, useNativeSync }; +// .yarn/cache/is-windows-npm-1.0.2-898cd6f3d7-b32f418ab3.zip/node_modules/is-windows/index.js +var require_is_windows = __commonJS({ + ".yarn/cache/is-windows-npm-1.0.2-898cd6f3d7-b32f418ab3.zip/node_modules/is-windows/index.js"(exports2, module2) { + (function(factory) { + if (exports2 && typeof exports2 === "object" && typeof module2 !== "undefined") { + module2.exports = factory(); + } else if (typeof define === "function" && define.amd) { + define([], factory); + } else if (typeof window !== "undefined") { + window.isWindows = factory(); + } else if (typeof global !== "undefined") { + global.isWindows = factory(); + } else if (typeof self !== "undefined") { + self.isWindows = factory(); + } else { + this.isWindows = factory(); + } + })(function() { + "use strict"; + return function isWindows4() { + return process && (process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE)); + }; + }); } }); -// .yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/index.js -var require_mkdirp = __commonJS({ - ".yarn/cache/mkdirp-npm-1.0.4-37f6ef56b9-46ea0f3ffa.zip/node_modules/mkdirp/index.js"(exports2, module2) { - var optsArg = require_opts_arg(); - var pathArg = require_path_arg(); - var { mkdirpNative, mkdirpNativeSync } = require_mkdirp_native(); - var { mkdirpManual, mkdirpManualSync } = require_mkdirp_manual(); - var { useNative, useNativeSync } = require_use_native(); - var mkdirp = (path10, opts) => { - path10 = pathArg(path10); - opts = optsArg(opts); - return useNative(opts) ? mkdirpNative(path10, opts) : mkdirpManual(path10, opts); - }; - var mkdirpSync = (path10, opts) => { - path10 = pathArg(path10); - opts = optsArg(opts); - return useNativeSync(opts) ? mkdirpNativeSync(path10, opts) : mkdirpManualSync(path10, opts); - }; - mkdirp.sync = mkdirpSync; - mkdirp.native = (path10, opts) => mkdirpNative(pathArg(path10), optsArg(opts)); - mkdirp.manual = (path10, opts) => mkdirpManual(pathArg(path10), optsArg(opts)); - mkdirp.nativeSync = (path10, opts) => mkdirpNativeSync(pathArg(path10), optsArg(opts)); - mkdirp.manualSync = (path10, opts) => mkdirpManualSync(pathArg(path10), optsArg(opts)); - module2.exports = mkdirp; +// .yarn/cache/cmd-extension-npm-1.0.2-11aa204c4b-acdb425d51.zip/node_modules/cmd-extension/index.js +var require_cmd_extension = __commonJS({ + ".yarn/cache/cmd-extension-npm-1.0.2-11aa204c4b-acdb425d51.zip/node_modules/cmd-extension/index.js"(exports2, module2) { + "use strict"; + var path16 = require("path"); + var cmdExtension; + if (process.env.PATHEXT) { + cmdExtension = process.env.PATHEXT.split(path16.delimiter).find((ext) => ext.toUpperCase() === ".CMD"); + } + module2.exports = cmdExtension || ".cmd"; } }); -// .yarn/cache/chownr-npm-2.0.0-638f1c9c61-594754e130.zip/node_modules/chownr/chownr.js -var require_chownr = __commonJS({ - ".yarn/cache/chownr-npm-2.0.0-638f1c9c61-594754e130.zip/node_modules/chownr/chownr.js"(exports2, module2) { - "use strict"; - var fs8 = require("fs"); - var path10 = require("path"); - var LCHOWN = fs8.lchown ? "lchown" : "chown"; - var LCHOWNSYNC = fs8.lchownSync ? "lchownSync" : "chownSync"; - var needEISDIRHandled = fs8.lchown && !process.version.match(/v1[1-9]+\./) && !process.version.match(/v10\.[6-9]/); - var lchownSync = (path11, uid, gid) => { - try { - return fs8[LCHOWNSYNC](path11, uid, gid); - } catch (er) { - if (er.code !== "ENOENT") - throw er; - } +// .yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/polyfills.js +var require_polyfills = __commonJS({ + ".yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/polyfills.js"(exports2, module2) { + var constants2 = require("constants"); + var origCwd = process.cwd; + var cwd = null; + var platform6 = process.env.GRACEFUL_FS_PLATFORM || process.platform; + process.cwd = function() { + if (!cwd) + cwd = origCwd.call(process); + return cwd; }; - var chownSync = (path11, uid, gid) => { - try { - return fs8.chownSync(path11, uid, gid); - } catch (er) { - if (er.code !== "ENOENT") - throw er; + try { + process.cwd(); + } catch (er) { + } + if (typeof process.chdir === "function") { + chdir = process.chdir; + process.chdir = function(d) { + cwd = null; + chdir.call(process, d); + }; + if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir); + } + var chdir; + module2.exports = patch; + function patch(fs17) { + if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) { + patchLchmod(fs17); + } + if (!fs17.lutimes) { + patchLutimes(fs17); + } + fs17.chown = chownFix(fs17.chown); + fs17.fchown = chownFix(fs17.fchown); + fs17.lchown = chownFix(fs17.lchown); + fs17.chmod = chmodFix(fs17.chmod); + fs17.fchmod = chmodFix(fs17.fchmod); + fs17.lchmod = chmodFix(fs17.lchmod); + fs17.chownSync = chownFixSync(fs17.chownSync); + fs17.fchownSync = chownFixSync(fs17.fchownSync); + fs17.lchownSync = chownFixSync(fs17.lchownSync); + fs17.chmodSync = chmodFixSync(fs17.chmodSync); + fs17.fchmodSync = chmodFixSync(fs17.fchmodSync); + fs17.lchmodSync = chmodFixSync(fs17.lchmodSync); + fs17.stat = statFix(fs17.stat); + fs17.fstat = statFix(fs17.fstat); + fs17.lstat = statFix(fs17.lstat); + fs17.statSync = statFixSync(fs17.statSync); + fs17.fstatSync = statFixSync(fs17.fstatSync); + fs17.lstatSync = statFixSync(fs17.lstatSync); + if (fs17.chmod && !fs17.lchmod) { + fs17.lchmod = function(path16, mode, cb) { + if (cb) process.nextTick(cb); + }; + fs17.lchmodSync = function() { + }; } - }; - var handleEISDIR = needEISDIRHandled ? (path11, uid, gid, cb) => (er) => { - if (!er || er.code !== "EISDIR") - cb(er); - else - fs8.chown(path11, uid, gid, cb); - } : (_, __, ___, cb) => cb; - var handleEISDirSync = needEISDIRHandled ? (path11, uid, gid) => { - try { - return lchownSync(path11, uid, gid); - } catch (er) { - if (er.code !== "EISDIR") - throw er; - chownSync(path11, uid, gid); - } - } : (path11, uid, gid) => lchownSync(path11, uid, gid); - var nodeVersion = process.version; - var readdir = (path11, options, cb) => fs8.readdir(path11, options, cb); - var readdirSync = (path11, options) => fs8.readdirSync(path11, options); - if (/^v4\./.test(nodeVersion)) - readdir = (path11, options, cb) => fs8.readdir(path11, cb); - var chown = (cpath, uid, gid, cb) => { - fs8[LCHOWN](cpath, uid, gid, handleEISDIR(cpath, uid, gid, (er) => { - cb(er && er.code !== "ENOENT" ? er : null); - })); - }; - var chownrKid = (p, child, uid, gid, cb) => { - if (typeof child === "string") - return fs8.lstat(path10.resolve(p, child), (er, stats) => { - if (er) - return cb(er.code !== "ENOENT" ? er : null); - stats.name = child; - chownrKid(p, stats, uid, gid, cb); - }); - if (child.isDirectory()) { - chownr(path10.resolve(p, child.name), uid, gid, (er) => { - if (er) - return cb(er); - const cpath = path10.resolve(p, child.name); - chown(cpath, uid, gid, cb); - }); - } else { - const cpath = path10.resolve(p, child.name); - chown(cpath, uid, gid, cb); + if (fs17.chown && !fs17.lchown) { + fs17.lchown = function(path16, uid, gid, cb) { + if (cb) process.nextTick(cb); + }; + fs17.lchownSync = function() { + }; } - }; - var chownr = (p, uid, gid, cb) => { - readdir(p, { withFileTypes: true }, (er, children) => { - if (er) { - if (er.code === "ENOENT") - return cb(); - else if (er.code !== "ENOTDIR" && er.code !== "ENOTSUP") - return cb(er); + if (platform6 === "win32") { + fs17.rename = typeof fs17.rename !== "function" ? fs17.rename : function(fs$rename) { + function rename(from, to, cb) { + var start = Date.now(); + var backoff = 0; + fs$rename(from, to, function CB(er) { + if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) { + setTimeout(function() { + fs17.stat(to, function(stater, st) { + if (stater && stater.code === "ENOENT") + fs$rename(from, to, CB); + else + cb(er); + }); + }, backoff); + if (backoff < 100) + backoff += 10; + return; + } + if (cb) cb(er); + }); + } + if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename); + return rename; + }(fs17.rename); + } + fs17.read = typeof fs17.read !== "function" ? fs17.read : function(fs$read) { + function read(fd, buffer, offset, length, position, callback_) { + var callback; + if (callback_ && typeof callback_ === "function") { + var eagCounter = 0; + callback = function(er, _, __) { + if (er && er.code === "EAGAIN" && eagCounter < 10) { + eagCounter++; + return fs$read.call(fs17, fd, buffer, offset, length, position, callback); + } + callback_.apply(this, arguments); + }; + } + return fs$read.call(fs17, fd, buffer, offset, length, position, callback); } - if (er || !children.length) - return chown(p, uid, gid, cb); - let len = children.length; - let errState = null; - const then = (er2) => { - if (errState) - return; - if (er2) - return cb(errState = er2); - if (--len === 0) - return chown(p, uid, gid, cb); + if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read); + return read; + }(fs17.read); + fs17.readSync = typeof fs17.readSync !== "function" ? fs17.readSync : /* @__PURE__ */ function(fs$readSync) { + return function(fd, buffer, offset, length, position) { + var eagCounter = 0; + while (true) { + try { + return fs$readSync.call(fs17, fd, buffer, offset, length, position); + } catch (er) { + if (er.code === "EAGAIN" && eagCounter < 10) { + eagCounter++; + continue; + } + throw er; + } + } + }; + }(fs17.readSync); + function patchLchmod(fs18) { + fs18.lchmod = function(path16, mode, callback) { + fs18.open( + path16, + constants2.O_WRONLY | constants2.O_SYMLINK, + mode, + function(err, fd) { + if (err) { + if (callback) callback(err); + return; + } + fs18.fchmod(fd, mode, function(err2) { + fs18.close(fd, function(err22) { + if (callback) callback(err2 || err22); + }); + }); + } + ); + }; + fs18.lchmodSync = function(path16, mode) { + var fd = fs18.openSync(path16, constants2.O_WRONLY | constants2.O_SYMLINK, mode); + var threw = true; + var ret; + try { + ret = fs18.fchmodSync(fd, mode); + threw = false; + } finally { + if (threw) { + try { + fs18.closeSync(fd); + } catch (er) { + } + } else { + fs18.closeSync(fd); + } + } + return ret; }; - children.forEach((child) => chownrKid(p, child, uid, gid, then)); - }); - }; - var chownrKidSync = (p, child, uid, gid) => { - if (typeof child === "string") { - try { - const stats = fs8.lstatSync(path10.resolve(p, child)); - stats.name = child; - child = stats; - } catch (er) { - if (er.code === "ENOENT") - return; - else - throw er; - } - } - if (child.isDirectory()) - chownrSync(path10.resolve(p, child.name), uid, gid); - handleEISDirSync(path10.resolve(p, child.name), uid, gid); - }; - var chownrSync = (p, uid, gid) => { - let children; - try { - children = readdirSync(p, { withFileTypes: true }); - } catch (er) { - if (er.code === "ENOENT") - return; - else if (er.code === "ENOTDIR" || er.code === "ENOTSUP") - return handleEISDirSync(p, uid, gid); - else - throw er; - } - if (children && children.length) - children.forEach((child) => chownrKidSync(p, child, uid, gid)); - return handleEISDirSync(p, uid, gid); - }; - module2.exports = chownr; - chownr.sync = chownrSync; - } -}); - -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/mkdir.js -var require_mkdir = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/mkdir.js"(exports2, module2) { - "use strict"; - var mkdirp = require_mkdirp(); - var fs8 = require("fs"); - var path10 = require("path"); - var chownr = require_chownr(); - var normPath = require_normalize_windows_path(); - var SymlinkError = class extends Error { - constructor(symlink, path11) { - super("Cannot extract through symbolic link"); - this.path = path11; - this.symlink = symlink; - } - get name() { - return "SylinkError"; } - }; - var CwdError = class extends Error { - constructor(path11, code) { - super(code + ": Cannot cd into '" + path11 + "'"); - this.path = path11; - this.code = code; + function patchLutimes(fs18) { + if (constants2.hasOwnProperty("O_SYMLINK") && fs18.futimes) { + fs18.lutimes = function(path16, at, mt, cb) { + fs18.open(path16, constants2.O_SYMLINK, function(er, fd) { + if (er) { + if (cb) cb(er); + return; + } + fs18.futimes(fd, at, mt, function(er2) { + fs18.close(fd, function(er22) { + if (cb) cb(er2 || er22); + }); + }); + }); + }; + fs18.lutimesSync = function(path16, at, mt) { + var fd = fs18.openSync(path16, constants2.O_SYMLINK); + var ret; + var threw = true; + try { + ret = fs18.futimesSync(fd, at, mt); + threw = false; + } finally { + if (threw) { + try { + fs18.closeSync(fd); + } catch (er) { + } + } else { + fs18.closeSync(fd); + } + } + return ret; + }; + } else if (fs18.futimes) { + fs18.lutimes = function(_a, _b, _c, cb) { + if (cb) process.nextTick(cb); + }; + fs18.lutimesSync = function() { + }; + } } - get name() { - return "CwdError"; + function chmodFix(orig) { + if (!orig) return orig; + return function(target, mode, cb) { + return orig.call(fs17, target, mode, function(er) { + if (chownErOk(er)) er = null; + if (cb) cb.apply(this, arguments); + }); + }; } - }; - var cGet = (cache, key) => cache.get(normPath(key)); - var cSet = (cache, key, val) => cache.set(normPath(key), val); - var checkCwd = (dir, cb) => { - fs8.stat(dir, (er, st) => { - if (er || !st.isDirectory()) { - er = new CwdError(dir, er && er.code || "ENOTDIR"); - } - cb(er); - }); - }; - module2.exports = (dir, opt, cb) => { - dir = normPath(dir); - const umask = opt.umask; - const mode = opt.mode | 448; - const needChmod = (mode & umask) !== 0; - const uid = opt.uid; - const gid = opt.gid; - const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid); - const preserve = opt.preserve; - const unlink = opt.unlink; - const cache = opt.cache; - const cwd = normPath(opt.cwd); - const done = (er, created) => { - if (er) { - cb(er); - } else { - cSet(cache, dir, true); - if (created && doChown) { - chownr(created, uid, gid, (er2) => done(er2)); - } else if (needChmod) { - fs8.chmod(dir, mode, cb); - } else { - cb(); + function chmodFixSync(orig) { + if (!orig) return orig; + return function(target, mode) { + try { + return orig.call(fs17, target, mode); + } catch (er) { + if (!chownErOk(er)) throw er; } - } - }; - if (cache && cGet(cache, dir) === true) { - return done(); - } - if (dir === cwd) { - return checkCwd(dir, done); + }; } - if (preserve) { - return mkdirp(dir, { mode }).then((made) => done(null, made), done); + function chownFix(orig) { + if (!orig) return orig; + return function(target, uid, gid, cb) { + return orig.call(fs17, target, uid, gid, function(er) { + if (chownErOk(er)) er = null; + if (cb) cb.apply(this, arguments); + }); + }; } - const sub = normPath(path10.relative(cwd, dir)); - const parts = sub.split("/"); - mkdir_(cwd, parts, mode, cache, unlink, cwd, null, done); - }; - var mkdir_ = (base, parts, mode, cache, unlink, cwd, created, cb) => { - if (!parts.length) { - return cb(null, created); + function chownFixSync(orig) { + if (!orig) return orig; + return function(target, uid, gid) { + try { + return orig.call(fs17, target, uid, gid); + } catch (er) { + if (!chownErOk(er)) throw er; + } + }; } - const p = parts.shift(); - const part = normPath(path10.resolve(base + "/" + p)); - if (cGet(cache, part)) { - return mkdir_(part, parts, mode, cache, unlink, cwd, created, cb); + function statFix(orig) { + if (!orig) return orig; + return function(target, options, cb) { + if (typeof options === "function") { + cb = options; + options = null; + } + function callback(er, stats) { + if (stats) { + if (stats.uid < 0) stats.uid += 4294967296; + if (stats.gid < 0) stats.gid += 4294967296; + } + if (cb) cb.apply(this, arguments); + } + return options ? orig.call(fs17, target, options, callback) : orig.call(fs17, target, callback); + }; } - fs8.mkdir(part, mode, onmkdir(part, parts, mode, cache, unlink, cwd, created, cb)); - }; - var onmkdir = (part, parts, mode, cache, unlink, cwd, created, cb) => (er) => { - if (er) { - fs8.lstat(part, (statEr, st) => { - if (statEr) { - statEr.path = statEr.path && normPath(statEr.path); - cb(statEr); - } else if (st.isDirectory()) { - mkdir_(part, parts, mode, cache, unlink, cwd, created, cb); - } else if (unlink) { - fs8.unlink(part, (er2) => { - if (er2) { - return cb(er2); - } - fs8.mkdir(part, mode, onmkdir(part, parts, mode, cache, unlink, cwd, created, cb)); - }); - } else if (st.isSymbolicLink()) { - return cb(new SymlinkError(part, part + "/" + parts.join("/"))); - } else { - cb(er); + function statFixSync(orig) { + if (!orig) return orig; + return function(target, options) { + var stats = options ? orig.call(fs17, target, options) : orig.call(fs17, target); + if (stats) { + if (stats.uid < 0) stats.uid += 4294967296; + if (stats.gid < 0) stats.gid += 4294967296; } - }); - } else { - created = created || part; - mkdir_(part, parts, mode, cache, unlink, cwd, created, cb); + return stats; + }; } - }; - var checkCwdSync = (dir) => { - let ok = false; - let code = "ENOTDIR"; - try { - ok = fs8.statSync(dir).isDirectory(); - } catch (er) { - code = er.code; - } finally { - if (!ok) { - throw new CwdError(dir, code); - } - } - }; - module2.exports.sync = (dir, opt) => { - dir = normPath(dir); - const umask = opt.umask; - const mode = opt.mode | 448; - const needChmod = (mode & umask) !== 0; - const uid = opt.uid; - const gid = opt.gid; - const doChown = typeof uid === "number" && typeof gid === "number" && (uid !== opt.processUid || gid !== opt.processGid); - const preserve = opt.preserve; - const unlink = opt.unlink; - const cache = opt.cache; - const cwd = normPath(opt.cwd); - const done = (created2) => { - cSet(cache, dir, true); - if (created2 && doChown) { - chownr.sync(created2, uid, gid); - } - if (needChmod) { - fs8.chmodSync(dir, mode); - } - }; - if (cache && cGet(cache, dir) === true) { - return done(); - } - if (dir === cwd) { - checkCwdSync(cwd); - return done(); - } - if (preserve) { - return done(mkdirp.sync(dir, mode)); - } - const sub = normPath(path10.relative(cwd, dir)); - const parts = sub.split("/"); - let created = null; - for (let p = parts.shift(), part = cwd; p && (part += "/" + p); p = parts.shift()) { - part = normPath(path10.resolve(part)); - if (cGet(cache, part)) { - continue; - } - try { - fs8.mkdirSync(part, mode); - created = created || part; - cSet(cache, part, true); - } catch (er) { - const st = fs8.lstatSync(part); - if (st.isDirectory()) { - cSet(cache, part, true); - continue; - } else if (unlink) { - fs8.unlinkSync(part); - fs8.mkdirSync(part, mode); - created = created || part; - cSet(cache, part, true); - continue; - } else if (st.isSymbolicLink()) { - return new SymlinkError(part, part + "/" + parts.join("/")); - } + function chownErOk(er) { + if (!er) + return true; + if (er.code === "ENOSYS") + return true; + var nonroot = !process.getuid || process.getuid() !== 0; + if (nonroot) { + if (er.code === "EINVAL" || er.code === "EPERM") + return true; } + return false; } - return done(created); - }; - } -}); - -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/normalize-unicode.js -var require_normalize_unicode = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/normalize-unicode.js"(exports2, module2) { - var normalizeCache = /* @__PURE__ */ Object.create(null); - var { hasOwnProperty } = Object.prototype; - module2.exports = (s) => { - if (!hasOwnProperty.call(normalizeCache, s)) { - normalizeCache[s] = s.normalize("NFD"); - } - return normalizeCache[s]; - }; + } } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/path-reservations.js -var require_path_reservations = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/path-reservations.js"(exports2, module2) { - var assert3 = require("assert"); - var normalize = require_normalize_unicode(); - var stripSlashes = require_strip_trailing_slashes(); - var { join: join2 } = require("path"); - var platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform; - var isWindows = platform === "win32"; - module2.exports = () => { - const queues = /* @__PURE__ */ new Map(); - const reservations = /* @__PURE__ */ new Map(); - const getDirs = (path10) => { - const dirs = path10.split("/").slice(0, -1).reduce((set, path11) => { - if (set.length) { - path11 = join2(set[set.length - 1], path11); - } - set.push(path11 || "/"); - return set; - }, []); - return dirs; +// .yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/legacy-streams.js +var require_legacy_streams = __commonJS({ + ".yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/legacy-streams.js"(exports2, module2) { + var Stream2 = require("stream").Stream; + module2.exports = legacy; + function legacy(fs17) { + return { + ReadStream: ReadStream2, + WriteStream: WriteStream2 }; - const running = /* @__PURE__ */ new Set(); - const getQueues = (fn2) => { - const res = reservations.get(fn2); - if (!res) { - throw new Error("function does not have any path reservations"); + function ReadStream2(path16, options) { + if (!(this instanceof ReadStream2)) return new ReadStream2(path16, options); + Stream2.call(this); + var self2 = this; + this.path = path16; + this.fd = null; + this.readable = true; + this.paused = false; + this.flags = "r"; + this.mode = 438; + this.bufferSize = 64 * 1024; + options = options || {}; + var keys = Object.keys(options); + for (var index = 0, length = keys.length; index < length; index++) { + var key = keys[index]; + this[key] = options[key]; } - return { - paths: res.paths.map((path10) => queues.get(path10)), - dirs: [...res.dirs].map((path10) => queues.get(path10)) - }; - }; - const check = (fn2) => { - const { paths, dirs } = getQueues(fn2); - return paths.every((q) => q[0] === fn2) && dirs.every((q) => q[0] instanceof Set && q[0].has(fn2)); - }; - const run2 = (fn2) => { - if (running.has(fn2) || !check(fn2)) { - return false; + if (this.encoding) this.setEncoding(this.encoding); + if (this.start !== void 0) { + if ("number" !== typeof this.start) { + throw TypeError("start must be a Number"); + } + if (this.end === void 0) { + this.end = Infinity; + } else if ("number" !== typeof this.end) { + throw TypeError("end must be a Number"); + } + if (this.start > this.end) { + throw new Error("start must be <= end"); + } + this.pos = this.start; } - running.add(fn2); - fn2(() => clear(fn2)); - return true; - }; - const clear = (fn2) => { - if (!running.has(fn2)) { - return false; + if (this.fd !== null) { + process.nextTick(function() { + self2._read(); + }); + return; } - const { paths, dirs } = reservations.get(fn2); - const next = /* @__PURE__ */ new Set(); - paths.forEach((path10) => { - const q = queues.get(path10); - assert3.equal(q[0], fn2); - if (q.length === 1) { - queues.delete(path10); - } else { - q.shift(); - if (typeof q[0] === "function") { - next.add(q[0]); - } else { - q[0].forEach((fn3) => next.add(fn3)); - } - } - }); - dirs.forEach((dir) => { - const q = queues.get(dir); - assert3(q[0] instanceof Set); - if (q[0].size === 1 && q.length === 1) { - queues.delete(dir); - } else if (q[0].size === 1) { - q.shift(); - next.add(q[0]); - } else { - q[0].delete(fn2); + fs17.open(this.path, this.flags, this.mode, function(err, fd) { + if (err) { + self2.emit("error", err); + self2.readable = false; + return; } + self2.fd = fd; + self2.emit("open", fd); + self2._read(); }); - running.delete(fn2); - next.forEach((fn3) => run2(fn3)); - return true; - }; - const reserve = (paths, fn2) => { - paths = isWindows ? ["win32 parallelization disabled"] : paths.map((p) => { - return stripSlashes(join2(normalize(p))).toLowerCase(); - }); - const dirs = new Set( - paths.map((path10) => getDirs(path10)).reduce((a, b) => a.concat(b)) - ); - reservations.set(fn2, { dirs, paths }); - paths.forEach((path10) => { - const q = queues.get(path10); - if (!q) { - queues.set(path10, [fn2]); - } else { - q.push(fn2); + } + function WriteStream2(path16, options) { + if (!(this instanceof WriteStream2)) return new WriteStream2(path16, options); + Stream2.call(this); + this.path = path16; + this.fd = null; + this.writable = true; + this.flags = "w"; + this.encoding = "binary"; + this.mode = 438; + this.bytesWritten = 0; + options = options || {}; + var keys = Object.keys(options); + for (var index = 0, length = keys.length; index < length; index++) { + var key = keys[index]; + this[key] = options[key]; + } + if (this.start !== void 0) { + if ("number" !== typeof this.start) { + throw TypeError("start must be a Number"); } - }); - dirs.forEach((dir) => { - const q = queues.get(dir); - if (!q) { - queues.set(dir, [/* @__PURE__ */ new Set([fn2])]); - } else if (q[q.length - 1] instanceof Set) { - q[q.length - 1].add(fn2); - } else { - q.push(/* @__PURE__ */ new Set([fn2])); + if (this.start < 0) { + throw new Error("start must be >= zero"); } - }); - return run2(fn2); - }; - return { check, reserve }; - }; + this.pos = this.start; + } + this.busy = false; + this._queue = []; + if (this.fd === null) { + this._open = fs17.open; + this._queue.push([this._open, this.path, this.flags, this.mode, void 0]); + this.flush(); + } + } + } } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/get-write-flag.js -var require_get_write_flag = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/get-write-flag.js"(exports2, module2) { - var platform = process.env.__FAKE_PLATFORM__ || process.platform; - var isWindows = platform === "win32"; - var fs8 = global.__FAKE_TESTING_FS__ || require("fs"); - var { O_CREAT, O_TRUNC, O_WRONLY, UV_FS_O_FILEMAP = 0 } = fs8.constants; - var fMapEnabled = isWindows && !!UV_FS_O_FILEMAP; - var fMapLimit = 512 * 1024; - var fMapFlag = UV_FS_O_FILEMAP | O_TRUNC | O_CREAT | O_WRONLY; - module2.exports = !fMapEnabled ? () => "w" : (size) => size < fMapLimit ? fMapFlag : "w"; +// .yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/clone.js +var require_clone = __commonJS({ + ".yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/clone.js"(exports2, module2) { + "use strict"; + module2.exports = clone; + var getPrototypeOf = Object.getPrototypeOf || function(obj) { + return obj.__proto__; + }; + function clone(obj) { + if (obj === null || typeof obj !== "object") + return obj; + if (obj instanceof Object) + var copy = { __proto__: getPrototypeOf(obj) }; + else + var copy = /* @__PURE__ */ Object.create(null); + Object.getOwnPropertyNames(obj).forEach(function(key) { + Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key)); + }); + return copy; + } } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/unpack.js -var require_unpack = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/unpack.js"(exports2, module2) { - "use strict"; - var assert3 = require("assert"); - var Parser = require_parse2(); - var fs8 = require("fs"); - var fsm = require_fs_minipass(); - var path10 = require("path"); - var mkdir4 = require_mkdir(); - var wc = require_winchars(); - var pathReservations = require_path_reservations(); - var stripAbsolutePath = require_strip_absolute_path(); - var normPath = require_normalize_windows_path(); - var stripSlash = require_strip_trailing_slashes(); - var normalize = require_normalize_unicode(); - var ONENTRY = Symbol("onEntry"); - var CHECKFS = Symbol("checkFs"); - var CHECKFS2 = Symbol("checkFs2"); - var PRUNECACHE = Symbol("pruneCache"); - var ISREUSABLE = Symbol("isReusable"); - var MAKEFS = Symbol("makeFs"); - var FILE = Symbol("file"); - var DIRECTORY = Symbol("directory"); - var LINK = Symbol("link"); - var SYMLINK = Symbol("symlink"); - var HARDLINK = Symbol("hardlink"); - var UNSUPPORTED = Symbol("unsupported"); - var CHECKPATH = Symbol("checkPath"); - var MKDIR = Symbol("mkdir"); - var ONERROR = Symbol("onError"); - var PENDING = Symbol("pending"); - var PEND = Symbol("pend"); - var UNPEND = Symbol("unpend"); - var ENDED = Symbol("ended"); - var MAYBECLOSE = Symbol("maybeClose"); - var SKIP = Symbol("skip"); - var DOCHOWN = Symbol("doChown"); - var UID = Symbol("uid"); - var GID = Symbol("gid"); - var CHECKED_CWD = Symbol("checkedCwd"); - var crypto = require("crypto"); - var getFlag = require_get_write_flag(); - var platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform; - var isWindows = platform === "win32"; - var DEFAULT_MAX_DEPTH = 1024; - var unlinkFile = (path11, cb) => { - if (!isWindows) { - return fs8.unlink(path11, cb); - } - const name = path11 + ".DELETE." + crypto.randomBytes(16).toString("hex"); - fs8.rename(path11, name, (er) => { - if (er) { - return cb(er); +// .yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/graceful-fs.js +var require_graceful_fs = __commonJS({ + ".yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/graceful-fs.js"(exports2, module2) { + var fs17 = require("fs"); + var polyfills = require_polyfills(); + var legacy = require_legacy_streams(); + var clone = require_clone(); + var util = require("util"); + var gracefulQueue; + var previousSymbol; + if (typeof Symbol === "function" && typeof Symbol.for === "function") { + gracefulQueue = Symbol.for("graceful-fs.queue"); + previousSymbol = Symbol.for("graceful-fs.previous"); + } else { + gracefulQueue = "___graceful-fs.queue"; + previousSymbol = "___graceful-fs.previous"; + } + function noop2() { + } + function publishQueue(context, queue2) { + Object.defineProperty(context, gracefulQueue, { + get: function() { + return queue2; } - fs8.unlink(name, cb); }); - }; - var unlinkFileSync = (path11) => { - if (!isWindows) { - return fs8.unlinkSync(path11); - } - const name = path11 + ".DELETE." + crypto.randomBytes(16).toString("hex"); - fs8.renameSync(path11, name); - fs8.unlinkSync(name); - }; - var uint32 = (a, b, c) => a === a >>> 0 ? a : b === b >>> 0 ? b : c; - var cacheKeyNormalize = (path11) => stripSlash(normPath(normalize(path11))).toLowerCase(); - var pruneCache = (cache, abs) => { - abs = cacheKeyNormalize(abs); - for (const path11 of cache.keys()) { - const pnorm = cacheKeyNormalize(path11); - if (pnorm === abs || pnorm.indexOf(abs + "/") === 0) { - cache.delete(path11); + } + var debug2 = noop2; + if (util.debuglog) + debug2 = util.debuglog("gfs4"); + else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) + debug2 = function() { + var m = util.format.apply(util, arguments); + m = "GFS4: " + m.split(/\n/).join("\nGFS4: "); + console.error(m); + }; + if (!fs17[gracefulQueue]) { + queue = global[gracefulQueue] || []; + publishQueue(fs17, queue); + fs17.close = function(fs$close) { + function close(fd, cb) { + return fs$close.call(fs17, fd, function(err) { + if (!err) { + resetQueue(); + } + if (typeof cb === "function") + cb.apply(this, arguments); + }); } - } - }; - var dropCache = (cache) => { - for (const key of cache.keys()) { - cache.delete(key); - } - }; - var Unpack = class extends Parser { - constructor(opt) { - if (!opt) { - opt = {}; + Object.defineProperty(close, previousSymbol, { + value: fs$close + }); + return close; + }(fs17.close); + fs17.closeSync = function(fs$closeSync) { + function closeSync(fd) { + fs$closeSync.apply(fs17, arguments); + resetQueue(); } - opt.ondone = (_) => { - this[ENDED] = true; - this[MAYBECLOSE](); - }; - super(opt); - this[CHECKED_CWD] = false; - this.reservations = pathReservations(); - this.transform = typeof opt.transform === "function" ? opt.transform : null; - this.writable = true; - this.readable = false; - this[PENDING] = 0; - this[ENDED] = false; - this.dirCache = opt.dirCache || /* @__PURE__ */ new Map(); - if (typeof opt.uid === "number" || typeof opt.gid === "number") { - if (typeof opt.uid !== "number" || typeof opt.gid !== "number") { - throw new TypeError("cannot set owner without number uid and gid"); - } - if (opt.preserveOwner) { - throw new TypeError( - "cannot preserve owner in archive and also set owner explicitly" - ); - } - this.uid = opt.uid; - this.gid = opt.gid; - this.setOwner = true; - } else { - this.uid = null; - this.gid = null; - this.setOwner = false; - } - if (opt.preserveOwner === void 0 && typeof opt.uid !== "number") { - this.preserveOwner = process.getuid && process.getuid() === 0; - } else { - this.preserveOwner = !!opt.preserveOwner; - } - this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : null; - this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : null; - this.maxDepth = typeof opt.maxDepth === "number" ? opt.maxDepth : DEFAULT_MAX_DEPTH; - this.forceChown = opt.forceChown === true; - this.win32 = !!opt.win32 || isWindows; - this.newer = !!opt.newer; - this.keep = !!opt.keep; - this.noMtime = !!opt.noMtime; - this.preservePaths = !!opt.preservePaths; - this.unlink = !!opt.unlink; - this.cwd = normPath(path10.resolve(opt.cwd || process.cwd())); - this.strip = +opt.strip || 0; - this.processUmask = opt.noChmod ? 0 : process.umask(); - this.umask = typeof opt.umask === "number" ? opt.umask : this.processUmask; - this.dmode = opt.dmode || 511 & ~this.umask; - this.fmode = opt.fmode || 438 & ~this.umask; - this.on("entry", (entry) => this[ONENTRY](entry)); - } - // a bad or damaged archive is a warning for Parser, but an error - // when extracting. Mark those errors as unrecoverable, because - // the Unpack contract cannot be met. - warn(code, msg, data = {}) { - if (code === "TAR_BAD_ARCHIVE" || code === "TAR_ABORT") { - data.recoverable = false; - } - return super.warn(code, msg, data); + Object.defineProperty(closeSync, previousSymbol, { + value: fs$closeSync + }); + return closeSync; + }(fs17.closeSync); + if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) { + process.on("exit", function() { + debug2(fs17[gracefulQueue]); + require("assert").equal(fs17[gracefulQueue].length, 0); + }); } - [MAYBECLOSE]() { - if (this[ENDED] && this[PENDING] === 0) { - this.emit("prefinish"); - this.emit("finish"); - this.emit("end"); + } + var queue; + if (!global[gracefulQueue]) { + publishQueue(global, fs17[gracefulQueue]); + } + module2.exports = patch(clone(fs17)); + if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs17.__patched) { + module2.exports = patch(fs17); + fs17.__patched = true; + } + function patch(fs18) { + polyfills(fs18); + fs18.gracefulify = patch; + fs18.createReadStream = createReadStream; + fs18.createWriteStream = createWriteStream; + var fs$readFile = fs18.readFile; + fs18.readFile = readFile; + function readFile(path16, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$readFile(path16, options, cb); + function go$readFile(path17, options2, cb2, startTime) { + return fs$readFile(path17, options2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$readFile, [path17, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } + }); } } - [CHECKPATH](entry) { - const p = normPath(entry.path); - const parts = p.split("/"); - if (this.strip) { - if (parts.length < this.strip) { - return false; - } - if (entry.type === "Link") { - const linkparts = normPath(entry.linkpath).split("/"); - if (linkparts.length >= this.strip) { - entry.linkpath = linkparts.slice(this.strip).join("/"); - } else { - return false; + var fs$writeFile = fs18.writeFile; + fs18.writeFile = writeFile; + function writeFile(path16, data, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$writeFile(path16, data, options, cb); + function go$writeFile(path17, data2, options2, cb2, startTime) { + return fs$writeFile(path17, data2, options2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$writeFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); } - } - parts.splice(0, this.strip); - entry.path = parts.join("/"); - } - if (isFinite(this.maxDepth) && parts.length > this.maxDepth) { - this.warn("TAR_ENTRY_ERROR", "path excessively deep", { - entry, - path: p, - depth: parts.length, - maxDepth: this.maxDepth }); - return false; - } - if (!this.preservePaths) { - if (parts.includes("..") || isWindows && /^[a-z]:\.\.$/i.test(parts[0])) { - this.warn("TAR_ENTRY_ERROR", `path contains '..'`, { - entry, - path: p - }); - return false; - } - const [root, stripped] = stripAbsolutePath(p); - if (root) { - entry.path = stripped; - this.warn("TAR_ENTRY_INFO", `stripping ${root} from absolute path`, { - entry, - path: p - }); - } } - if (path10.isAbsolute(entry.path)) { - entry.absolute = normPath(path10.resolve(entry.path)); - } else { - entry.absolute = normPath(path10.resolve(this.cwd, entry.path)); - } - if (!this.preservePaths && entry.absolute.indexOf(this.cwd + "/") !== 0 && entry.absolute !== this.cwd) { - this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", { - entry, - path: normPath(entry.path), - resolvedPath: entry.absolute, - cwd: this.cwd + } + var fs$appendFile = fs18.appendFile; + if (fs$appendFile) + fs18.appendFile = appendFile; + function appendFile(path16, data, options, cb) { + if (typeof options === "function") + cb = options, options = null; + return go$appendFile(path16, data, options, cb); + function go$appendFile(path17, data2, options2, cb2, startTime) { + return fs$appendFile(path17, data2, options2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$appendFile, [path17, data2, options2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); + } }); - return false; } - if (entry.absolute === this.cwd && entry.type !== "Directory" && entry.type !== "GNUDumpDir") { - return false; - } - if (this.win32) { - const { root: aRoot } = path10.win32.parse(entry.absolute); - entry.absolute = aRoot + wc.encode(entry.absolute.slice(aRoot.length)); - const { root: pRoot } = path10.win32.parse(entry.path); - entry.path = pRoot + wc.encode(entry.path.slice(pRoot.length)); - } - return true; } - [ONENTRY](entry) { - if (!this[CHECKPATH](entry)) { - return entry.resume(); + var fs$copyFile = fs18.copyFile; + if (fs$copyFile) + fs18.copyFile = copyFile; + function copyFile(src, dest, flags, cb) { + if (typeof flags === "function") { + cb = flags; + flags = 0; } - assert3.equal(typeof entry.absolute, "string"); - switch (entry.type) { - case "Directory": - case "GNUDumpDir": - if (entry.mode) { - entry.mode = entry.mode | 448; + return go$copyFile(src, dest, flags, cb); + function go$copyFile(src2, dest2, flags2, cb2, startTime) { + return fs$copyFile(src2, dest2, flags2, function(err) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); } - case "File": - case "OldFile": - case "ContiguousFile": - case "Link": - case "SymbolicLink": - return this[CHECKFS](entry); - case "CharacterDevice": - case "BlockDevice": - case "FIFO": - default: - return this[UNSUPPORTED](entry); + }); } } - [ONERROR](er, entry) { - if (er.name === "CwdError") { - this.emit("error", er); - } else { - this.warn("TAR_ENTRY_ERROR", er, { entry }); - this[UNPEND](); - entry.resume(); + var fs$readdir = fs18.readdir; + fs18.readdir = readdir; + var noReaddirOptionVersions = /^v[0-5]\./; + function readdir(path16, options, cb) { + if (typeof options === "function") + cb = options, options = null; + var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path17, options2, cb2, startTime) { + return fs$readdir(path17, fs$readdirCallback( + path17, + options2, + cb2, + startTime + )); + } : function go$readdir2(path17, options2, cb2, startTime) { + return fs$readdir(path17, options2, fs$readdirCallback( + path17, + options2, + cb2, + startTime + )); + }; + return go$readdir(path16, options, cb); + function fs$readdirCallback(path17, options2, cb2, startTime) { + return function(err, files) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([ + go$readdir, + [path17, options2, cb2], + err, + startTime || Date.now(), + Date.now() + ]); + else { + if (files && files.sort) + files.sort(); + if (typeof cb2 === "function") + cb2.call(this, err, files); + } + }; } } - [MKDIR](dir, mode, cb) { - mkdir4(normPath(dir), { - uid: this.uid, - gid: this.gid, - processUid: this.processUid, - processGid: this.processGid, - umask: this.processUmask, - preserve: this.preservePaths, - unlink: this.unlink, - cache: this.dirCache, - cwd: this.cwd, - mode, - noChmod: this.noChmod - }, cb); + if (process.version.substr(0, 4) === "v0.8") { + var legStreams = legacy(fs18); + ReadStream2 = legStreams.ReadStream; + WriteStream2 = legStreams.WriteStream; } - [DOCHOWN](entry) { - return this.forceChown || this.preserveOwner && (typeof entry.uid === "number" && entry.uid !== this.processUid || typeof entry.gid === "number" && entry.gid !== this.processGid) || (typeof this.uid === "number" && this.uid !== this.processUid || typeof this.gid === "number" && this.gid !== this.processGid); + var fs$ReadStream = fs18.ReadStream; + if (fs$ReadStream) { + ReadStream2.prototype = Object.create(fs$ReadStream.prototype); + ReadStream2.prototype.open = ReadStream$open; } - [UID](entry) { - return uint32(this.uid, entry.uid, this.processUid); + var fs$WriteStream = fs18.WriteStream; + if (fs$WriteStream) { + WriteStream2.prototype = Object.create(fs$WriteStream.prototype); + WriteStream2.prototype.open = WriteStream$open; } - [GID](entry) { - return uint32(this.gid, entry.gid, this.processGid); + Object.defineProperty(fs18, "ReadStream", { + get: function() { + return ReadStream2; + }, + set: function(val) { + ReadStream2 = val; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(fs18, "WriteStream", { + get: function() { + return WriteStream2; + }, + set: function(val) { + WriteStream2 = val; + }, + enumerable: true, + configurable: true + }); + var FileReadStream = ReadStream2; + Object.defineProperty(fs18, "FileReadStream", { + get: function() { + return FileReadStream; + }, + set: function(val) { + FileReadStream = val; + }, + enumerable: true, + configurable: true + }); + var FileWriteStream = WriteStream2; + Object.defineProperty(fs18, "FileWriteStream", { + get: function() { + return FileWriteStream; + }, + set: function(val) { + FileWriteStream = val; + }, + enumerable: true, + configurable: true + }); + function ReadStream2(path16, options) { + if (this instanceof ReadStream2) + return fs$ReadStream.apply(this, arguments), this; + else + return ReadStream2.apply(Object.create(ReadStream2.prototype), arguments); } - [FILE](entry, fullyDone) { - const mode = entry.mode & 4095 || this.fmode; - const stream = new fsm.WriteStream(entry.absolute, { - flags: getFlag(entry.size), - mode, - autoClose: false - }); - stream.on("error", (er) => { - if (stream.fd) { - fs8.close(stream.fd, () => { - }); - } - stream.write = () => true; - this[ONERROR](er, entry); - fullyDone(); - }); - let actions = 1; - const done = (er) => { - if (er) { - if (stream.fd) { - fs8.close(stream.fd, () => { - }); - } - this[ONERROR](er, entry); - fullyDone(); - return; - } - if (--actions === 0) { - fs8.close(stream.fd, (er2) => { - if (er2) { - this[ONERROR](er2, entry); - } else { - this[UNPEND](); - } - fullyDone(); - }); - } - }; - stream.on("finish", (_) => { - const abs = entry.absolute; - const fd = stream.fd; - if (entry.mtime && !this.noMtime) { - actions++; - const atime = entry.atime || /* @__PURE__ */ new Date(); - const mtime = entry.mtime; - fs8.futimes(fd, atime, mtime, (er) => er ? fs8.utimes(abs, atime, mtime, (er2) => done(er2 && er)) : done()); - } - if (this[DOCHOWN](entry)) { - actions++; - const uid = this[UID](entry); - const gid = this[GID](entry); - fs8.fchown(fd, uid, gid, (er) => er ? fs8.chown(abs, uid, gid, (er2) => done(er2 && er)) : done()); + function ReadStream$open() { + var that = this; + open(that.path, that.flags, that.mode, function(err, fd) { + if (err) { + if (that.autoClose) + that.destroy(); + that.emit("error", err); + } else { + that.fd = fd; + that.emit("open", fd); + that.read(); } - done(); }); - const tx = this.transform ? this.transform(entry) || entry : entry; - if (tx !== entry) { - tx.on("error", (er) => { - this[ONERROR](er, entry); - fullyDone(); - }); - entry.pipe(tx); - } - tx.pipe(stream); } - [DIRECTORY](entry, fullyDone) { - const mode = entry.mode & 4095 || this.dmode; - this[MKDIR](entry.absolute, mode, (er) => { - if (er) { - this[ONERROR](er, entry); - fullyDone(); - return; - } - let actions = 1; - const done = (_) => { - if (--actions === 0) { - fullyDone(); - this[UNPEND](); - entry.resume(); - } - }; - if (entry.mtime && !this.noMtime) { - actions++; - fs8.utimes(entry.absolute, entry.atime || /* @__PURE__ */ new Date(), entry.mtime, done); - } - if (this[DOCHOWN](entry)) { - actions++; - fs8.chown(entry.absolute, this[UID](entry), this[GID](entry), done); + function WriteStream2(path16, options) { + if (this instanceof WriteStream2) + return fs$WriteStream.apply(this, arguments), this; + else + return WriteStream2.apply(Object.create(WriteStream2.prototype), arguments); + } + function WriteStream$open() { + var that = this; + open(that.path, that.flags, that.mode, function(err, fd) { + if (err) { + that.destroy(); + that.emit("error", err); + } else { + that.fd = fd; + that.emit("open", fd); } - done(); }); } - [UNSUPPORTED](entry) { - entry.unsupported = true; - this.warn( - "TAR_ENTRY_UNSUPPORTED", - `unsupported entry type: ${entry.type}`, - { entry } - ); - entry.resume(); - } - [SYMLINK](entry, done) { - this[LINK](entry, entry.linkpath, "symlink", done); - } - [HARDLINK](entry, done) { - const linkpath = normPath(path10.resolve(this.cwd, entry.linkpath)); - this[LINK](entry, linkpath, "link", done); - } - [PEND]() { - this[PENDING]++; - } - [UNPEND]() { - this[PENDING]--; - this[MAYBECLOSE](); - } - [SKIP](entry) { - this[UNPEND](); - entry.resume(); - } - // Check if we can reuse an existing filesystem entry safely and - // overwrite it, rather than unlinking and recreating - // Windows doesn't report a useful nlink, so we just never reuse entries - [ISREUSABLE](entry, st) { - return entry.type === "File" && !this.unlink && st.isFile() && st.nlink <= 1 && !isWindows; - } - // check if a thing is there, and if so, try to clobber it - [CHECKFS](entry) { - this[PEND](); - const paths = [entry.path]; - if (entry.linkpath) { - paths.push(entry.linkpath); - } - this.reservations.reserve(paths, (done) => this[CHECKFS2](entry, done)); + function createReadStream(path16, options) { + return new fs18.ReadStream(path16, options); } - [PRUNECACHE](entry) { - if (entry.type === "SymbolicLink") { - dropCache(this.dirCache); - } else if (entry.type !== "Directory") { - pruneCache(this.dirCache, entry.absolute); - } + function createWriteStream(path16, options) { + return new fs18.WriteStream(path16, options); } - [CHECKFS2](entry, fullyDone) { - this[PRUNECACHE](entry); - const done = (er) => { - this[PRUNECACHE](entry); - fullyDone(er); - }; - const checkCwd = () => { - this[MKDIR](this.cwd, this.dmode, (er) => { - if (er) { - this[ONERROR](er, entry); - done(); - return; - } - this[CHECKED_CWD] = true; - start(); - }); - }; - const start = () => { - if (entry.absolute !== this.cwd) { - const parent = normPath(path10.dirname(entry.absolute)); - if (parent !== this.cwd) { - return this[MKDIR](parent, this.dmode, (er) => { - if (er) { - this[ONERROR](er, entry); - done(); - return; - } - afterMakeParent(); - }); - } - } - afterMakeParent(); - }; - const afterMakeParent = () => { - fs8.lstat(entry.absolute, (lstatEr, st) => { - if (st && (this.keep || this.newer && st.mtime > entry.mtime)) { - this[SKIP](entry); - done(); - return; - } - if (lstatEr || this[ISREUSABLE](entry, st)) { - return this[MAKEFS](null, entry, done); - } - if (st.isDirectory()) { - if (entry.type === "Directory") { - const needChmod = !this.noChmod && entry.mode && (st.mode & 4095) !== entry.mode; - const afterChmod = (er) => this[MAKEFS](er, entry, done); - if (!needChmod) { - return afterChmod(); - } - return fs8.chmod(entry.absolute, entry.mode, afterChmod); - } - if (entry.absolute !== this.cwd) { - return fs8.rmdir(entry.absolute, (er) => this[MAKEFS](er, entry, done)); - } - } - if (entry.absolute === this.cwd) { - return this[MAKEFS](null, entry, done); + var fs$open = fs18.open; + fs18.open = open; + function open(path16, flags, mode, cb) { + if (typeof mode === "function") + cb = mode, mode = null; + return go$open(path16, flags, mode, cb); + function go$open(path17, flags2, mode2, cb2, startTime) { + return fs$open(path17, flags2, mode2, function(err, fd) { + if (err && (err.code === "EMFILE" || err.code === "ENFILE")) + enqueue([go$open, [path17, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]); + else { + if (typeof cb2 === "function") + cb2.apply(this, arguments); } - unlinkFile(entry.absolute, (er) => this[MAKEFS](er, entry, done)); }); - }; - if (this[CHECKED_CWD]) { - start(); - } else { - checkCwd(); } } - [MAKEFS](er, entry, done) { - if (er) { - this[ONERROR](er, entry); - done(); - return; - } - switch (entry.type) { - case "File": - case "OldFile": - case "ContiguousFile": - return this[FILE](entry, done); - case "Link": - return this[HARDLINK](entry, done); - case "SymbolicLink": - return this[SYMLINK](entry, done); - case "Directory": - case "GNUDumpDir": - return this[DIRECTORY](entry, done); + return fs18; + } + function enqueue(elem) { + debug2("ENQUEUE", elem[0].name, elem[1]); + fs17[gracefulQueue].push(elem); + retry(); + } + var retryTimer; + function resetQueue() { + var now = Date.now(); + for (var i = 0; i < fs17[gracefulQueue].length; ++i) { + if (fs17[gracefulQueue][i].length > 2) { + fs17[gracefulQueue][i][3] = now; + fs17[gracefulQueue][i][4] = now; } } - [LINK](entry, linkpath, link, done) { - fs8[link](linkpath, entry.absolute, (er) => { - if (er) { - this[ONERROR](er, entry); - } else { - this[UNPEND](); - entry.resume(); - } - done(); - }); + retry(); + } + function retry() { + clearTimeout(retryTimer); + retryTimer = void 0; + if (fs17[gracefulQueue].length === 0) + return; + var elem = fs17[gracefulQueue].shift(); + var fn2 = elem[0]; + var args = elem[1]; + var err = elem[2]; + var startTime = elem[3]; + var lastTime = elem[4]; + if (startTime === void 0) { + debug2("RETRY", fn2.name, args); + fn2.apply(null, args); + } else if (Date.now() - startTime >= 6e4) { + debug2("TIMEOUT", fn2.name, args); + var cb = args.pop(); + if (typeof cb === "function") + cb.call(null, err); + } else { + var sinceAttempt = Date.now() - lastTime; + var sinceStart = Math.max(lastTime - startTime, 1); + var desiredDelay = Math.min(sinceStart * 1.2, 100); + if (sinceAttempt >= desiredDelay) { + debug2("RETRY", fn2.name, args); + fn2.apply(null, args.concat([startTime])); + } else { + fs17[gracefulQueue].push(elem); + } } - }; - var callSync = (fn2) => { - try { - return [null, fn2()]; - } catch (er) { - return [er, null]; + if (retryTimer === void 0) { + retryTimer = setTimeout(retry, 0); } - }; - var UnpackSync = class extends Unpack { - [MAKEFS](er, entry) { - return super[MAKEFS](er, entry, () => { - }); - } - [CHECKFS](entry) { - this[PRUNECACHE](entry); - if (!this[CHECKED_CWD]) { - const er2 = this[MKDIR](this.cwd, this.dmode); - if (er2) { - return this[ONERROR](er2, entry); - } - this[CHECKED_CWD] = true; - } - if (entry.absolute !== this.cwd) { - const parent = normPath(path10.dirname(entry.absolute)); - if (parent !== this.cwd) { - const mkParent = this[MKDIR](parent, this.dmode); - if (mkParent) { - return this[ONERROR](mkParent, entry); - } - } - } - const [lstatEr, st] = callSync(() => fs8.lstatSync(entry.absolute)); - if (st && (this.keep || this.newer && st.mtime > entry.mtime)) { - return this[SKIP](entry); - } - if (lstatEr || this[ISREUSABLE](entry, st)) { - return this[MAKEFS](null, entry); - } - if (st.isDirectory()) { - if (entry.type === "Directory") { - const needChmod = !this.noChmod && entry.mode && (st.mode & 4095) !== entry.mode; - const [er3] = needChmod ? callSync(() => { - fs8.chmodSync(entry.absolute, entry.mode); - }) : []; - return this[MAKEFS](er3, entry); - } - const [er2] = callSync(() => fs8.rmdirSync(entry.absolute)); - this[MAKEFS](er2, entry); - } - const [er] = entry.absolute === this.cwd ? [] : callSync(() => unlinkFileSync(entry.absolute)); - this[MAKEFS](er, entry); - } - [FILE](entry, done) { - const mode = entry.mode & 4095 || this.fmode; - const oner = (er) => { - let closeError; - try { - fs8.closeSync(fd); - } catch (e) { - closeError = e; - } - if (er || closeError) { - this[ONERROR](er || closeError, entry); - } - done(); - }; - let fd; - try { - fd = fs8.openSync(entry.absolute, getFlag(entry.size), mode); - } catch (er) { - return oner(er); - } - const tx = this.transform ? this.transform(entry) || entry : entry; - if (tx !== entry) { - tx.on("error", (er) => this[ONERROR](er, entry)); - entry.pipe(tx); - } - tx.on("data", (chunk) => { - try { - fs8.writeSync(fd, chunk, 0, chunk.length); - } catch (er) { - oner(er); - } - }); - tx.on("end", (_) => { - let er = null; - if (entry.mtime && !this.noMtime) { - const atime = entry.atime || /* @__PURE__ */ new Date(); - const mtime = entry.mtime; - try { - fs8.futimesSync(fd, atime, mtime); - } catch (futimeser) { - try { - fs8.utimesSync(entry.absolute, atime, mtime); - } catch (utimeser) { - er = futimeser; - } - } - } - if (this[DOCHOWN](entry)) { - const uid = this[UID](entry); - const gid = this[GID](entry); - try { - fs8.fchownSync(fd, uid, gid); - } catch (fchowner) { - try { - fs8.chownSync(entry.absolute, uid, gid); - } catch (chowner) { - er = er || fchowner; - } - } - } - oner(er); - }); - } - [DIRECTORY](entry, done) { - const mode = entry.mode & 4095 || this.dmode; - const er = this[MKDIR](entry.absolute, mode); - if (er) { - this[ONERROR](er, entry); - done(); - return; - } - if (entry.mtime && !this.noMtime) { - try { - fs8.utimesSync(entry.absolute, entry.atime || /* @__PURE__ */ new Date(), entry.mtime); - } catch (er2) { - } - } - if (this[DOCHOWN](entry)) { - try { - fs8.chownSync(entry.absolute, this[UID](entry), this[GID](entry)); - } catch (er2) { - } - } - done(); - entry.resume(); - } - [MKDIR](dir, mode) { - try { - return mkdir4.sync(normPath(dir), { - uid: this.uid, - gid: this.gid, - processUid: this.processUid, - processGid: this.processGid, - umask: this.processUmask, - preserve: this.preservePaths, - unlink: this.unlink, - cache: this.dirCache, - cwd: this.cwd, - mode - }); - } catch (er) { - return er; - } - } - [LINK](entry, linkpath, link, done) { - try { - fs8[link + "Sync"](linkpath, entry.absolute); - done(); - entry.resume(); - } catch (er) { - return this[ONERROR](er, entry); - } - } - }; - Unpack.Sync = UnpackSync; - module2.exports = Unpack; + } } }); -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/extract.js -var require_extract = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/lib/extract.js"(exports2, module2) { +// .yarn/cache/@zkochan-cmd-shim-npm-6.0.0-97792a7373-ba1442ba1e.zip/node_modules/@zkochan/cmd-shim/index.js +var require_cmd_shim = __commonJS({ + ".yarn/cache/@zkochan-cmd-shim-npm-6.0.0-97792a7373-ba1442ba1e.zip/node_modules/@zkochan/cmd-shim/index.js"(exports2, module2) { "use strict"; - var hlo = require_high_level_opt(); - var Unpack = require_unpack(); - var fs8 = require("fs"); - var fsm = require_fs_minipass(); - var path10 = require("path"); - var stripSlash = require_strip_trailing_slashes(); - module2.exports = (opt_, files, cb) => { - if (typeof opt_ === "function") { - cb = opt_, files = null, opt_ = {}; - } else if (Array.isArray(opt_)) { - files = opt_, opt_ = {}; - } - if (typeof files === "function") { - cb = files, files = null; - } - if (!files) { - files = []; - } else { - files = Array.from(files); - } - const opt = hlo(opt_); - if (opt.sync && typeof cb === "function") { - throw new TypeError("callback not supported for sync tar functions"); - } - if (!opt.file && typeof cb === "function") { - throw new TypeError("callback only supported with file option"); - } - if (files.length) { - filesFilter(opt, files); - } - return opt.file && opt.sync ? extractFileSync(opt) : opt.file ? extractFile(opt, cb) : opt.sync ? extractSync(opt) : extract(opt); + cmdShim2.ifExists = cmdShimIfExists; + var util_1 = require("util"); + var path16 = require("path"); + var isWindows4 = require_is_windows(); + var CMD_EXTENSION = require_cmd_extension(); + var shebangExpr = /^#!\s*(?:\/usr\/bin\/env(?:\s+-S\s*)?)?\s*([^ \t]+)(.*)$/; + var DEFAULT_OPTIONS = { + // Create PowerShell file by default if the option hasn't been specified + createPwshFile: true, + createCmdFile: isWindows4(), + fs: require_graceful_fs() }; - var filesFilter = (opt, files) => { - const map = new Map(files.map((f) => [stripSlash(f), true])); - const filter = opt.filter; - const mapHas = (file, r) => { - const root = r || path10.parse(file).root || "."; - const ret = file === root ? false : map.has(file) ? map.get(file) : mapHas(path10.dirname(file), root); - map.set(file, ret); - return ret; + var extensionToProgramMap = /* @__PURE__ */ new Map([ + [".js", "node"], + [".cjs", "node"], + [".mjs", "node"], + [".cmd", "cmd"], + [".bat", "cmd"], + [".ps1", "pwsh"], + [".sh", "sh"] + ]); + function ingestOptions(opts) { + const opts_ = { ...DEFAULT_OPTIONS, ...opts }; + const fs17 = opts_.fs; + opts_.fs_ = { + chmod: fs17.chmod ? (0, util_1.promisify)(fs17.chmod) : async () => { + }, + mkdir: (0, util_1.promisify)(fs17.mkdir), + readFile: (0, util_1.promisify)(fs17.readFile), + stat: (0, util_1.promisify)(fs17.stat), + unlink: (0, util_1.promisify)(fs17.unlink), + writeFile: (0, util_1.promisify)(fs17.writeFile) }; - opt.filter = filter ? (file, entry) => filter(file, entry) && mapHas(stripSlash(file)) : (file) => mapHas(stripSlash(file)); - }; - var extractFileSync = (opt) => { - const u = new Unpack.Sync(opt); - const file = opt.file; - const stat = fs8.statSync(file); - const readSize = opt.maxReadSize || 16 * 1024 * 1024; - const stream = new fsm.ReadStreamSync(file, { - readSize, - size: stat.size + return opts_; + } + async function cmdShim2(src, to, opts) { + const opts_ = ingestOptions(opts); + await cmdShim_(src, to, opts_); + } + function cmdShimIfExists(src, to, opts) { + return cmdShim2(src, to, opts).catch(() => { }); - stream.pipe(u); - }; - var extractFile = (opt, cb) => { - const u = new Unpack(opt); - const readSize = opt.maxReadSize || 16 * 1024 * 1024; - const file = opt.file; - const p = new Promise((resolve, reject) => { - u.on("error", reject); - u.on("close", resolve); - fs8.stat(file, (er, stat) => { - if (er) { - reject(er); - } else { - const stream = new fsm.ReadStream(file, { - readSize, - size: stat.size - }); - stream.on("error", reject); - stream.pipe(u); - } - }); + } + function rm(path17, opts) { + return opts.fs_.unlink(path17).catch(() => { }); - return cb ? p.then(cb, cb) : p; - }; - var extractSync = (opt) => new Unpack.Sync(opt); - var extract = (opt) => new Unpack(opt); - } -}); - -// .yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/index.js -var require_tar = __commonJS({ - ".yarn/cache/tar-npm-6.2.1-237800bb20-a5eca3eb50.zip/node_modules/tar/index.js"(exports2) { - "use strict"; - exports2.c = exports2.create = require_create(); - exports2.r = exports2.replace = require_replace(); - exports2.t = exports2.list = require_list(); - exports2.u = exports2.update = require_update(); - exports2.x = exports2.extract = require_extract(); - exports2.Pack = require_pack(); - exports2.Unpack = require_unpack(); - exports2.Parse = require_parse2(); - exports2.ReadEntry = require_read_entry(); - exports2.WriteEntry = require_write_entry(); - exports2.Header = require_header(); - exports2.Pax = require_pax(); - exports2.types = require_types(); - } -}); - -// .yarn/cache/v8-compile-cache-npm-2.4.0-5979f8e405-3878511925.zip/node_modules/v8-compile-cache/v8-compile-cache.js -var require_v8_compile_cache = __commonJS({ - ".yarn/cache/v8-compile-cache-npm-2.4.0-5979f8e405-3878511925.zip/node_modules/v8-compile-cache/v8-compile-cache.js"(exports2, module2) { - "use strict"; - var Module2 = require("module"); - var crypto = require("crypto"); - var fs8 = require("fs"); - var path10 = require("path"); - var vm = require("vm"); - var os3 = require("os"); - var hasOwnProperty = Object.prototype.hasOwnProperty; - var FileSystemBlobStore = class { - constructor(directory, prefix) { - const name = prefix ? slashEscape(prefix + ".") : ""; - this._blobFilename = path10.join(directory, name + "BLOB"); - this._mapFilename = path10.join(directory, name + "MAP"); - this._lockFilename = path10.join(directory, name + "LOCK"); - this._directory = directory; - this._load(); - } - has(key, invalidationKey) { - if (hasOwnProperty.call(this._memoryBlobs, key)) { - return this._invalidationKeys[key] === invalidationKey; - } else if (hasOwnProperty.call(this._storedMap, key)) { - return this._storedMap[key][0] === invalidationKey; - } - return false; - } - get(key, invalidationKey) { - if (hasOwnProperty.call(this._memoryBlobs, key)) { - if (this._invalidationKeys[key] === invalidationKey) { - return this._memoryBlobs[key]; - } - } else if (hasOwnProperty.call(this._storedMap, key)) { - const mapping = this._storedMap[key]; - if (mapping[0] === invalidationKey) { - return this._storedBlob.slice(mapping[1], mapping[2]); - } - } - } - set(key, invalidationKey, buffer) { - this._invalidationKeys[key] = invalidationKey; - this._memoryBlobs[key] = buffer; - this._dirty = true; - } - delete(key) { - if (hasOwnProperty.call(this._memoryBlobs, key)) { - this._dirty = true; - delete this._memoryBlobs[key]; - } - if (hasOwnProperty.call(this._invalidationKeys, key)) { - this._dirty = true; - delete this._invalidationKeys[key]; - } - if (hasOwnProperty.call(this._storedMap, key)) { - this._dirty = true; - delete this._storedMap[key]; - } + } + async function cmdShim_(src, to, opts) { + const srcRuntimeInfo = await searchScriptRuntime(src, opts); + await writeShimsPreCommon(to, opts); + return writeAllShims(src, to, srcRuntimeInfo, opts); + } + function writeShimsPreCommon(target, opts) { + return opts.fs_.mkdir(path16.dirname(target), { recursive: true }); + } + function writeAllShims(src, to, srcRuntimeInfo, opts) { + const opts_ = ingestOptions(opts); + const generatorAndExts = [{ generator: generateShShim, extension: "" }]; + if (opts_.createCmdFile) { + generatorAndExts.push({ generator: generateCmdShim, extension: CMD_EXTENSION }); } - isDirty() { - return this._dirty; + if (opts_.createPwshFile) { + generatorAndExts.push({ generator: generatePwshShim, extension: ".ps1" }); } - save() { - const dump = this._getDump(); - const blobToStore = Buffer.concat(dump[0]); - const mapToStore = JSON.stringify(dump[1]); - try { - mkdirpSync(this._directory); - fs8.writeFileSync(this._lockFilename, "LOCK", { flag: "wx" }); - } catch (error) { - return false; + return Promise.all(generatorAndExts.map((generatorAndExt) => writeShim(src, to + generatorAndExt.extension, srcRuntimeInfo, generatorAndExt.generator, opts_))); + } + function writeShimPre(target, opts) { + return rm(target, opts); + } + function writeShimPost(target, opts) { + return chmodShim(target, opts); + } + async function searchScriptRuntime(target, opts) { + try { + const data = await opts.fs_.readFile(target, "utf8"); + const firstLine = data.trim().split(/\r*\n/)[0]; + const shebang = firstLine.match(shebangExpr); + if (!shebang) { + const targetExtension = path16.extname(target).toLowerCase(); + return { + // undefined if extension is unknown but it's converted to null. + program: extensionToProgramMap.get(targetExtension) || null, + additionalArgs: "" + }; } - try { - fs8.writeFileSync(this._blobFilename, blobToStore); - fs8.writeFileSync(this._mapFilename, mapToStore); - } finally { - fs8.unlinkSync(this._lockFilename); + return { + program: shebang[1], + additionalArgs: shebang[2] + }; + } catch (err) { + if (!isWindows4() || err.code !== "ENOENT") + throw err; + if (await opts.fs_.stat(`${target}${getExeExtension()}`)) { + return { + program: null, + additionalArgs: "" + }; } - return true; + throw err; } - _load() { - try { - this._storedBlob = fs8.readFileSync(this._blobFilename); - this._storedMap = JSON.parse(fs8.readFileSync(this._mapFilename)); - } catch (e) { - this._storedBlob = Buffer.alloc(0); - this._storedMap = {}; - } - this._dirty = false; - this._memoryBlobs = {}; - this._invalidationKeys = {}; + } + function getExeExtension() { + let cmdExtension; + if (process.env.PATHEXT) { + cmdExtension = process.env.PATHEXT.split(path16.delimiter).find((ext) => ext.toLowerCase() === ".exe"); } - _getDump() { - const buffers = []; - const newMap = {}; - let offset = 0; - function push(key, invalidationKey, buffer) { - buffers.push(buffer); - newMap[key] = [invalidationKey, offset, offset + buffer.length]; - offset += buffer.length; - } - for (const key of Object.keys(this._memoryBlobs)) { - const buffer = this._memoryBlobs[key]; - const invalidationKey = this._invalidationKeys[key]; - push(key, invalidationKey, buffer); - } - for (const key of Object.keys(this._storedMap)) { - if (hasOwnProperty.call(newMap, key)) continue; - const mapping = this._storedMap[key]; - const buffer = this._storedBlob.slice(mapping[1], mapping[2]); - push(key, mapping[0], buffer); - } - return [buffers, newMap]; + return cmdExtension || ".exe"; + } + async function writeShim(src, to, srcRuntimeInfo, generateShimScript, opts) { + const defaultArgs = opts.preserveSymlinks ? "--preserve-symlinks" : ""; + const args = [srcRuntimeInfo.additionalArgs, defaultArgs].filter((arg) => arg).join(" "); + opts = Object.assign({}, opts, { + prog: srcRuntimeInfo.program, + args + }); + await writeShimPre(to, opts); + await opts.fs_.writeFile(to, generateShimScript(src, to, opts), "utf8"); + return writeShimPost(to, opts); + } + function generateCmdShim(src, to, opts) { + const shTarget = path16.relative(path16.dirname(to), src); + let target = shTarget.split("/").join("\\"); + const quotedPathToTarget = path16.isAbsolute(target) ? `"${target}"` : `"%~dp0\\${target}"`; + let longProg; + let prog = opts.prog; + let args = opts.args || ""; + const nodePath = normalizePathEnvVar(opts.nodePath).win32; + const prependToPath = normalizePathEnvVar(opts.prependToPath).win32; + if (!prog) { + prog = quotedPathToTarget; + args = ""; + target = ""; + } else if (prog === "node" && opts.nodeExecPath) { + prog = `"${opts.nodeExecPath}"`; + target = quotedPathToTarget; + } else { + longProg = `"%~dp0\\${prog}.exe"`; + target = quotedPathToTarget; } - }; - var NativeCompileCache = class { - constructor() { - this._cacheStore = null; - this._previousModuleCompile = null; + let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : ""; + let cmd = "@SETLOCAL\r\n"; + if (prependToPath) { + cmd += `@SET "PATH=${prependToPath}:%PATH%"\r +`; } - setCacheStore(cacheStore) { - this._cacheStore = cacheStore; + if (nodePath) { + cmd += `@IF NOT DEFINED NODE_PATH (\r + @SET "NODE_PATH=${nodePath}"\r +) ELSE (\r + @SET "NODE_PATH=${nodePath};%NODE_PATH%"\r +)\r +`; } - install() { - const self2 = this; - const hasRequireResolvePaths = typeof require.resolve.paths === "function"; - this._previousModuleCompile = Module2.prototype._compile; - Module2.prototype._compile = function(content, filename) { - const mod = this; - function require2(id) { - return mod.require(id); - } - function resolve(request, options) { - return Module2._resolveFilename(request, mod, false, options); - } - require2.resolve = resolve; - if (hasRequireResolvePaths) { - resolve.paths = function paths(request) { - return Module2._resolveLookupPaths(request, mod, true); - }; - } - require2.main = process.mainModule; - require2.extensions = Module2._extensions; - require2.cache = Module2._cache; - const dirname = path10.dirname(filename); - const compiledWrapper = self2._moduleCompile(filename, content); - const args = [mod.exports, require2, mod, filename, dirname, process, global, Buffer]; - return compiledWrapper.apply(mod.exports, args); - }; + if (longProg) { + cmd += `@IF EXIST ${longProg} (\r + ${longProg} ${args} ${target} ${progArgs}%*\r +) ELSE (\r + @SET PATHEXT=%PATHEXT:;.JS;=;%\r + ${prog} ${args} ${target} ${progArgs}%*\r +)\r +`; + } else { + cmd += `@${prog} ${args} ${target} ${progArgs}%*\r +`; } - uninstall() { - Module2.prototype._compile = this._previousModuleCompile; + return cmd; + } + function generateShShim(src, to, opts) { + let shTarget = path16.relative(path16.dirname(to), src); + let shProg = opts.prog && opts.prog.split("\\").join("/"); + let shLongProg; + shTarget = shTarget.split("\\").join("/"); + const quotedPathToTarget = path16.isAbsolute(shTarget) ? `"${shTarget}"` : `"$basedir/${shTarget}"`; + let args = opts.args || ""; + const shNodePath = normalizePathEnvVar(opts.nodePath).posix; + if (!shProg) { + shProg = quotedPathToTarget; + args = ""; + shTarget = ""; + } else if (opts.prog === "node" && opts.nodeExecPath) { + shProg = `"${opts.nodeExecPath}"`; + shTarget = quotedPathToTarget; + } else { + shLongProg = `"$basedir/${opts.prog}"`; + shTarget = quotedPathToTarget; } - _moduleCompile(filename, content) { - var contLen = content.length; - if (contLen >= 2) { - if (content.charCodeAt(0) === 35 && content.charCodeAt(1) === 33) { - if (contLen === 2) { - content = ""; - } else { - var i = 2; - for (; i < contLen; ++i) { - var code = content.charCodeAt(i); - if (code === 10 || code === 13) break; - } - if (i === contLen) { - content = ""; - } else { - content = content.slice(i); - } - } - } - } - var wrapper = Module2.wrap(content); - var invalidationKey = crypto.createHash("sha1").update(content, "utf8").digest("hex"); - var buffer = this._cacheStore.get(filename, invalidationKey); - var script = new vm.Script(wrapper, { - filename, - lineOffset: 0, - displayErrors: true, - cachedData: buffer, - produceCachedData: true - }); - if (script.cachedDataProduced) { - this._cacheStore.set(filename, invalidationKey, script.cachedData); - } else if (script.cachedDataRejected) { - this._cacheStore.delete(filename); - } - var compiledWrapper = script.runInThisContext({ - filename, - lineOffset: 0, - columnOffset: 0, - displayErrors: true - }); - return compiledWrapper; + let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : ""; + let sh = `#!/bin/sh +basedir=$(dirname "$(echo "$0" | sed -e 's,\\\\,/,g')") + +case \`uname\` in + *CYGWIN*) basedir=\`cygpath -w "$basedir"\`;; +esac + +`; + if (opts.prependToPath) { + sh += `export PATH="${opts.prependToPath}:$PATH" +`; } - }; - function mkdirpSync(p_) { - _mkdirpSync(path10.resolve(p_), 511); - } - function _mkdirpSync(p, mode) { - try { - fs8.mkdirSync(p, mode); - } catch (err0) { - if (err0.code === "ENOENT") { - _mkdirpSync(path10.dirname(p)); - _mkdirpSync(p); - } else { - try { - const stat = fs8.statSync(p); - if (!stat.isDirectory()) { - throw err0; - } - } catch (err1) { - throw err0; - } - } + if (shNodePath) { + sh += `if [ -z "$NODE_PATH" ]; then + export NODE_PATH="${shNodePath}" +else + export NODE_PATH="${shNodePath}:$NODE_PATH" +fi +`; } - } - function slashEscape(str) { - const ESCAPE_LOOKUP = { - "\\": "zB", - ":": "zC", - "/": "zS", - "\0": "z0", - "z": "zZ" - }; - const ESCAPE_REGEX = /[\\:/\x00z]/g; - return str.replace(ESCAPE_REGEX, (match) => ESCAPE_LOOKUP[match]); - } - function supportsCachedData() { - const script = new vm.Script('""', { produceCachedData: true }); - return script.cachedDataProduced === true; - } - function getCacheDir() { - const v8_compile_cache_cache_dir = process.env.V8_COMPILE_CACHE_CACHE_DIR; - if (v8_compile_cache_cache_dir) { - return v8_compile_cache_cache_dir; + if (shLongProg) { + sh += `if [ -x ${shLongProg} ]; then + exec ${shLongProg} ${args} ${shTarget} ${progArgs}"$@" +else + exec ${shProg} ${args} ${shTarget} ${progArgs}"$@" +fi +`; + } else { + sh += `${shProg} ${args} ${shTarget} ${progArgs}"$@" +exit $? +`; } - const dirname = typeof process.getuid === "function" ? "v8-compile-cache-" + process.getuid() : "v8-compile-cache"; - const arch = process.arch; - const version2 = typeof process.versions.v8 === "string" ? process.versions.v8 : typeof process.versions.chakracore === "string" ? "chakracore-" + process.versions.chakracore : "node-" + process.version; - const cacheDir = path10.join(os3.tmpdir(), dirname, arch, version2); - return cacheDir; - } - function getMainName() { - const mainName = require.main && typeof require.main.filename === "string" ? require.main.filename : process.cwd(); - return mainName; - } - if (!process.env.DISABLE_V8_COMPILE_CACHE && supportsCachedData()) { - const cacheDir = getCacheDir(); - const prefix = getMainName(); - const blobStore = new FileSystemBlobStore(cacheDir, prefix); - const nativeCompileCache = new NativeCompileCache(); - nativeCompileCache.setCacheStore(blobStore); - nativeCompileCache.install(); - process.once("exit", () => { - if (blobStore.isDirty()) { - blobStore.save(); - } - nativeCompileCache.uninstall(); - }); + return sh; } - module2.exports.__TEST__ = { - FileSystemBlobStore, - NativeCompileCache, - mkdirpSync, - slashEscape, - supportsCachedData, - getCacheDir, - getMainName - }; - } -}); + function generatePwshShim(src, to, opts) { + let shTarget = path16.relative(path16.dirname(to), src); + const shProg = opts.prog && opts.prog.split("\\").join("/"); + let pwshProg = shProg && `"${shProg}$exe"`; + let pwshLongProg; + shTarget = shTarget.split("\\").join("/"); + const quotedPathToTarget = path16.isAbsolute(shTarget) ? `"${shTarget}"` : `"$basedir/${shTarget}"`; + let args = opts.args || ""; + let normalizedNodePathEnvVar = normalizePathEnvVar(opts.nodePath); + const nodePath = normalizedNodePathEnvVar.win32; + const shNodePath = normalizedNodePathEnvVar.posix; + let normalizedPrependPathEnvVar = normalizePathEnvVar(opts.prependToPath); + const prependPath = normalizedPrependPathEnvVar.win32; + const shPrependPath = normalizedPrependPathEnvVar.posix; + if (!pwshProg) { + pwshProg = quotedPathToTarget; + args = ""; + shTarget = ""; + } else if (opts.prog === "node" && opts.nodeExecPath) { + pwshProg = `"${opts.nodeExecPath}"`; + shTarget = quotedPathToTarget; + } else { + pwshLongProg = `"$basedir/${opts.prog}$exe"`; + shTarget = quotedPathToTarget; + } + let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : ""; + let pwsh = `#!/usr/bin/env pwsh +$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent -// .yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/posix.js -var require_posix = __commonJS({ - ".yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/posix.js"(exports2) { - "use strict"; - Object.defineProperty(exports2, "__esModule", { value: true }); - exports2.sync = exports2.isexe = void 0; - var fs_1 = require("fs"); - var promises_1 = require("fs/promises"); - var isexe = async (path10, options = {}) => { - const { ignoreErrors = false } = options; - try { - return checkStat(await (0, promises_1.stat)(path10), options); - } catch (e) { - const er = e; - if (ignoreErrors || er.code === "EACCES") - return false; - throw er; +$exe="" +${nodePath || prependPath ? '$pathsep=":"\n' : ""}${nodePath ? `$env_node_path=$env:NODE_PATH +$new_node_path="${nodePath}" +` : ""}${prependPath ? `$env_path=$env:PATH +$prepend_path="${prependPath}" +` : ""}if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { + # Fix case when both the Windows and Linux builds of Node + # are installed in the same directory + $exe=".exe" +${nodePath || prependPath ? ' $pathsep=";"\n' : ""}}`; + if (shNodePath || shPrependPath) { + pwsh += ` else { +${shNodePath ? ` $new_node_path="${shNodePath}" +` : ""}${shPrependPath ? ` $prepend_path="${shPrependPath}" +` : ""}} +`; } - }; - exports2.isexe = isexe; - var sync = (path10, options = {}) => { - const { ignoreErrors = false } = options; - try { - return checkStat((0, fs_1.statSync)(path10), options); - } catch (e) { - const er = e; - if (ignoreErrors || er.code === "EACCES") - return false; - throw er; + if (shNodePath) { + pwsh += `if ([string]::IsNullOrEmpty($env_node_path)) { + $env:NODE_PATH=$new_node_path +} else { + $env:NODE_PATH="$new_node_path$pathsep$env_node_path" +} +`; } - }; - exports2.sync = sync; - var checkStat = (stat, options) => stat.isFile() && checkMode(stat, options); - var checkMode = (stat, options) => { - const myUid = options.uid ?? process.getuid?.(); - const myGroups = options.groups ?? process.getgroups?.() ?? []; - const myGid = options.gid ?? process.getgid?.() ?? myGroups[0]; - if (myUid === void 0 || myGid === void 0) { - throw new Error("cannot get uid or gid"); + if (opts.prependToPath) { + pwsh += ` +$env:PATH="$prepend_path$pathsep$env:PATH" +`; } - const groups = /* @__PURE__ */ new Set([myGid, ...myGroups]); - const mod = stat.mode; - const uid = stat.uid; - const gid = stat.gid; - const u = parseInt("100", 8); - const g = parseInt("010", 8); - const o = parseInt("001", 8); - const ug = u | g; - return !!(mod & o || mod & g && groups.has(gid) || mod & u && uid === myUid || mod & ug && myUid === 0); - }; + if (pwshLongProg) { + pwsh += ` +$ret=0 +if (Test-Path ${pwshLongProg}) { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & ${pwshLongProg} ${args} ${shTarget} ${progArgs}$args + } else { + & ${pwshLongProg} ${args} ${shTarget} ${progArgs}$args } -}); - -// .yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/win32.js -var require_win32 = __commonJS({ - ".yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/win32.js"(exports2) { - "use strict"; - Object.defineProperty(exports2, "__esModule", { value: true }); - exports2.sync = exports2.isexe = void 0; - var fs_1 = require("fs"); - var promises_1 = require("fs/promises"); - var isexe = async (path10, options = {}) => { - const { ignoreErrors = false } = options; - try { - return checkStat(await (0, promises_1.stat)(path10), path10, options); - } catch (e) { - const er = e; - if (ignoreErrors || er.code === "EACCES") - return false; - throw er; - } - }; - exports2.isexe = isexe; - var sync = (path10, options = {}) => { - const { ignoreErrors = false } = options; - try { - return checkStat((0, fs_1.statSync)(path10), path10, options); - } catch (e) { - const er = e; - if (ignoreErrors || er.code === "EACCES") - return false; - throw er; + $ret=$LASTEXITCODE +} else { + # Support pipeline input + if ($MyInvocation.ExpectingInput) { + $input | & ${pwshProg} ${args} ${shTarget} ${progArgs}$args + } else { + & ${pwshProg} ${args} ${shTarget} ${progArgs}$args + } + $ret=$LASTEXITCODE +} +${nodePath ? "$env:NODE_PATH=$env_node_path\n" : ""}${prependPath ? "$env:PATH=$env_path\n" : ""}exit $ret +`; + } else { + pwsh += ` +# Support pipeline input +if ($MyInvocation.ExpectingInput) { + $input | & ${pwshProg} ${args} ${shTarget} ${progArgs}$args +} else { + & ${pwshProg} ${args} ${shTarget} ${progArgs}$args +} +${nodePath ? "$env:NODE_PATH=$env_node_path\n" : ""}${prependPath ? "$env:PATH=$env_path\n" : ""}exit $LASTEXITCODE +`; } - }; - exports2.sync = sync; - var checkPathExt = (path10, options) => { - const { pathExt = process.env.PATHEXT || "" } = options; - const peSplit = pathExt.split(";"); - if (peSplit.indexOf("") !== -1) { - return true; + return pwsh; + } + function chmodShim(to, opts) { + return opts.fs_.chmod(to, 493); + } + function normalizePathEnvVar(nodePath) { + if (!nodePath || !nodePath.length) { + return { + win32: "", + posix: "" + }; } - for (let i = 0; i < peSplit.length; i++) { - const p = peSplit[i].toLowerCase(); - const ext = path10.substring(path10.length - p.length).toLowerCase(); - if (p && ext === p) { - return true; - } + let split = typeof nodePath === "string" ? nodePath.split(path16.delimiter) : Array.from(nodePath); + let result = {}; + for (let i = 0; i < split.length; i++) { + const win322 = split[i].split("/").join("\\"); + const posix = isWindows4() ? split[i].split("\\").join("/").replace(/^([^:\\/]*):/, (_, $1) => `/mnt/${$1.toLowerCase()}`) : split[i]; + result.win32 = result.win32 ? `${result.win32};${win322}` : win322; + result.posix = result.posix ? `${result.posix}:${posix}` : posix; + result[i] = { win32: win322, posix }; } - return false; - }; - var checkStat = (stat, path10, options) => stat.isFile() && checkPathExt(path10, options); - } -}); - -// .yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/options.js -var require_options = __commonJS({ - ".yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/options.js"(exports2) { - "use strict"; - Object.defineProperty(exports2, "__esModule", { value: true }); + return result; + } + module2.exports = cmdShim2; } }); -// .yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/index.js -var require_cjs = __commonJS({ - ".yarn/cache/isexe-npm-3.1.1-9c0061eead-9ec2576540.zip/node_modules/isexe/dist/cjs/index.js"(exports2) { - "use strict"; - var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) { - if (k2 === void 0) k2 = k; - var desc = Object.getOwnPropertyDescriptor(m, k); - if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { - desc = { enumerable: true, get: function() { - return m[k]; - } }; +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/mode-fix.js +var modeFix; +var init_mode_fix = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/mode-fix.js"() { + modeFix = (mode, isDir, portable) => { + mode &= 4095; + if (portable) { + mode = (mode | 384) & ~18; } - Object.defineProperty(o, k2, desc); - } : function(o, m, k, k2) { - if (k2 === void 0) k2 = k; - o[k2] = m[k]; - }); - var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) { - Object.defineProperty(o, "default", { enumerable: true, value: v }); - } : function(o, v) { - o["default"] = v; - }); - var __importStar = exports2 && exports2.__importStar || function(mod) { - if (mod && mod.__esModule) return mod; - var result = {}; - if (mod != null) { - for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + if (isDir) { + if (mode & 256) { + mode |= 64; + } + if (mode & 32) { + mode |= 8; + } + if (mode & 4) { + mode |= 1; + } } - __setModuleDefault(result, mod); - return result; - }; - var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) { - for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p); + return mode; }; - Object.defineProperty(exports2, "__esModule", { value: true }); - exports2.sync = exports2.isexe = exports2.posix = exports2.win32 = void 0; - var posix = __importStar(require_posix()); - exports2.posix = posix; - var win32 = __importStar(require_win32()); - exports2.win32 = win32; - __exportStar(require_options(), exports2); - var platform = process.env._ISEXE_TEST_PLATFORM_ || process.platform; - var impl = platform === "win32" ? win32 : posix; - exports2.isexe = impl.isexe; - exports2.sync = impl.sync; } }); -// .yarn/cache/which-npm-4.0.0-dd31cd4928-449fa5c44e.zip/node_modules/which/lib/index.js -var require_lib = __commonJS({ - ".yarn/cache/which-npm-4.0.0-dd31cd4928-449fa5c44e.zip/node_modules/which/lib/index.js"(exports2, module2) { - var { isexe, sync: isexeSync } = require_cjs(); - var { join: join2, delimiter, sep, posix } = require("path"); - var isWindows = process.platform === "win32"; - var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1")); - var rRel = new RegExp(`^\\.${rSlash.source}`); - var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" }); - var getPathInfo = (cmd, { - path: optPath = process.env.PATH, - pathExt: optPathExt = process.env.PATHEXT, - delimiter: optDelimiter = delimiter - }) => { - const pathEnv = cmd.match(rSlash) ? [""] : [ - // windows always checks the cwd first - ...isWindows ? [process.cwd()] : [], - ...(optPath || /* istanbul ignore next: very unusual */ - "").split(optDelimiter) - ]; - if (isWindows) { - const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter); - const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]); - if (cmd.includes(".") && pathExt[0] !== "") { - pathExt.unshift(""); +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/write-entry.js +var import_fs14, import_path13, prefixPath, maxReadSize, PROCESS, FILE2, DIRECTORY2, SYMLINK2, HARDLINK2, HEADER, READ2, LSTAT, ONLSTAT, ONREAD, ONREADLINK, OPENFILE, ONOPENFILE, CLOSE, MODE, AWAITDRAIN, ONDRAIN, PREFIX, WriteEntry, WriteEntrySync, WriteEntryTar, getType; +var init_write_entry = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/write-entry.js"() { + import_fs14 = __toESM(require("fs"), 1); + init_esm(); + import_path13 = __toESM(require("path"), 1); + init_header(); + init_mode_fix(); + init_normalize_windows_path(); + init_options(); + init_pax(); + init_strip_absolute_path(); + init_strip_trailing_slashes(); + init_warn_method(); + init_winchars(); + prefixPath = (path16, prefix) => { + if (!prefix) { + return normalizeWindowsPath(path16); + } + path16 = normalizeWindowsPath(path16).replace(/^\.(\/|$)/, ""); + return stripTrailingSlashes(prefix) + "/" + path16; + }; + maxReadSize = 16 * 1024 * 1024; + PROCESS = Symbol("process"); + FILE2 = Symbol("file"); + DIRECTORY2 = Symbol("directory"); + SYMLINK2 = Symbol("symlink"); + HARDLINK2 = Symbol("hardlink"); + HEADER = Symbol("header"); + READ2 = Symbol("read"); + LSTAT = Symbol("lstat"); + ONLSTAT = Symbol("onlstat"); + ONREAD = Symbol("onread"); + ONREADLINK = Symbol("onreadlink"); + OPENFILE = Symbol("openfile"); + ONOPENFILE = Symbol("onopenfile"); + CLOSE = Symbol("close"); + MODE = Symbol("mode"); + AWAITDRAIN = Symbol("awaitDrain"); + ONDRAIN = Symbol("ondrain"); + PREFIX = Symbol("prefix"); + WriteEntry = class extends Minipass { + path; + portable; + myuid = process.getuid && process.getuid() || 0; + // until node has builtin pwnam functions, this'll have to do + myuser = process.env.USER || ""; + maxReadSize; + linkCache; + statCache; + preservePaths; + cwd; + strict; + mtime; + noPax; + noMtime; + prefix; + fd; + blockLen = 0; + blockRemain = 0; + buf; + pos = 0; + remain = 0; + length = 0; + offset = 0; + win32; + absolute; + header; + type; + linkpath; + stat; + /* c8 ignore start */ + #hadError = false; + constructor(p, opt_ = {}) { + const opt = dealias(opt_); + super(); + this.path = normalizeWindowsPath(p); + this.portable = !!opt.portable; + this.maxReadSize = opt.maxReadSize || maxReadSize; + this.linkCache = opt.linkCache || /* @__PURE__ */ new Map(); + this.statCache = opt.statCache || /* @__PURE__ */ new Map(); + this.preservePaths = !!opt.preservePaths; + this.cwd = normalizeWindowsPath(opt.cwd || process.cwd()); + this.strict = !!opt.strict; + this.noPax = !!opt.noPax; + this.noMtime = !!opt.noMtime; + this.mtime = opt.mtime; + this.prefix = opt.prefix ? normalizeWindowsPath(opt.prefix) : void 0; + if (typeof opt.onwarn === "function") { + this.on("warn", opt.onwarn); } - return { pathEnv, pathExt, pathExtExe }; - } - return { pathEnv, pathExt: [""] }; - }; - var getPathPart = (raw, cmd) => { - const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw; - const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : ""; - return prefix + join2(pathPart, cmd); - }; - var which3 = async (cmd, opt = {}) => { - const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt); - const found = []; - for (const envPart of pathEnv) { - const p = getPathPart(envPart, cmd); - for (const ext of pathExt) { - const withExt = p + ext; - const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true }); - if (is) { - if (!opt.all) { - return withExt; - } - found.push(withExt); + let pathWarn = false; + if (!this.preservePaths) { + const [root, stripped] = stripAbsolutePath(this.path); + if (root && typeof stripped === "string") { + this.path = stripped; + pathWarn = root; } } - } - if (opt.all && found.length) { - return found; - } - if (opt.nothrow) { - return null; - } - throw getNotFoundError(cmd); - }; - var whichSync = (cmd, opt = {}) => { - const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt); - const found = []; - for (const pathEnvPart of pathEnv) { - const p = getPathPart(pathEnvPart, cmd); - for (const ext of pathExt) { - const withExt = p + ext; - const is = isexeSync(withExt, { pathExt: pathExtExe, ignoreErrors: true }); - if (is) { - if (!opt.all) { - return withExt; - } - found.push(withExt); - } + this.win32 = !!opt.win32 || process.platform === "win32"; + if (this.win32) { + this.path = decode(this.path.replace(/\\/g, "/")); + p = p.replace(/\\/g, "/"); + } + this.absolute = normalizeWindowsPath(opt.absolute || import_path13.default.resolve(this.cwd, p)); + if (this.path === "") { + this.path = "./"; + } + if (pathWarn) { + this.warn("TAR_ENTRY_INFO", `stripping ${pathWarn} from absolute path`, { + entry: this, + path: pathWarn + this.path + }); + } + const cs = this.statCache.get(this.absolute); + if (cs) { + this[ONLSTAT](cs); + } else { + this[LSTAT](); } } - if (opt.all && found.length) { - return found; - } - if (opt.nothrow) { - return null; - } - throw getNotFoundError(cmd); - }; - module2.exports = which3; - which3.sync = whichSync; - } -}); - -// .yarn/cache/is-windows-npm-1.0.2-898cd6f3d7-b32f418ab3.zip/node_modules/is-windows/index.js -var require_is_windows = __commonJS({ - ".yarn/cache/is-windows-npm-1.0.2-898cd6f3d7-b32f418ab3.zip/node_modules/is-windows/index.js"(exports2, module2) { - (function(factory) { - if (exports2 && typeof exports2 === "object" && typeof module2 !== "undefined") { - module2.exports = factory(); - } else if (typeof define === "function" && define.amd) { - define([], factory); - } else if (typeof window !== "undefined") { - window.isWindows = factory(); - } else if (typeof global !== "undefined") { - global.isWindows = factory(); - } else if (typeof self !== "undefined") { - self.isWindows = factory(); - } else { - this.isWindows = factory(); - } - })(function() { - "use strict"; - return function isWindows() { - return process && (process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE)); - }; - }); - } -}); - -// .yarn/cache/cmd-extension-npm-1.0.2-11aa204c4b-acdb425d51.zip/node_modules/cmd-extension/index.js -var require_cmd_extension = __commonJS({ - ".yarn/cache/cmd-extension-npm-1.0.2-11aa204c4b-acdb425d51.zip/node_modules/cmd-extension/index.js"(exports2, module2) { - "use strict"; - var path10 = require("path"); - var cmdExtension; - if (process.env.PATHEXT) { - cmdExtension = process.env.PATHEXT.split(path10.delimiter).find((ext) => ext.toUpperCase() === ".CMD"); - } - module2.exports = cmdExtension || ".cmd"; - } -}); - -// .yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/polyfills.js -var require_polyfills = __commonJS({ - ".yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/polyfills.js"(exports2, module2) { - var constants = require("constants"); - var origCwd = process.cwd; - var cwd = null; - var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform; - process.cwd = function() { - if (!cwd) - cwd = origCwd.call(process); - return cwd; - }; - try { - process.cwd(); - } catch (er) { - } - if (typeof process.chdir === "function") { - chdir = process.chdir; - process.chdir = function(d) { - cwd = null; - chdir.call(process, d); - }; - if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir); - } - var chdir; - module2.exports = patch; - function patch(fs8) { - if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) { - patchLchmod(fs8); - } - if (!fs8.lutimes) { - patchLutimes(fs8); - } - fs8.chown = chownFix(fs8.chown); - fs8.fchown = chownFix(fs8.fchown); - fs8.lchown = chownFix(fs8.lchown); - fs8.chmod = chmodFix(fs8.chmod); - fs8.fchmod = chmodFix(fs8.fchmod); - fs8.lchmod = chmodFix(fs8.lchmod); - fs8.chownSync = chownFixSync(fs8.chownSync); - fs8.fchownSync = chownFixSync(fs8.fchownSync); - fs8.lchownSync = chownFixSync(fs8.lchownSync); - fs8.chmodSync = chmodFixSync(fs8.chmodSync); - fs8.fchmodSync = chmodFixSync(fs8.fchmodSync); - fs8.lchmodSync = chmodFixSync(fs8.lchmodSync); - fs8.stat = statFix(fs8.stat); - fs8.fstat = statFix(fs8.fstat); - fs8.lstat = statFix(fs8.lstat); - fs8.statSync = statFixSync(fs8.statSync); - fs8.fstatSync = statFixSync(fs8.fstatSync); - fs8.lstatSync = statFixSync(fs8.lstatSync); - if (fs8.chmod && !fs8.lchmod) { - fs8.lchmod = function(path10, mode, cb) { - if (cb) process.nextTick(cb); - }; - fs8.lchmodSync = function() { - }; + warn(code2, message, data = {}) { + return warnMethod(this, code2, message, data); } - if (fs8.chown && !fs8.lchown) { - fs8.lchown = function(path10, uid, gid, cb) { - if (cb) process.nextTick(cb); - }; - fs8.lchownSync = function() { - }; + emit(ev, ...data) { + if (ev === "error") { + this.#hadError = true; + } + return super.emit(ev, ...data); } - if (platform === "win32") { - fs8.rename = typeof fs8.rename !== "function" ? fs8.rename : function(fs$rename) { - function rename(from, to, cb) { - var start = Date.now(); - var backoff = 0; - fs$rename(from, to, function CB(er) { - if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) { - setTimeout(function() { - fs8.stat(to, function(stater, st) { - if (stater && stater.code === "ENOENT") - fs$rename(from, to, CB); - else - cb(er); - }); - }, backoff); - if (backoff < 100) - backoff += 10; - return; - } - if (cb) cb(er); - }); + [LSTAT]() { + import_fs14.default.lstat(this.absolute, (er, stat2) => { + if (er) { + return this.emit("error", er); } - if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename); - return rename; - }(fs8.rename); + this[ONLSTAT](stat2); + }); } - fs8.read = typeof fs8.read !== "function" ? fs8.read : function(fs$read) { - function read(fd, buffer, offset, length, position, callback_) { - var callback; - if (callback_ && typeof callback_ === "function") { - var eagCounter = 0; - callback = function(er, _, __) { - if (er && er.code === "EAGAIN" && eagCounter < 10) { - eagCounter++; - return fs$read.call(fs8, fd, buffer, offset, length, position, callback); - } - callback_.apply(this, arguments); - }; - } - return fs$read.call(fs8, fd, buffer, offset, length, position, callback); + [ONLSTAT](stat2) { + this.statCache.set(this.absolute, stat2); + this.stat = stat2; + if (!stat2.isFile()) { + stat2.size = 0; } - if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read); - return read; - }(fs8.read); - fs8.readSync = typeof fs8.readSync !== "function" ? fs8.readSync : /* @__PURE__ */ function(fs$readSync) { - return function(fd, buffer, offset, length, position) { - var eagCounter = 0; - while (true) { - try { - return fs$readSync.call(fs8, fd, buffer, offset, length, position); - } catch (er) { - if (er.code === "EAGAIN" && eagCounter < 10) { - eagCounter++; - continue; - } - throw er; - } - } - }; - }(fs8.readSync); - function patchLchmod(fs9) { - fs9.lchmod = function(path10, mode, callback) { - fs9.open( - path10, - constants.O_WRONLY | constants.O_SYMLINK, - mode, - function(err, fd) { - if (err) { - if (callback) callback(err); - return; - } - fs9.fchmod(fd, mode, function(err2) { - fs9.close(fd, function(err22) { - if (callback) callback(err2 || err22); - }); - }); - } - ); - }; - fs9.lchmodSync = function(path10, mode) { - var fd = fs9.openSync(path10, constants.O_WRONLY | constants.O_SYMLINK, mode); - var threw = true; - var ret; - try { - ret = fs9.fchmodSync(fd, mode); - threw = false; - } finally { - if (threw) { - try { - fs9.closeSync(fd); - } catch (er) { - } - } else { - fs9.closeSync(fd); - } - } - return ret; - }; + this.type = getType(stat2); + this.emit("stat", stat2); + this[PROCESS](); } - function patchLutimes(fs9) { - if (constants.hasOwnProperty("O_SYMLINK") && fs9.futimes) { - fs9.lutimes = function(path10, at, mt, cb) { - fs9.open(path10, constants.O_SYMLINK, function(er, fd) { - if (er) { - if (cb) cb(er); - return; - } - fs9.futimes(fd, at, mt, function(er2) { - fs9.close(fd, function(er22) { - if (cb) cb(er2 || er22); - }); - }); - }); - }; - fs9.lutimesSync = function(path10, at, mt) { - var fd = fs9.openSync(path10, constants.O_SYMLINK); - var ret; - var threw = true; - try { - ret = fs9.futimesSync(fd, at, mt); - threw = false; - } finally { - if (threw) { - try { - fs9.closeSync(fd); - } catch (er) { - } - } else { - fs9.closeSync(fd); - } - } - return ret; - }; - } else if (fs9.futimes) { - fs9.lutimes = function(_a, _b, _c, cb) { - if (cb) process.nextTick(cb); - }; - fs9.lutimesSync = function() { - }; + [PROCESS]() { + switch (this.type) { + case "File": + return this[FILE2](); + case "Directory": + return this[DIRECTORY2](); + case "SymbolicLink": + return this[SYMLINK2](); + default: + return this.end(); } } - function chmodFix(orig) { - if (!orig) return orig; - return function(target, mode, cb) { - return orig.call(fs8, target, mode, function(er) { - if (chownErOk(er)) er = null; - if (cb) cb.apply(this, arguments); - }); - }; + [MODE](mode) { + return modeFix(mode, this.type === "Directory", this.portable); } - function chmodFixSync(orig) { - if (!orig) return orig; - return function(target, mode) { - try { - return orig.call(fs8, target, mode); - } catch (er) { - if (!chownErOk(er)) throw er; - } - }; + [PREFIX](path16) { + return prefixPath(path16, this.prefix); } - function chownFix(orig) { - if (!orig) return orig; - return function(target, uid, gid, cb) { - return orig.call(fs8, target, uid, gid, function(er) { - if (chownErOk(er)) er = null; - if (cb) cb.apply(this, arguments); - }); - }; + [HEADER]() { + if (!this.stat) { + throw new Error("cannot write header before stat"); + } + if (this.type === "Directory" && this.portable) { + this.noMtime = true; + } + this.header = new Header({ + path: this[PREFIX](this.path), + // only apply the prefix to hard links. + linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath, + // only the permissions and setuid/setgid/sticky bitflags + // not the higher-order bits that specify file type + mode: this[MODE](this.stat.mode), + uid: this.portable ? void 0 : this.stat.uid, + gid: this.portable ? void 0 : this.stat.gid, + size: this.stat.size, + mtime: this.noMtime ? void 0 : this.mtime || this.stat.mtime, + /* c8 ignore next */ + type: this.type === "Unsupported" ? void 0 : this.type, + uname: this.portable ? void 0 : this.stat.uid === this.myuid ? this.myuser : "", + atime: this.portable ? void 0 : this.stat.atime, + ctime: this.portable ? void 0 : this.stat.ctime + }); + if (this.header.encode() && !this.noPax) { + super.write(new Pax({ + atime: this.portable ? void 0 : this.header.atime, + ctime: this.portable ? void 0 : this.header.ctime, + gid: this.portable ? void 0 : this.header.gid, + mtime: this.noMtime ? void 0 : this.mtime || this.header.mtime, + path: this[PREFIX](this.path), + linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath, + size: this.header.size, + uid: this.portable ? void 0 : this.header.uid, + uname: this.portable ? void 0 : this.header.uname, + dev: this.portable ? void 0 : this.stat.dev, + ino: this.portable ? void 0 : this.stat.ino, + nlink: this.portable ? void 0 : this.stat.nlink + }).encode()); + } + const block = this.header?.block; + if (!block) { + throw new Error("failed to encode header"); + } + super.write(block); } - function chownFixSync(orig) { - if (!orig) return orig; - return function(target, uid, gid) { - try { - return orig.call(fs8, target, uid, gid); - } catch (er) { - if (!chownErOk(er)) throw er; - } - }; + [DIRECTORY2]() { + if (!this.stat) { + throw new Error("cannot create directory entry without stat"); + } + if (this.path.slice(-1) !== "/") { + this.path += "/"; + } + this.stat.size = 0; + this[HEADER](); + this.end(); } - function statFix(orig) { - if (!orig) return orig; - return function(target, options, cb) { - if (typeof options === "function") { - cb = options; - options = null; - } - function callback(er, stats) { - if (stats) { - if (stats.uid < 0) stats.uid += 4294967296; - if (stats.gid < 0) stats.gid += 4294967296; - } - if (cb) cb.apply(this, arguments); + [SYMLINK2]() { + import_fs14.default.readlink(this.absolute, (er, linkpath) => { + if (er) { + return this.emit("error", er); } - return options ? orig.call(fs8, target, options, callback) : orig.call(fs8, target, callback); - }; + this[ONREADLINK](linkpath); + }); } - function statFixSync(orig) { - if (!orig) return orig; - return function(target, options) { - var stats = options ? orig.call(fs8, target, options) : orig.call(fs8, target); - if (stats) { - if (stats.uid < 0) stats.uid += 4294967296; - if (stats.gid < 0) stats.gid += 4294967296; - } - return stats; - }; + [ONREADLINK](linkpath) { + this.linkpath = normalizeWindowsPath(linkpath); + this[HEADER](); + this.end(); } - function chownErOk(er) { - if (!er) - return true; - if (er.code === "ENOSYS") - return true; - var nonroot = !process.getuid || process.getuid() !== 0; - if (nonroot) { - if (er.code === "EINVAL" || er.code === "EPERM") - return true; + [HARDLINK2](linkpath) { + if (!this.stat) { + throw new Error("cannot create link entry without stat"); } - return false; + this.type = "Link"; + this.linkpath = normalizeWindowsPath(import_path13.default.relative(this.cwd, linkpath)); + this.stat.size = 0; + this[HEADER](); + this.end(); } - } - } -}); - -// .yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/legacy-streams.js -var require_legacy_streams = __commonJS({ - ".yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/legacy-streams.js"(exports2, module2) { - var Stream = require("stream").Stream; - module2.exports = legacy; - function legacy(fs8) { - return { - ReadStream, - WriteStream - }; - function ReadStream(path10, options) { - if (!(this instanceof ReadStream)) return new ReadStream(path10, options); - Stream.call(this); - var self2 = this; - this.path = path10; - this.fd = null; - this.readable = true; - this.paused = false; - this.flags = "r"; - this.mode = 438; - this.bufferSize = 64 * 1024; - options = options || {}; - var keys = Object.keys(options); - for (var index = 0, length = keys.length; index < length; index++) { - var key = keys[index]; - this[key] = options[key]; + [FILE2]() { + if (!this.stat) { + throw new Error("cannot create file entry without stat"); } - if (this.encoding) this.setEncoding(this.encoding); - if (this.start !== void 0) { - if ("number" !== typeof this.start) { - throw TypeError("start must be a Number"); - } - if (this.end === void 0) { - this.end = Infinity; - } else if ("number" !== typeof this.end) { - throw TypeError("end must be a Number"); + if (this.stat.nlink > 1) { + const linkKey = `${this.stat.dev}:${this.stat.ino}`; + const linkpath = this.linkCache.get(linkKey); + if (linkpath?.indexOf(this.cwd) === 0) { + return this[HARDLINK2](linkpath); } - if (this.start > this.end) { - throw new Error("start must be <= end"); + this.linkCache.set(linkKey, this.absolute); + } + this[HEADER](); + if (this.stat.size === 0) { + return this.end(); + } + this[OPENFILE](); + } + [OPENFILE]() { + import_fs14.default.open(this.absolute, "r", (er, fd) => { + if (er) { + return this.emit("error", er); } - this.pos = this.start; + this[ONOPENFILE](fd); + }); + } + [ONOPENFILE](fd) { + this.fd = fd; + if (this.#hadError) { + return this[CLOSE](); } - if (this.fd !== null) { - process.nextTick(function() { - self2._read(); - }); - return; + if (!this.stat) { + throw new Error("should stat before calling onopenfile"); } - fs8.open(this.path, this.flags, this.mode, function(err, fd) { - if (err) { - self2.emit("error", err); - self2.readable = false; - return; + this.blockLen = 512 * Math.ceil(this.stat.size / 512); + this.blockRemain = this.blockLen; + const bufLen = Math.min(this.blockLen, this.maxReadSize); + this.buf = Buffer.allocUnsafe(bufLen); + this.offset = 0; + this.pos = 0; + this.remain = this.stat.size; + this.length = this.buf.length; + this[READ2](); + } + [READ2]() { + const { fd, buf, offset, length, pos: pos2 } = this; + if (fd === void 0 || buf === void 0) { + throw new Error("cannot read file without first opening"); + } + import_fs14.default.read(fd, buf, offset, length, pos2, (er, bytesRead) => { + if (er) { + return this[CLOSE](() => this.emit("error", er)); } - self2.fd = fd; - self2.emit("open", fd); - self2._read(); + this[ONREAD](bytesRead); }); } - function WriteStream(path10, options) { - if (!(this instanceof WriteStream)) return new WriteStream(path10, options); - Stream.call(this); - this.path = path10; - this.fd = null; - this.writable = true; - this.flags = "w"; - this.encoding = "binary"; - this.mode = 438; - this.bytesWritten = 0; - options = options || {}; - var keys = Object.keys(options); - for (var index = 0, length = keys.length; index < length; index++) { - var key = keys[index]; - this[key] = options[key]; + /* c8 ignore start */ + [CLOSE](cb = () => { + }) { + if (this.fd !== void 0) + import_fs14.default.close(this.fd, cb); + } + [ONREAD](bytesRead) { + if (bytesRead <= 0 && this.remain > 0) { + const er = Object.assign(new Error("encountered unexpected EOF"), { + path: this.absolute, + syscall: "read", + code: "EOF" + }); + return this[CLOSE](() => this.emit("error", er)); } - if (this.start !== void 0) { - if ("number" !== typeof this.start) { - throw TypeError("start must be a Number"); - } - if (this.start < 0) { - throw new Error("start must be >= zero"); + if (bytesRead > this.remain) { + const er = Object.assign(new Error("did not encounter expected EOF"), { + path: this.absolute, + syscall: "read", + code: "EOF" + }); + return this[CLOSE](() => this.emit("error", er)); + } + if (!this.buf) { + throw new Error("should have created buffer prior to reading"); + } + if (bytesRead === this.remain) { + for (let i = bytesRead; i < this.length && bytesRead < this.blockRemain; i++) { + this.buf[i + this.offset] = 0; + bytesRead++; + this.remain++; } - this.pos = this.start; } - this.busy = false; - this._queue = []; - if (this.fd === null) { - this._open = fs8.open; - this._queue.push([this._open, this.path, this.flags, this.mode, void 0]); - this.flush(); + const chunk = this.offset === 0 && bytesRead === this.buf.length ? this.buf : this.buf.subarray(this.offset, this.offset + bytesRead); + const flushed = this.write(chunk); + if (!flushed) { + this[AWAITDRAIN](() => this[ONDRAIN]()); + } else { + this[ONDRAIN](); } } - } - } -}); - -// .yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/clone.js -var require_clone = __commonJS({ - ".yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/clone.js"(exports2, module2) { - "use strict"; - module2.exports = clone; - var getPrototypeOf = Object.getPrototypeOf || function(obj) { - return obj.__proto__; - }; - function clone(obj) { - if (obj === null || typeof obj !== "object") - return obj; - if (obj instanceof Object) - var copy = { __proto__: getPrototypeOf(obj) }; - else - var copy = /* @__PURE__ */ Object.create(null); - Object.getOwnPropertyNames(obj).forEach(function(key) { - Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key)); - }); - return copy; - } - } -}); - -// .yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/graceful-fs.js -var require_graceful_fs = __commonJS({ - ".yarn/cache/graceful-fs-npm-4.2.11-24bb648a68-386d011a55.zip/node_modules/graceful-fs/graceful-fs.js"(exports2, module2) { - var fs8 = require("fs"); - var polyfills = require_polyfills(); - var legacy = require_legacy_streams(); - var clone = require_clone(); - var util = require("util"); - var gracefulQueue; - var previousSymbol; - if (typeof Symbol === "function" && typeof Symbol.for === "function") { - gracefulQueue = Symbol.for("graceful-fs.queue"); - previousSymbol = Symbol.for("graceful-fs.previous"); - } else { - gracefulQueue = "___graceful-fs.queue"; - previousSymbol = "___graceful-fs.previous"; - } - function noop() { - } - function publishQueue(context, queue2) { - Object.defineProperty(context, gracefulQueue, { - get: function() { - return queue2; + [AWAITDRAIN](cb) { + this.once("drain", cb); + } + write(chunk, encoding, cb) { + if (typeof encoding === "function") { + cb = encoding; + encoding = void 0; } - }); - } - var debug2 = noop; - if (util.debuglog) - debug2 = util.debuglog("gfs4"); - else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) - debug2 = function() { - var m = util.format.apply(util, arguments); - m = "GFS4: " + m.split(/\n/).join("\nGFS4: "); - console.error(m); - }; - if (!fs8[gracefulQueue]) { - queue = global[gracefulQueue] || []; - publishQueue(fs8, queue); - fs8.close = function(fs$close) { - function close(fd, cb) { - return fs$close.call(fs8, fd, function(err) { - if (!err) { - resetQueue(); - } - if (typeof cb === "function") - cb.apply(this, arguments); + if (typeof chunk === "string") { + chunk = Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8"); + } + if (this.blockRemain < chunk.length) { + const er = Object.assign(new Error("writing more data than expected"), { + path: this.absolute }); + return this.emit("error", er); } - Object.defineProperty(close, previousSymbol, { - value: fs$close - }); - return close; - }(fs8.close); - fs8.closeSync = function(fs$closeSync) { - function closeSync(fd) { - fs$closeSync.apply(fs8, arguments); - resetQueue(); + this.remain -= chunk.length; + this.blockRemain -= chunk.length; + this.pos += chunk.length; + this.offset += chunk.length; + return super.write(chunk, null, cb); + } + [ONDRAIN]() { + if (!this.remain) { + if (this.blockRemain) { + super.write(Buffer.alloc(this.blockRemain)); + } + return this[CLOSE]((er) => er ? this.emit("error", er) : this.end()); } - Object.defineProperty(closeSync, previousSymbol, { - value: fs$closeSync - }); - return closeSync; - }(fs8.closeSync); - if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) { - process.on("exit", function() { - debug2(fs8[gracefulQueue]); - require("assert").equal(fs8[gracefulQueue].length, 0); - }); + if (!this.buf) { + throw new Error("buffer lost somehow in ONDRAIN"); + } + if (this.offset >= this.length) { + this.buf = Buffer.allocUnsafe(Math.min(this.blockRemain, this.buf.length)); + this.offset = 0; + } + this.length = this.buf.length - this.offset; + this[READ2](); } - } - var queue; - if (!global[gracefulQueue]) { - publishQueue(global, fs8[gracefulQueue]); - } - module2.exports = patch(clone(fs8)); - if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs8.__patched) { - module2.exports = patch(fs8); - fs8.__patched = true; - } - function patch(fs9) { - polyfills(fs9); - fs9.gracefulify = patch; - fs9.createReadStream = createReadStream; - fs9.createWriteStream = createWriteStream; - var fs$readFile = fs9.readFile; - fs9.readFile = readFile; - function readFile(path10, options, cb) { - if (typeof options === "function") - cb = options, options = null; - return go$readFile(path10, options, cb); - function go$readFile(path11, options2, cb2, startTime) { - return fs$readFile(path11, options2, function(err) { - if (err && (err.code === "EMFILE" || err.code === "ENFILE")) - enqueue([go$readFile, [path11, options2, cb2], err, startTime || Date.now(), Date.now()]); - else { - if (typeof cb2 === "function") - cb2.apply(this, arguments); + }; + WriteEntrySync = class extends WriteEntry { + sync = true; + [LSTAT]() { + this[ONLSTAT](import_fs14.default.lstatSync(this.absolute)); + } + [SYMLINK2]() { + this[ONREADLINK](import_fs14.default.readlinkSync(this.absolute)); + } + [OPENFILE]() { + this[ONOPENFILE](import_fs14.default.openSync(this.absolute, "r")); + } + [READ2]() { + let threw = true; + try { + const { fd, buf, offset, length, pos: pos2 } = this; + if (fd === void 0 || buf === void 0) { + throw new Error("fd and buf must be set in READ method"); + } + const bytesRead = import_fs14.default.readSync(fd, buf, offset, length, pos2); + this[ONREAD](bytesRead); + threw = false; + } finally { + if (threw) { + try { + this[CLOSE](() => { + }); + } catch (er) { } - }); + } } } - var fs$writeFile = fs9.writeFile; - fs9.writeFile = writeFile; - function writeFile(path10, data, options, cb) { - if (typeof options === "function") - cb = options, options = null; - return go$writeFile(path10, data, options, cb); - function go$writeFile(path11, data2, options2, cb2, startTime) { - return fs$writeFile(path11, data2, options2, function(err) { - if (err && (err.code === "EMFILE" || err.code === "ENFILE")) - enqueue([go$writeFile, [path11, data2, options2, cb2], err, startTime || Date.now(), Date.now()]); - else { - if (typeof cb2 === "function") - cb2.apply(this, arguments); - } + [AWAITDRAIN](cb) { + cb(); + } + /* c8 ignore start */ + [CLOSE](cb = () => { + }) { + if (this.fd !== void 0) + import_fs14.default.closeSync(this.fd); + cb(); + } + }; + WriteEntryTar = class extends Minipass { + blockLen = 0; + blockRemain = 0; + buf = 0; + pos = 0; + remain = 0; + length = 0; + preservePaths; + portable; + strict; + noPax; + noMtime; + readEntry; + type; + prefix; + path; + mode; + uid; + gid; + uname; + gname; + header; + mtime; + atime; + ctime; + linkpath; + size; + warn(code2, message, data = {}) { + return warnMethod(this, code2, message, data); + } + constructor(readEntry, opt_ = {}) { + const opt = dealias(opt_); + super(); + this.preservePaths = !!opt.preservePaths; + this.portable = !!opt.portable; + this.strict = !!opt.strict; + this.noPax = !!opt.noPax; + this.noMtime = !!opt.noMtime; + this.readEntry = readEntry; + const { type } = readEntry; + if (type === "Unsupported") { + throw new Error("writing entry that should be ignored"); + } + this.type = type; + if (this.type === "Directory" && this.portable) { + this.noMtime = true; + } + this.prefix = opt.prefix; + this.path = normalizeWindowsPath(readEntry.path); + this.mode = readEntry.mode !== void 0 ? this[MODE](readEntry.mode) : void 0; + this.uid = this.portable ? void 0 : readEntry.uid; + this.gid = this.portable ? void 0 : readEntry.gid; + this.uname = this.portable ? void 0 : readEntry.uname; + this.gname = this.portable ? void 0 : readEntry.gname; + this.size = readEntry.size; + this.mtime = this.noMtime ? void 0 : opt.mtime || readEntry.mtime; + this.atime = this.portable ? void 0 : readEntry.atime; + this.ctime = this.portable ? void 0 : readEntry.ctime; + this.linkpath = readEntry.linkpath !== void 0 ? normalizeWindowsPath(readEntry.linkpath) : void 0; + if (typeof opt.onwarn === "function") { + this.on("warn", opt.onwarn); + } + let pathWarn = false; + if (!this.preservePaths) { + const [root, stripped] = stripAbsolutePath(this.path); + if (root && typeof stripped === "string") { + this.path = stripped; + pathWarn = root; + } + } + this.remain = readEntry.size; + this.blockRemain = readEntry.startBlockSize; + this.header = new Header({ + path: this[PREFIX](this.path), + linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath, + // only the permissions and setuid/setgid/sticky bitflags + // not the higher-order bits that specify file type + mode: this.mode, + uid: this.portable ? void 0 : this.uid, + gid: this.portable ? void 0 : this.gid, + size: this.size, + mtime: this.noMtime ? void 0 : this.mtime, + type: this.type, + uname: this.portable ? void 0 : this.uname, + atime: this.portable ? void 0 : this.atime, + ctime: this.portable ? void 0 : this.ctime + }); + if (pathWarn) { + this.warn("TAR_ENTRY_INFO", `stripping ${pathWarn} from absolute path`, { + entry: this, + path: pathWarn + this.path }); } + if (this.header.encode() && !this.noPax) { + super.write(new Pax({ + atime: this.portable ? void 0 : this.atime, + ctime: this.portable ? void 0 : this.ctime, + gid: this.portable ? void 0 : this.gid, + mtime: this.noMtime ? void 0 : this.mtime, + path: this[PREFIX](this.path), + linkpath: this.type === "Link" && this.linkpath !== void 0 ? this[PREFIX](this.linkpath) : this.linkpath, + size: this.size, + uid: this.portable ? void 0 : this.uid, + uname: this.portable ? void 0 : this.uname, + dev: this.portable ? void 0 : this.readEntry.dev, + ino: this.portable ? void 0 : this.readEntry.ino, + nlink: this.portable ? void 0 : this.readEntry.nlink + }).encode()); + } + const b = this.header?.block; + if (!b) + throw new Error("failed to encode header"); + super.write(b); + readEntry.pipe(this); } - var fs$appendFile = fs9.appendFile; - if (fs$appendFile) - fs9.appendFile = appendFile; - function appendFile(path10, data, options, cb) { - if (typeof options === "function") - cb = options, options = null; - return go$appendFile(path10, data, options, cb); - function go$appendFile(path11, data2, options2, cb2, startTime) { - return fs$appendFile(path11, data2, options2, function(err) { - if (err && (err.code === "EMFILE" || err.code === "ENFILE")) - enqueue([go$appendFile, [path11, data2, options2, cb2], err, startTime || Date.now(), Date.now()]); - else { - if (typeof cb2 === "function") - cb2.apply(this, arguments); - } - }); + [PREFIX](path16) { + return prefixPath(path16, this.prefix); + } + [MODE](mode) { + return modeFix(mode, this.type === "Directory", this.portable); + } + write(chunk, encoding, cb) { + if (typeof encoding === "function") { + cb = encoding; + encoding = void 0; + } + if (typeof chunk === "string") { + chunk = Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8"); + } + const writeLen = chunk.length; + if (writeLen > this.blockRemain) { + throw new Error("writing more to entry than is appropriate"); } + this.blockRemain -= writeLen; + return super.write(chunk, cb); } - var fs$copyFile = fs9.copyFile; - if (fs$copyFile) - fs9.copyFile = copyFile; - function copyFile(src, dest, flags, cb) { - if (typeof flags === "function") { - cb = flags; - flags = 0; + end(chunk, encoding, cb) { + if (this.blockRemain) { + super.write(Buffer.alloc(this.blockRemain)); } - return go$copyFile(src, dest, flags, cb); - function go$copyFile(src2, dest2, flags2, cb2, startTime) { - return fs$copyFile(src2, dest2, flags2, function(err) { - if (err && (err.code === "EMFILE" || err.code === "ENFILE")) - enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]); - else { - if (typeof cb2 === "function") - cb2.apply(this, arguments); - } - }); + if (typeof chunk === "function") { + cb = chunk; + encoding = void 0; + chunk = void 0; } + if (typeof encoding === "function") { + cb = encoding; + encoding = void 0; + } + if (typeof chunk === "string") { + chunk = Buffer.from(chunk, encoding ?? "utf8"); + } + if (cb) + this.once("finish", cb); + chunk ? super.end(chunk, cb) : super.end(cb); + return this; } - var fs$readdir = fs9.readdir; - fs9.readdir = readdir; - var noReaddirOptionVersions = /^v[0-5]\./; - function readdir(path10, options, cb) { - if (typeof options === "function") - cb = options, options = null; - var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path11, options2, cb2, startTime) { - return fs$readdir(path11, fs$readdirCallback( - path11, - options2, - cb2, - startTime - )); - } : function go$readdir2(path11, options2, cb2, startTime) { - return fs$readdir(path11, options2, fs$readdirCallback( - path11, - options2, - cb2, - startTime - )); - }; - return go$readdir(path10, options, cb); - function fs$readdirCallback(path11, options2, cb2, startTime) { - return function(err, files) { - if (err && (err.code === "EMFILE" || err.code === "ENFILE")) - enqueue([ - go$readdir, - [path11, options2, cb2], - err, - startTime || Date.now(), - Date.now() - ]); - else { - if (files && files.sort) - files.sort(); - if (typeof cb2 === "function") - cb2.call(this, err, files); + }; + getType = (stat2) => stat2.isFile() ? "File" : stat2.isDirectory() ? "Directory" : stat2.isSymbolicLink() ? "SymbolicLink" : "Unsupported"; + } +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/pack.js +var import_fs15, import_path14, PackJob, EOF2, ONSTAT, ENDED3, QUEUE2, CURRENT, PROCESS2, PROCESSING, PROCESSJOB, JOBS, JOBDONE, ADDFSENTRY, ADDTARENTRY, STAT, READDIR, ONREADDIR, PIPE, ENTRY, ENTRYOPT, WRITEENTRYCLASS, WRITE, ONDRAIN2, Pack, PackSync; +var init_pack = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/pack.js"() { + import_fs15 = __toESM(require("fs"), 1); + init_write_entry(); + init_esm(); + init_esm3(); + init_esm4(); + init_read_entry(); + init_warn_method(); + import_path14 = __toESM(require("path"), 1); + init_normalize_windows_path(); + PackJob = class { + path; + absolute; + entry; + stat; + readdir; + pending = false; + ignore = false; + piped = false; + constructor(path16, absolute) { + this.path = path16 || "./"; + this.absolute = absolute; + } + }; + EOF2 = Buffer.alloc(1024); + ONSTAT = Symbol("onStat"); + ENDED3 = Symbol("ended"); + QUEUE2 = Symbol("queue"); + CURRENT = Symbol("current"); + PROCESS2 = Symbol("process"); + PROCESSING = Symbol("processing"); + PROCESSJOB = Symbol("processJob"); + JOBS = Symbol("jobs"); + JOBDONE = Symbol("jobDone"); + ADDFSENTRY = Symbol("addFSEntry"); + ADDTARENTRY = Symbol("addTarEntry"); + STAT = Symbol("stat"); + READDIR = Symbol("readdir"); + ONREADDIR = Symbol("onreaddir"); + PIPE = Symbol("pipe"); + ENTRY = Symbol("entry"); + ENTRYOPT = Symbol("entryOpt"); + WRITEENTRYCLASS = Symbol("writeEntryClass"); + WRITE = Symbol("write"); + ONDRAIN2 = Symbol("ondrain"); + Pack = class extends Minipass { + opt; + cwd; + maxReadSize; + preservePaths; + strict; + noPax; + prefix; + linkCache; + statCache; + file; + portable; + zip; + readdirCache; + noDirRecurse; + follow; + noMtime; + mtime; + filter; + jobs; + [WRITEENTRYCLASS]; + onWriteEntry; + [QUEUE2]; + [JOBS] = 0; + [PROCESSING] = false; + [ENDED3] = false; + constructor(opt = {}) { + super(); + this.opt = opt; + this.file = opt.file || ""; + this.cwd = opt.cwd || process.cwd(); + this.maxReadSize = opt.maxReadSize; + this.preservePaths = !!opt.preservePaths; + this.strict = !!opt.strict; + this.noPax = !!opt.noPax; + this.prefix = normalizeWindowsPath(opt.prefix || ""); + this.linkCache = opt.linkCache || /* @__PURE__ */ new Map(); + this.statCache = opt.statCache || /* @__PURE__ */ new Map(); + this.readdirCache = opt.readdirCache || /* @__PURE__ */ new Map(); + this.onWriteEntry = opt.onWriteEntry; + this[WRITEENTRYCLASS] = WriteEntry; + if (typeof opt.onwarn === "function") { + this.on("warn", opt.onwarn); + } + this.portable = !!opt.portable; + if (opt.gzip || opt.brotli) { + if (opt.gzip && opt.brotli) { + throw new TypeError("gzip and brotli are mutually exclusive"); + } + if (opt.gzip) { + if (typeof opt.gzip !== "object") { + opt.gzip = {}; } - }; + if (this.portable) { + opt.gzip.portable = true; + } + this.zip = new Gzip(opt.gzip); + } + if (opt.brotli) { + if (typeof opt.brotli !== "object") { + opt.brotli = {}; + } + this.zip = new BrotliCompress(opt.brotli); + } + if (!this.zip) + throw new Error("impossible"); + const zip = this.zip; + zip.on("data", (chunk) => super.write(chunk)); + zip.on("end", () => super.end()); + zip.on("drain", () => this[ONDRAIN2]()); + this.on("resume", () => zip.resume()); + } else { + this.on("drain", this[ONDRAIN2]); } + this.noDirRecurse = !!opt.noDirRecurse; + this.follow = !!opt.follow; + this.noMtime = !!opt.noMtime; + if (opt.mtime) + this.mtime = opt.mtime; + this.filter = typeof opt.filter === "function" ? opt.filter : () => true; + this[QUEUE2] = new Yallist(); + this[JOBS] = 0; + this.jobs = Number(opt.jobs) || 4; + this[PROCESSING] = false; + this[ENDED3] = false; } - if (process.version.substr(0, 4) === "v0.8") { - var legStreams = legacy(fs9); - ReadStream = legStreams.ReadStream; - WriteStream = legStreams.WriteStream; + [WRITE](chunk) { + return super.write(chunk); } - var fs$ReadStream = fs9.ReadStream; - if (fs$ReadStream) { - ReadStream.prototype = Object.create(fs$ReadStream.prototype); - ReadStream.prototype.open = ReadStream$open; + add(path16) { + this.write(path16); + return this; } - var fs$WriteStream = fs9.WriteStream; - if (fs$WriteStream) { - WriteStream.prototype = Object.create(fs$WriteStream.prototype); - WriteStream.prototype.open = WriteStream$open; + //@ts-ignore + end(path16) { + if (path16) { + this.add(path16); + } + this[ENDED3] = true; + this[PROCESS2](); + return this; } - Object.defineProperty(fs9, "ReadStream", { - get: function() { - return ReadStream; - }, - set: function(val) { - ReadStream = val; - }, - enumerable: true, - configurable: true - }); - Object.defineProperty(fs9, "WriteStream", { - get: function() { - return WriteStream; - }, - set: function(val) { - WriteStream = val; - }, - enumerable: true, - configurable: true - }); - var FileReadStream = ReadStream; - Object.defineProperty(fs9, "FileReadStream", { - get: function() { - return FileReadStream; - }, - set: function(val) { - FileReadStream = val; - }, - enumerable: true, - configurable: true - }); - var FileWriteStream = WriteStream; - Object.defineProperty(fs9, "FileWriteStream", { - get: function() { - return FileWriteStream; - }, - set: function(val) { - FileWriteStream = val; - }, - enumerable: true, - configurable: true - }); - function ReadStream(path10, options) { - if (this instanceof ReadStream) - return fs$ReadStream.apply(this, arguments), this; - else - return ReadStream.apply(Object.create(ReadStream.prototype), arguments); + //@ts-ignore + write(path16) { + if (this[ENDED3]) { + throw new Error("write after end"); + } + if (path16 instanceof ReadEntry) { + this[ADDTARENTRY](path16); + } else { + this[ADDFSENTRY](path16); + } + return this.flowing; } - function ReadStream$open() { - var that = this; - open(that.path, that.flags, that.mode, function(err, fd) { - if (err) { - if (that.autoClose) - that.destroy(); - that.emit("error", err); - } else { - that.fd = fd; - that.emit("open", fd); - that.read(); - } - }); + [ADDTARENTRY](p) { + const absolute = normalizeWindowsPath(import_path14.default.resolve(this.cwd, p.path)); + if (!this.filter(p.path, p)) { + p.resume(); + } else { + const job = new PackJob(p.path, absolute); + job.entry = new WriteEntryTar(p, this[ENTRYOPT](job)); + job.entry.on("end", () => this[JOBDONE](job)); + this[JOBS] += 1; + this[QUEUE2].push(job); + } + this[PROCESS2](); } - function WriteStream(path10, options) { - if (this instanceof WriteStream) - return fs$WriteStream.apply(this, arguments), this; - else - return WriteStream.apply(Object.create(WriteStream.prototype), arguments); + [ADDFSENTRY](p) { + const absolute = normalizeWindowsPath(import_path14.default.resolve(this.cwd, p)); + this[QUEUE2].push(new PackJob(p, absolute)); + this[PROCESS2](); } - function WriteStream$open() { - var that = this; - open(that.path, that.flags, that.mode, function(err, fd) { - if (err) { - that.destroy(); - that.emit("error", err); + [STAT](job) { + job.pending = true; + this[JOBS] += 1; + const stat2 = this.follow ? "stat" : "lstat"; + import_fs15.default[stat2](job.absolute, (er, stat3) => { + job.pending = false; + this[JOBS] -= 1; + if (er) { + this.emit("error", er); } else { - that.fd = fd; - that.emit("open", fd); + this[ONSTAT](job, stat3); } }); } - function createReadStream(path10, options) { - return new fs9.ReadStream(path10, options); - } - function createWriteStream(path10, options) { - return new fs9.WriteStream(path10, options); - } - var fs$open = fs9.open; - fs9.open = open; - function open(path10, flags, mode, cb) { - if (typeof mode === "function") - cb = mode, mode = null; - return go$open(path10, flags, mode, cb); - function go$open(path11, flags2, mode2, cb2, startTime) { - return fs$open(path11, flags2, mode2, function(err, fd) { - if (err && (err.code === "EMFILE" || err.code === "ENFILE")) - enqueue([go$open, [path11, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]); - else { - if (typeof cb2 === "function") - cb2.apply(this, arguments); - } - }); - } - } - return fs9; - } - function enqueue(elem) { - debug2("ENQUEUE", elem[0].name, elem[1]); - fs8[gracefulQueue].push(elem); - retry(); - } - var retryTimer; - function resetQueue() { - var now = Date.now(); - for (var i = 0; i < fs8[gracefulQueue].length; ++i) { - if (fs8[gracefulQueue][i].length > 2) { - fs8[gracefulQueue][i][3] = now; - fs8[gracefulQueue][i][4] = now; + [ONSTAT](job, stat2) { + this.statCache.set(job.absolute, stat2); + job.stat = stat2; + if (!this.filter(job.path, stat2)) { + job.ignore = true; } + this[PROCESS2](); } - retry(); - } - function retry() { - clearTimeout(retryTimer); - retryTimer = void 0; - if (fs8[gracefulQueue].length === 0) - return; - var elem = fs8[gracefulQueue].shift(); - var fn2 = elem[0]; - var args = elem[1]; - var err = elem[2]; - var startTime = elem[3]; - var lastTime = elem[4]; - if (startTime === void 0) { - debug2("RETRY", fn2.name, args); - fn2.apply(null, args); - } else if (Date.now() - startTime >= 6e4) { - debug2("TIMEOUT", fn2.name, args); - var cb = args.pop(); - if (typeof cb === "function") - cb.call(null, err); - } else { - var sinceAttempt = Date.now() - lastTime; - var sinceStart = Math.max(lastTime - startTime, 1); - var desiredDelay = Math.min(sinceStart * 1.2, 100); - if (sinceAttempt >= desiredDelay) { - debug2("RETRY", fn2.name, args); - fn2.apply(null, args.concat([startTime])); - } else { - fs8[gracefulQueue].push(elem); - } + [READDIR](job) { + job.pending = true; + this[JOBS] += 1; + import_fs15.default.readdir(job.absolute, (er, entries) => { + job.pending = false; + this[JOBS] -= 1; + if (er) { + return this.emit("error", er); + } + this[ONREADDIR](job, entries); + }); } - if (retryTimer === void 0) { - retryTimer = setTimeout(retry, 0); + [ONREADDIR](job, entries) { + this.readdirCache.set(job.absolute, entries); + job.readdir = entries; + this[PROCESS2](); } - } - } -}); - -// .yarn/cache/@zkochan-cmd-shim-npm-6.0.0-97792a7373-ba1442ba1e.zip/node_modules/@zkochan/cmd-shim/index.js -var require_cmd_shim = __commonJS({ - ".yarn/cache/@zkochan-cmd-shim-npm-6.0.0-97792a7373-ba1442ba1e.zip/node_modules/@zkochan/cmd-shim/index.js"(exports2, module2) { - "use strict"; - cmdShim2.ifExists = cmdShimIfExists; - var util_1 = require("util"); - var path10 = require("path"); - var isWindows = require_is_windows(); - var CMD_EXTENSION = require_cmd_extension(); - var shebangExpr = /^#!\s*(?:\/usr\/bin\/env(?:\s+-S\s*)?)?\s*([^ \t]+)(.*)$/; - var DEFAULT_OPTIONS = { - // Create PowerShell file by default if the option hasn't been specified - createPwshFile: true, - createCmdFile: isWindows(), - fs: require_graceful_fs() - }; - var extensionToProgramMap = /* @__PURE__ */ new Map([ - [".js", "node"], - [".cjs", "node"], - [".mjs", "node"], - [".cmd", "cmd"], - [".bat", "cmd"], - [".ps1", "pwsh"], - [".sh", "sh"] - ]); - function ingestOptions(opts) { - const opts_ = { ...DEFAULT_OPTIONS, ...opts }; - const fs8 = opts_.fs; - opts_.fs_ = { - chmod: fs8.chmod ? (0, util_1.promisify)(fs8.chmod) : async () => { - }, - mkdir: (0, util_1.promisify)(fs8.mkdir), - readFile: (0, util_1.promisify)(fs8.readFile), - stat: (0, util_1.promisify)(fs8.stat), - unlink: (0, util_1.promisify)(fs8.unlink), - writeFile: (0, util_1.promisify)(fs8.writeFile) - }; - return opts_; - } - async function cmdShim2(src, to, opts) { - const opts_ = ingestOptions(opts); - await cmdShim_(src, to, opts_); - } - function cmdShimIfExists(src, to, opts) { - return cmdShim2(src, to, opts).catch(() => { - }); - } - function rm(path11, opts) { - return opts.fs_.unlink(path11).catch(() => { - }); - } - async function cmdShim_(src, to, opts) { - const srcRuntimeInfo = await searchScriptRuntime(src, opts); - await writeShimsPreCommon(to, opts); - return writeAllShims(src, to, srcRuntimeInfo, opts); - } - function writeShimsPreCommon(target, opts) { - return opts.fs_.mkdir(path10.dirname(target), { recursive: true }); - } - function writeAllShims(src, to, srcRuntimeInfo, opts) { - const opts_ = ingestOptions(opts); - const generatorAndExts = [{ generator: generateShShim, extension: "" }]; - if (opts_.createCmdFile) { - generatorAndExts.push({ generator: generateCmdShim, extension: CMD_EXTENSION }); + [PROCESS2]() { + if (this[PROCESSING]) { + return; + } + this[PROCESSING] = true; + for (let w = this[QUEUE2].head; !!w && this[JOBS] < this.jobs; w = w.next) { + this[PROCESSJOB](w.value); + if (w.value.ignore) { + const p = w.next; + this[QUEUE2].removeNode(w); + w.next = p; + } + } + this[PROCESSING] = false; + if (this[ENDED3] && !this[QUEUE2].length && this[JOBS] === 0) { + if (this.zip) { + this.zip.end(EOF2); + } else { + super.write(EOF2); + super.end(); + } + } } - if (opts_.createPwshFile) { - generatorAndExts.push({ generator: generatePwshShim, extension: ".ps1" }); + get [CURRENT]() { + return this[QUEUE2] && this[QUEUE2].head && this[QUEUE2].head.value; } - return Promise.all(generatorAndExts.map((generatorAndExt) => writeShim(src, to + generatorAndExt.extension, srcRuntimeInfo, generatorAndExt.generator, opts_))); - } - function writeShimPre(target, opts) { - return rm(target, opts); - } - function writeShimPost(target, opts) { - return chmodShim(target, opts); - } - async function searchScriptRuntime(target, opts) { - try { - const data = await opts.fs_.readFile(target, "utf8"); - const firstLine = data.trim().split(/\r*\n/)[0]; - const shebang = firstLine.match(shebangExpr); - if (!shebang) { - const targetExtension = path10.extname(target).toLowerCase(); - return { - // undefined if extension is unknown but it's converted to null. - program: extensionToProgramMap.get(targetExtension) || null, - additionalArgs: "" - }; + [JOBDONE](_job) { + this[QUEUE2].shift(); + this[JOBS] -= 1; + this[PROCESS2](); + } + [PROCESSJOB](job) { + if (job.pending) { + return; } - return { - program: shebang[1], - additionalArgs: shebang[2] - }; - } catch (err) { - if (!isWindows() || err.code !== "ENOENT") - throw err; - if (await opts.fs_.stat(`${target}${getExeExtension()}`)) { - return { - program: null, - additionalArgs: "" - }; + if (job.entry) { + if (job === this[CURRENT] && !job.piped) { + this[PIPE](job); + } + return; + } + if (!job.stat) { + const sc = this.statCache.get(job.absolute); + if (sc) { + this[ONSTAT](job, sc); + } else { + this[STAT](job); + } + } + if (!job.stat) { + return; + } + if (job.ignore) { + return; + } + if (!this.noDirRecurse && job.stat.isDirectory() && !job.readdir) { + const rc = this.readdirCache.get(job.absolute); + if (rc) { + this[ONREADDIR](job, rc); + } else { + this[READDIR](job); + } + if (!job.readdir) { + return; + } + } + job.entry = this[ENTRY](job); + if (!job.entry) { + job.ignore = true; + return; + } + if (job === this[CURRENT] && !job.piped) { + this[PIPE](job); } - throw err; - } - } - function getExeExtension() { - let cmdExtension; - if (process.env.PATHEXT) { - cmdExtension = process.env.PATHEXT.split(path10.delimiter).find((ext) => ext.toLowerCase() === ".exe"); } - return cmdExtension || ".exe"; - } - async function writeShim(src, to, srcRuntimeInfo, generateShimScript, opts) { - const defaultArgs = opts.preserveSymlinks ? "--preserve-symlinks" : ""; - const args = [srcRuntimeInfo.additionalArgs, defaultArgs].filter((arg) => arg).join(" "); - opts = Object.assign({}, opts, { - prog: srcRuntimeInfo.program, - args - }); - await writeShimPre(to, opts); - await opts.fs_.writeFile(to, generateShimScript(src, to, opts), "utf8"); - return writeShimPost(to, opts); - } - function generateCmdShim(src, to, opts) { - const shTarget = path10.relative(path10.dirname(to), src); - let target = shTarget.split("/").join("\\"); - const quotedPathToTarget = path10.isAbsolute(target) ? `"${target}"` : `"%~dp0\\${target}"`; - let longProg; - let prog = opts.prog; - let args = opts.args || ""; - const nodePath = normalizePathEnvVar(opts.nodePath).win32; - const prependToPath = normalizePathEnvVar(opts.prependToPath).win32; - if (!prog) { - prog = quotedPathToTarget; - args = ""; - target = ""; - } else if (prog === "node" && opts.nodeExecPath) { - prog = `"${opts.nodeExecPath}"`; - target = quotedPathToTarget; - } else { - longProg = `"%~dp0\\${prog}.exe"`; - target = quotedPathToTarget; + [ENTRYOPT](job) { + return { + onwarn: (code2, msg, data) => this.warn(code2, msg, data), + noPax: this.noPax, + cwd: this.cwd, + absolute: job.absolute, + preservePaths: this.preservePaths, + maxReadSize: this.maxReadSize, + strict: this.strict, + portable: this.portable, + linkCache: this.linkCache, + statCache: this.statCache, + noMtime: this.noMtime, + mtime: this.mtime, + prefix: this.prefix + }; } - let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : ""; - let cmd = "@SETLOCAL\r\n"; - if (prependToPath) { - cmd += `@SET "PATH=${prependToPath}:%PATH%"\r -`; + [ENTRY](job) { + this[JOBS] += 1; + try { + const e = new this[WRITEENTRYCLASS](job.path, this[ENTRYOPT](job)); + this.onWriteEntry?.(e); + return e.on("end", () => this[JOBDONE](job)).on("error", (er) => this.emit("error", er)); + } catch (er) { + this.emit("error", er); + } } - if (nodePath) { - cmd += `@IF NOT DEFINED NODE_PATH (\r - @SET "NODE_PATH=${nodePath}"\r -) ELSE (\r - @SET "NODE_PATH=${nodePath};%NODE_PATH%"\r -)\r -`; + [ONDRAIN2]() { + if (this[CURRENT] && this[CURRENT].entry) { + this[CURRENT].entry.resume(); + } } - if (longProg) { - cmd += `@IF EXIST ${longProg} (\r - ${longProg} ${args} ${target} ${progArgs}%*\r -) ELSE (\r - @SET PATHEXT=%PATHEXT:;.JS;=;%\r - ${prog} ${args} ${target} ${progArgs}%*\r -)\r -`; - } else { - cmd += `@${prog} ${args} ${target} ${progArgs}%*\r -`; + // like .pipe() but using super, because our write() is special + [PIPE](job) { + job.piped = true; + if (job.readdir) { + job.readdir.forEach((entry) => { + const p = job.path; + const base = p === "./" ? "" : p.replace(/\/*$/, "/"); + this[ADDFSENTRY](base + entry); + }); + } + const source = job.entry; + const zip = this.zip; + if (!source) + throw new Error("cannot pipe without source"); + if (zip) { + source.on("data", (chunk) => { + if (!zip.write(chunk)) { + source.pause(); + } + }); + } else { + source.on("data", (chunk) => { + if (!super.write(chunk)) { + source.pause(); + } + }); + } } - return cmd; - } - function generateShShim(src, to, opts) { - let shTarget = path10.relative(path10.dirname(to), src); - let shProg = opts.prog && opts.prog.split("\\").join("/"); - let shLongProg; - shTarget = shTarget.split("\\").join("/"); - const quotedPathToTarget = path10.isAbsolute(shTarget) ? `"${shTarget}"` : `"$basedir/${shTarget}"`; - let args = opts.args || ""; - const shNodePath = normalizePathEnvVar(opts.nodePath).posix; - if (!shProg) { - shProg = quotedPathToTarget; - args = ""; - shTarget = ""; - } else if (opts.prog === "node" && opts.nodeExecPath) { - shProg = `"${opts.nodeExecPath}"`; - shTarget = quotedPathToTarget; - } else { - shLongProg = `"$basedir/${opts.prog}"`; - shTarget = quotedPathToTarget; + pause() { + if (this.zip) { + this.zip.pause(); + } + return super.pause(); } - let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : ""; - let sh = `#!/bin/sh -basedir=$(dirname "$(echo "$0" | sed -e 's,\\\\,/,g')") - -case \`uname\` in - *CYGWIN*) basedir=\`cygpath -w "$basedir"\`;; -esac - -`; - if (opts.prependToPath) { - sh += `export PATH="${opts.prependToPath}:$PATH" -`; + warn(code2, message, data = {}) { + warnMethod(this, code2, message, data); } - if (shNodePath) { - sh += `if [ -z "$NODE_PATH" ]; then - export NODE_PATH="${shNodePath}" -else - export NODE_PATH="${shNodePath}:$NODE_PATH" -fi -`; + }; + PackSync = class extends Pack { + sync = true; + constructor(opt) { + super(opt); + this[WRITEENTRYCLASS] = WriteEntrySync; } - if (shLongProg) { - sh += `if [ -x ${shLongProg} ]; then - exec ${shLongProg} ${args} ${shTarget} ${progArgs}"$@" -else - exec ${shProg} ${args} ${shTarget} ${progArgs}"$@" -fi -`; - } else { - sh += `${shProg} ${args} ${shTarget} ${progArgs}"$@" -exit $? -`; + // pause/resume are no-ops in sync streams. + pause() { } - return sh; - } - function generatePwshShim(src, to, opts) { - let shTarget = path10.relative(path10.dirname(to), src); - const shProg = opts.prog && opts.prog.split("\\").join("/"); - let pwshProg = shProg && `"${shProg}$exe"`; - let pwshLongProg; - shTarget = shTarget.split("\\").join("/"); - const quotedPathToTarget = path10.isAbsolute(shTarget) ? `"${shTarget}"` : `"$basedir/${shTarget}"`; - let args = opts.args || ""; - let normalizedNodePathEnvVar = normalizePathEnvVar(opts.nodePath); - const nodePath = normalizedNodePathEnvVar.win32; - const shNodePath = normalizedNodePathEnvVar.posix; - let normalizedPrependPathEnvVar = normalizePathEnvVar(opts.prependToPath); - const prependPath = normalizedPrependPathEnvVar.win32; - const shPrependPath = normalizedPrependPathEnvVar.posix; - if (!pwshProg) { - pwshProg = quotedPathToTarget; - args = ""; - shTarget = ""; - } else if (opts.prog === "node" && opts.nodeExecPath) { - pwshProg = `"${opts.nodeExecPath}"`; - shTarget = quotedPathToTarget; - } else { - pwshLongProg = `"$basedir/${opts.prog}$exe"`; - shTarget = quotedPathToTarget; + resume() { } - let progArgs = opts.progArgs ? `${opts.progArgs.join(` `)} ` : ""; - let pwsh = `#!/usr/bin/env pwsh -$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent - -$exe="" -${nodePath || prependPath ? '$pathsep=":"\n' : ""}${nodePath ? `$env_node_path=$env:NODE_PATH -$new_node_path="${nodePath}" -` : ""}${prependPath ? `$env_path=$env:PATH -$prepend_path="${prependPath}" -` : ""}if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { - # Fix case when both the Windows and Linux builds of Node - # are installed in the same directory - $exe=".exe" -${nodePath || prependPath ? ' $pathsep=";"\n' : ""}}`; - if (shNodePath || shPrependPath) { - pwsh += ` else { -${shNodePath ? ` $new_node_path="${shNodePath}" -` : ""}${shPrependPath ? ` $prepend_path="${shPrependPath}" -` : ""}} -`; + [STAT](job) { + const stat2 = this.follow ? "statSync" : "lstatSync"; + this[ONSTAT](job, import_fs15.default[stat2](job.absolute)); } - if (shNodePath) { - pwsh += `if ([string]::IsNullOrEmpty($env_node_path)) { - $env:NODE_PATH=$new_node_path -} else { - $env:NODE_PATH="$new_node_path$pathsep$env_node_path" -} -`; + [READDIR](job) { + this[ONREADDIR](job, import_fs15.default.readdirSync(job.absolute)); } - if (opts.prependToPath) { - pwsh += ` -$env:PATH="$prepend_path$pathsep$env:PATH" -`; + // gotta get it all in this tick + [PIPE](job) { + const source = job.entry; + const zip = this.zip; + if (job.readdir) { + job.readdir.forEach((entry) => { + const p = job.path; + const base = p === "./" ? "" : p.replace(/\/*$/, "/"); + this[ADDFSENTRY](base + entry); + }); + } + if (!source) + throw new Error("Cannot pipe without source"); + if (zip) { + source.on("data", (chunk) => { + zip.write(chunk); + }); + } else { + source.on("data", (chunk) => { + super[WRITE](chunk); + }); + } } - if (pwshLongProg) { - pwsh += ` -$ret=0 -if (Test-Path ${pwshLongProg}) { - # Support pipeline input - if ($MyInvocation.ExpectingInput) { - $input | & ${pwshLongProg} ${args} ${shTarget} ${progArgs}$args - } else { - & ${pwshLongProg} ${args} ${shTarget} ${progArgs}$args - } - $ret=$LASTEXITCODE -} else { - # Support pipeline input - if ($MyInvocation.ExpectingInput) { - $input | & ${pwshProg} ${args} ${shTarget} ${progArgs}$args - } else { - & ${pwshProg} ${args} ${shTarget} ${progArgs}$args + }; } - $ret=$LASTEXITCODE -} -${nodePath ? "$env:NODE_PATH=$env_node_path\n" : ""}${prependPath ? "$env:PATH=$env_path\n" : ""}exit $ret -`; - } else { - pwsh += ` -# Support pipeline input -if ($MyInvocation.ExpectingInput) { - $input | & ${pwshProg} ${args} ${shTarget} ${progArgs}$args -} else { - & ${pwshProg} ${args} ${shTarget} ${progArgs}$args -} -${nodePath ? "$env:NODE_PATH=$env_node_path\n" : ""}${prependPath ? "$env:PATH=$env_path\n" : ""}exit $LASTEXITCODE -`; - } - return pwsh; - } - function chmodShim(to, opts) { - return opts.fs_.chmod(to, 493); - } - function normalizePathEnvVar(nodePath) { - if (!nodePath || !nodePath.length) { - return { - win32: "", - posix: "" - }; +}); + +// .yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/create.js +var create_exports = {}; +__export(create_exports, { + create: () => create +}); +var import_node_path8, createFileSync, createFile, addFilesSync, addFilesAsync, createSync, createAsync, create; +var init_create = __esm({ + ".yarn/cache/tar-npm-7.4.0-2d244f1b3c-f4bab85fd1.zip/node_modules/tar/dist/esm/create.js"() { + init_esm2(); + import_node_path8 = __toESM(require("node:path"), 1); + init_list(); + init_make_command(); + init_pack(); + createFileSync = (opt, files) => { + const p = new PackSync(opt); + const stream = new WriteStreamSync(opt.file, { + mode: opt.mode || 438 + }); + p.pipe(stream); + addFilesSync(p, files); + }; + createFile = (opt, files) => { + const p = new Pack(opt); + const stream = new WriteStream(opt.file, { + mode: opt.mode || 438 + }); + p.pipe(stream); + const promise = new Promise((res, rej) => { + stream.on("error", rej); + stream.on("close", res); + p.on("error", rej); + }); + addFilesAsync(p, files); + return promise; + }; + addFilesSync = (p, files) => { + files.forEach((file) => { + if (file.charAt(0) === "@") { + list({ + file: import_node_path8.default.resolve(p.cwd, file.slice(1)), + sync: true, + noResume: true, + onReadEntry: (entry) => p.add(entry) + }); + } else { + p.add(file); + } + }); + p.end(); + }; + addFilesAsync = async (p, files) => { + for (let i = 0; i < files.length; i++) { + const file = String(files[i]); + if (file.charAt(0) === "@") { + await list({ + file: import_node_path8.default.resolve(String(p.cwd), file.slice(1)), + noResume: true, + onReadEntry: (entry) => { + p.add(entry); + } + }); + } else { + p.add(file); + } } - let split = typeof nodePath === "string" ? nodePath.split(path10.delimiter) : Array.from(nodePath); - let result = {}; - for (let i = 0; i < split.length; i++) { - const win32 = split[i].split("/").join("\\"); - const posix = isWindows() ? split[i].split("\\").join("/").replace(/^([^:\\/]*):/, (_, $1) => `/mnt/${$1.toLowerCase()}`) : split[i]; - result.win32 = result.win32 ? `${result.win32};${win32}` : win32; - result.posix = result.posix ? `${result.posix}:${posix}` : posix; - result[i] = { win32, posix }; + p.end(); + }; + createSync = (opt, files) => { + const p = new PackSync(opt); + addFilesSync(p, files); + return p; + }; + createAsync = (opt, files) => { + const p = new Pack(opt); + addFilesAsync(p, files); + return p; + }; + create = makeCommand(createFileSync, createFile, createSync, createAsync, (_opt, files) => { + if (!files?.length) { + throw new TypeError("no paths specified to add to archive"); } - return result; - } - module2.exports = cmdShim2; + }); } }); -// .yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/major.js +// .yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/major.js var require_major = __commonJS({ - ".yarn/cache/semver-npm-7.6.2-0fec6944bb-97d3441e97.zip/node_modules/semver/functions/major.js"(exports2, module2) { + ".yarn/cache/semver-npm-7.6.3-57e82c14d5-88f33e148b.zip/node_modules/semver/functions/major.js"(exports2, module2) { var SemVer3 = require_semver(); var major = (a, loose) => new SemVer3(a, loose).major; module2.exports = major; @@ -19632,7 +19604,7 @@ __export(lib_exports2, { }); module.exports = __toCommonJS(lib_exports2); -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/constants.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/constants.mjs var NODE_INITIAL = 0; var NODE_SUCCESS = 1; var NODE_ERRORED = 2; @@ -19645,7 +19617,7 @@ var BATCH_REGEX = /^-[a-zA-Z]{2,}$/; var BINDING_REGEX = /^([^=]+)=([\s\S]*)$/; var DEBUG = process.env.DEBUG_CLI === `1`; -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/errors.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/errors.mjs var UsageError = class extends Error { constructor(message) { super(message); @@ -19714,7 +19686,7 @@ var whileRunning = (input) => `While running ${input.filter((token) => { } }).join(` `)}`; -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/format.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/format.mjs var MAX_LINE_LENGTH = 80; var richLine = Array(MAX_LINE_LENGTH).fill(`\u2501`); for (let t = 0; t <= 24; ++t) @@ -19773,7 +19745,7 @@ function formatMarkdownish(text, { format, paragraphs }) { ` : ``; } -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/options/utils.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/utils.mjs var isOptionSymbol = Symbol(`clipanion/isOption`); function makeCommandOption(spec) { return { ...spec, [isOptionSymbol]: true }; @@ -19791,10 +19763,10 @@ function cleanValidationError(message, { mergeName = false } = {}) { const match = message.match(/^([^:]+): (.*)$/m); if (!match) return `validation failed`; - let [, path10, line] = match; + let [, path16, line] = match; if (mergeName) line = line[0].toLowerCase() + line.slice(1); - line = path10 !== `.` || !mergeName ? `${path10.replace(/^\.(\[|$)/, `$1`)}: ${line}` : `: ${line}`; + line = path16 !== `.` || !mergeName ? `${path16.replace(/^\.(\[|$)/, `$1`)}: ${line}` : `: ${line}`; return line; } function formatError(message, errors) { @@ -19806,7 +19778,7 @@ ${errors.map((error) => ` - ${cleanValidationError(error)}`).join(``)}`); } } -function applyValidator(name, value, validator) { +function applyValidator(name2, value, validator) { if (typeof validator === `undefined`) return value; const errors = []; @@ -19818,13 +19790,13 @@ function applyValidator(name, value, validator) { }; const check = validator(value, { errors, coercions, coercion }); if (!check) - throw formatError(`Invalid value for ${name}`, errors); + throw formatError(`Invalid value for ${name2}`, errors); for (const [, op] of coercions) op(); return value; } -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/Command.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/Command.mjs var Command = class { constructor() { this.help = false; @@ -19871,7 +19843,7 @@ var Command = class { Command.isOption = isOptionSymbol; Command.Default = []; -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/core.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/core.mjs function debug(str) { if (DEBUG) { console.log(str); @@ -20146,7 +20118,7 @@ function selectBestState(input, states) { }); if (terminalStates.length === 0) throw new Error(); - const requiredOptionsSetStates = terminalStates.filter((state) => state.selectedIndex === HELP_COMMAND_INDEX || state.requiredOptions.every((names) => names.some((name) => state.options.find((opt) => opt.name === name)))); + const requiredOptionsSetStates = terminalStates.filter((state) => state.selectedIndex === HELP_COMMAND_INDEX || state.requiredOptions.every((names) => names.some((name2) => state.options.find((opt) => opt.name === name2)))); if (requiredOptionsSetStates.length === 0) { throw new UnknownSyntaxError(input, terminalStates.map((state) => ({ usage: state.candidateUsage, @@ -20245,8 +20217,8 @@ function registerStatic(machine, from, test, to, reducer) { } function execute(store, callback, state, segment) { if (Array.isArray(callback)) { - const [name, ...args] = callback; - return store[name](state, segment, ...args); + const [name2, ...args] = callback; + return store[name2](state, segment, ...args); } else { return store[callback](state, segment); } @@ -20268,18 +20240,18 @@ var tests = { isNotOptionLike: (state, segment) => { return state.ignoreOptions || segment === `-` || !segment.startsWith(`-`); }, - isOption: (state, segment, name, hidden) => { - return !state.ignoreOptions && segment === name; + isOption: (state, segment, name2, hidden) => { + return !state.ignoreOptions && segment === name2; }, isBatchOption: (state, segment, names) => { - return !state.ignoreOptions && BATCH_REGEX.test(segment) && [...segment.slice(1)].every((name) => names.includes(`-${name}`)); + return !state.ignoreOptions && BATCH_REGEX.test(segment) && [...segment.slice(1)].every((name2) => names.includes(`-${name2}`)); }, isBoundOption: (state, segment, names, options) => { const optionParsing = segment.match(BINDING_REGEX); return !state.ignoreOptions && !!optionParsing && OPTION_REGEX.test(optionParsing[1]) && names.includes(optionParsing[1]) && options.filter((opt) => opt.names.includes(optionParsing[1])).every((opt) => opt.allowBinding); }, - isNegatedOption: (state, segment, name) => { - return !state.ignoreOptions && segment === `--no-${name.slice(2)}`; + isNegatedOption: (state, segment, name2) => { + return !state.ignoreOptions && segment === `--no-${name2.slice(2)}`; }, isHelp: (state, segment) => { return !state.ignoreOptions && HELP_REGEX.test(segment); @@ -20291,8 +20263,8 @@ var tests = { return !state.ignoreOptions && segment.startsWith(`-`) && !OPTION_REGEX.test(segment); } }; -tests.isOption.suggest = (state, name, hidden = true) => { - return !hidden ? [name] : null; +tests.isOption.suggest = (state, name2, hidden = true) => { + return !hidden ? [name2] : null; }; var reducers = { setCandidateState: (state, segment, candidateState) => { @@ -20302,11 +20274,11 @@ var reducers = { return { ...state, selectedIndex: index }; }, pushBatch: (state, segment) => { - return { ...state, options: state.options.concat([...segment.slice(1)].map((name) => ({ name: `-${name}`, value: true }))) }; + return { ...state, options: state.options.concat([...segment.slice(1)].map((name2) => ({ name: `-${name2}`, value: true }))) }; }, pushBound: (state, segment) => { - const [, name, value] = segment.match(BINDING_REGEX); - return { ...state, options: state.options.concat({ name, value }) }; + const [, name2, value] = segment.match(BINDING_REGEX); + return { ...state, options: state.options.concat({ name: name2, value }) }; }, pushPath: (state, segment) => { return { ...state, path: state.path.concat(segment) }; @@ -20320,11 +20292,11 @@ var reducers = { pushExtraNoLimits: (state, segment) => { return { ...state, positionals: state.positionals.concat({ value: segment, extra: NoLimits }) }; }, - pushTrue: (state, segment, name = segment) => { + pushTrue: (state, segment, name2 = segment) => { return { ...state, options: state.options.concat({ name: segment, value: true }) }; }, - pushFalse: (state, segment, name = segment) => { - return { ...state, options: state.options.concat({ name, value: false }) }; + pushFalse: (state, segment, name2 = segment) => { + return { ...state, options: state.options.concat({ name: name2, value: false }) }; }, pushUndefined: (state, segment) => { return { ...state, options: state.options.concat({ name: segment, value: void 0 }) }; @@ -20380,32 +20352,32 @@ var CommandBuilder = class { this.cliIndex = cliIndex; this.cliOpts = cliOpts; } - addPath(path10) { - this.paths.push(path10); + addPath(path16) { + this.paths.push(path16); } setArity({ leading = this.arity.leading, trailing = this.arity.trailing, extra = this.arity.extra, proxy = this.arity.proxy }) { Object.assign(this.arity, { leading, trailing, extra, proxy }); } - addPositional({ name = `arg`, required = true } = {}) { + addPositional({ name: name2 = `arg`, required = true } = {}) { if (!required && this.arity.extra === NoLimits) throw new Error(`Optional parameters cannot be declared when using .rest() or .proxy()`); if (!required && this.arity.trailing.length > 0) throw new Error(`Optional parameters cannot be declared after the required trailing positional arguments`); if (!required && this.arity.extra !== NoLimits) { - this.arity.extra.push(name); + this.arity.extra.push(name2); } else if (this.arity.extra !== NoLimits && this.arity.extra.length === 0) { - this.arity.leading.push(name); + this.arity.leading.push(name2); } else { - this.arity.trailing.push(name); + this.arity.trailing.push(name2); } } - addRest({ name = `arg`, required = 0 } = {}) { + addRest({ name: name2 = `arg`, required = 0 } = {}) { if (this.arity.extra === NoLimits) throw new Error(`Infinite lists cannot be declared multiple times in the same command`); if (this.arity.trailing.length > 0) throw new Error(`Infinite lists cannot be declared after the required trailing positional arguments`); for (let t = 0; t < required; ++t) - this.addPositional({ name }); + this.addPositional({ name: name2 }); this.arity.extra = NoLimits; } addProxy({ required = 0 } = {}) { @@ -20444,12 +20416,12 @@ var CommandBuilder = class { segments.push(required ? `<${definition}>` : `[${definition}]`); } } - segments.push(...this.arity.leading.map((name) => `<${name}>`)); + segments.push(...this.arity.leading.map((name2) => `<${name2}>`)); if (this.arity.extra === NoLimits) segments.push(`...`); else - segments.push(...this.arity.extra.map((name) => `[${name}]`)); - segments.push(...this.arity.trailing.map((name) => `<${name}>`)); + segments.push(...this.arity.extra.map((name2) => `[${name2}]`)); + segments.push(...this.arity.trailing.map((name2) => `<${name2}>`)); } const usage = segments.join(` `); return { usage, options: detailedOptionList }; @@ -20465,17 +20437,17 @@ var CommandBuilder = class { registerStatic(machine, NODE_INITIAL, START_OF_INPUT, firstNode, [`setCandidateState`, { candidateUsage, requiredOptions }]); const positionalArgument = this.arity.proxy ? `always` : `isNotOptionLike`; const paths = this.paths.length > 0 ? this.paths : [[]]; - for (const path10 of paths) { + for (const path16 of paths) { let lastPathNode = firstNode; - if (path10.length > 0) { + if (path16.length > 0) { const optionPathNode = injectNode(machine, makeNode()); registerShortcut(machine, lastPathNode, optionPathNode); this.registerOptions(machine, optionPathNode); lastPathNode = optionPathNode; } - for (let t = 0; t < path10.length; ++t) { + for (let t = 0; t < path16.length; ++t) { const nextPathNode = injectNode(machine, makeNode()); - registerStatic(machine, lastPathNode, path10[t], nextPathNode, `pushPath`); + registerStatic(machine, lastPathNode, path16[t], nextPathNode, `pushPath`); lastPathNode = nextPathNode; } if (this.arity.leading.length > 0 || !this.arity.proxy) { @@ -20547,20 +20519,20 @@ var CommandBuilder = class { registerDynamic(machine, node, [`isUnsupportedOption`, this.allOptionNames], NODE_ERRORED, [`setError`, `Unsupported option name`]); registerDynamic(machine, node, [`isInvalidOption`], NODE_ERRORED, [`setError`, `Invalid option name`]); for (const option of this.options) { - const longestName = option.names.reduce((longestName2, name) => { - return name.length > longestName2.length ? name : longestName2; + const longestName = option.names.reduce((longestName2, name2) => { + return name2.length > longestName2.length ? name2 : longestName2; }, ``); if (option.arity === 0) { - for (const name of option.names) { - registerDynamic(machine, node, [`isOption`, name, option.hidden || name !== longestName], node, `pushTrue`); - if (name.startsWith(`--`) && !name.startsWith(`--no-`)) { - registerDynamic(machine, node, [`isNegatedOption`, name], node, [`pushFalse`, name]); + for (const name2 of option.names) { + registerDynamic(machine, node, [`isOption`, name2, option.hidden || name2 !== longestName], node, `pushTrue`); + if (name2.startsWith(`--`) && !name2.startsWith(`--no-`)) { + registerDynamic(machine, node, [`isNegatedOption`, name2], node, [`pushFalse`, name2]); } } } else { let lastNode = injectNode(machine, makeNode()); - for (const name of option.names) - registerDynamic(machine, node, [`isOption`, name, option.hidden || name !== longestName], lastNode, `pushUndefined`); + for (const name2 of option.names) + registerDynamic(machine, node, [`isOption`, name2, option.hidden || name2 !== longestName], lastNode, `pushUndefined`); for (let t = 0; t < option.arity; ++t) { const nextNode = injectNode(machine, makeNode()); registerStatic(machine, lastNode, END_OF_INPUT, NODE_ERRORED, `setOptionArityError`); @@ -20620,48 +20592,10 @@ var CliBuilder = class _CliBuilder { } }; -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/platform/node.mjs -var import_tty = __toESM(require("tty"), 1); -function getDefaultColorDepth() { - if (import_tty.default && `getColorDepth` in import_tty.default.WriteStream.prototype) - return import_tty.default.WriteStream.prototype.getColorDepth(); - if (process.env.FORCE_COLOR === `0`) - return 1; - if (process.env.FORCE_COLOR === `1`) - return 8; - if (typeof process.stdout !== `undefined` && process.stdout.isTTY) - return 8; - return 1; -} -var gContextStorage; -function getCaptureActivator(context) { - let contextStorage = gContextStorage; - if (typeof contextStorage === `undefined`) { - if (context.stdout === process.stdout && context.stderr === process.stderr) - return null; - const { AsyncLocalStorage: LazyAsyncLocalStorage } = require("async_hooks"); - contextStorage = gContextStorage = new LazyAsyncLocalStorage(); - const origStdoutWrite = process.stdout._write; - process.stdout._write = function(chunk, encoding, cb) { - const context2 = contextStorage.getStore(); - if (typeof context2 === `undefined`) - return origStdoutWrite.call(this, chunk, encoding, cb); - return context2.stdout.write(chunk, encoding, cb); - }; - const origStderrWrite = process.stderr._write; - process.stderr._write = function(chunk, encoding, cb) { - const context2 = contextStorage.getStore(); - if (typeof context2 === `undefined`) - return origStderrWrite.call(this, chunk, encoding, cb); - return context2.stderr.write(chunk, encoding, cb); - }; - } - return (fn2) => { - return contextStorage.run(context, fn2); - }; -} +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/Cli.mjs +var import_platform = __toESM(require_node(), 1); -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/HelpCommand.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/HelpCommand.mjs var HelpCommand = class _HelpCommand extends Command { constructor(contexts) { super(); @@ -20711,7 +20645,7 @@ var HelpCommand = class _HelpCommand extends Command { } }; -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/Cli.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/Cli.mjs var errorCommandSymbol = Symbol(`clipanion/errorCommand`); var Cli = class _Cli { constructor({ binaryLabel, binaryName: binaryNameOpt = `...`, binaryVersion, enableCapture = false, enableColors } = {}) { @@ -20753,8 +20687,8 @@ var Cli = class _Cli { const index = builder.cliIndex; const paths = (_a = commandClass.paths) !== null && _a !== void 0 ? _a : command.paths; if (typeof paths !== `undefined`) - for (const path10 of paths) - builder.addPath(path10); + for (const path16 of paths) + builder.addPath(path16); this.registrations.set(commandClass, { specs, builder, index }); for (const [key, { definition }] of specs.entries()) definition(builder, key); @@ -20832,7 +20766,7 @@ var Cli = class _Cli { run: (input2, subContext) => this.run(input2, { ...context, ...subContext }), usage: (command2, opts) => this.usage(command2, opts) }; - const activate = this.enableCapture ? (_b = getCaptureActivator(context)) !== null && _b !== void 0 ? _b : noopCaptureActivator : noopCaptureActivator; + const activate = this.enableCapture ? (_b = (0, import_platform.getCaptureActivator)(context)) !== null && _b !== void 0 ? _b : noopCaptureActivator : noopCaptureActivator; let exitCode; try { exitCode = await activate(() => command.validateAndExecute().catch((error) => command.catch(error).then(() => 0))); @@ -20854,13 +20788,13 @@ var Cli = class _Cli { for (const [commandClass, { index }] of this.registrations) { if (typeof commandClass.usage === `undefined`) continue; - const { usage: path10 } = this.getUsageByIndex(index, { detailed: false }); + const { usage: path16 } = this.getUsageByIndex(index, { detailed: false }); const { usage, options } = this.getUsageByIndex(index, { detailed: true, inlineOptions: false }); const category = typeof commandClass.usage.category !== `undefined` ? formatMarkdownish(commandClass.usage.category, { format: this.format(colored), paragraphs: false }) : void 0; const description = typeof commandClass.usage.description !== `undefined` ? formatMarkdownish(commandClass.usage.description, { format: this.format(colored), paragraphs: false }) : void 0; const details = typeof commandClass.usage.details !== `undefined` ? formatMarkdownish(commandClass.usage.details, { format: this.format(colored), paragraphs: true }) : void 0; const examples = typeof commandClass.usage.examples !== `undefined` ? commandClass.usage.examples.map(([label, cli]) => [formatMarkdownish(label, { format: this.format(colored), paragraphs: false }), cli.replace(/\$0/g, this.binaryName)]) : void 0; - data.push({ path: path10, usage, category, description, details, examples, options }); + data.push({ path: path16, usage, category, description, details, examples, options }); } return data; } @@ -20871,7 +20805,7 @@ var Cli = class _Cli { const paths = commandClass2.paths; const isDocumented = typeof commandClass2.usage !== `undefined`; const isExclusivelyDefault = !paths || paths.length === 0 || paths.length === 1 && paths[0].length === 0; - const isDefault = isExclusivelyDefault || ((_a = paths === null || paths === void 0 ? void 0 : paths.some((path10) => path10.length === 0)) !== null && _a !== void 0 ? _a : false); + const isDefault = isExclusivelyDefault || ((_a = paths === null || paths === void 0 ? void 0 : paths.some((path16) => path16.length === 0)) !== null && _a !== void 0 ? _a : false); if (isDefault) { if (command) { command = null; @@ -21018,10 +20952,10 @@ var Cli = class _Cli { if (!error || typeof error !== `object` || !(`stack` in error)) error = new Error(`Execution failed with a non-error rejection (rejected value: ${JSON.stringify(error)})`); let result = ``; - let name = error.name.replace(/([a-z])([A-Z])/g, `$1 $2`); - if (name === `Error`) - name = `Internal Error`; - result += `${this.format(colored).error(name)}: ${error.message} + let name2 = error.name.replace(/([a-z])([A-Z])/g, `$1 $2`); + if (name2 === `Error`) + name2 = `Internal Error`; + result += `${this.format(colored).error(name2)}: ${error.message} `; const meta = error.clipanion; if (typeof meta !== `undefined`) { @@ -21057,13 +20991,13 @@ Cli.defaultContext = { stdin: process.stdin, stdout: process.stdout, stderr: process.stderr, - colorDepth: getDefaultColorDepth() + colorDepth: (0, import_platform.getDefaultColorDepth)() }; function noopCaptureActivator(fn2) { return fn2(); } -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/builtins/index.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/builtins/index.mjs var builtins_exports = {}; __export(builtins_exports, { DefinitionsCommand: () => DefinitionsCommand, @@ -21071,7 +21005,7 @@ __export(builtins_exports, { VersionCommand: () => VersionCommand }); -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/builtins/definitions.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/builtins/definitions.mjs var DefinitionsCommand = class extends Command { async execute() { this.context.stdout.write(`${JSON.stringify(this.cli.definitions(), null, 2)} @@ -21080,7 +21014,7 @@ var DefinitionsCommand = class extends Command { }; DefinitionsCommand.paths = [[`--clipanion=definitions`]]; -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/builtins/help.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/builtins/help.mjs var HelpCommand2 = class extends Command { async execute() { this.context.stdout.write(this.cli.usage()); @@ -21088,7 +21022,7 @@ var HelpCommand2 = class extends Command { }; HelpCommand2.paths = [[`-h`], [`--help`]]; -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/builtins/version.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/builtins/version.mjs var VersionCommand = class extends Command { async execute() { var _a; @@ -21098,7 +21032,7 @@ var VersionCommand = class extends Command { }; VersionCommand.paths = [[`-v`], [`--version`]]; -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/options/index.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/index.mjs var options_exports = {}; __export(options_exports, { Array: () => Array2, @@ -21115,7 +21049,7 @@ __export(options_exports, { rerouteArguments: () => rerouteArguments }); -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/options/Array.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/Array.mjs function Array2(descriptor, initialValueBase, optsBase) { const [initialValue, opts] = rerouteArguments(initialValueBase, optsBase !== null && optsBase !== void 0 ? optsBase : {}); const { arity = 1 } = opts; @@ -21134,10 +21068,10 @@ function Array2(descriptor, initialValueBase, optsBase) { transformer(builder, key, state) { let usedName; let currentValue = typeof initialValue !== `undefined` ? [...initialValue] : void 0; - for (const { name, value } of state.options) { - if (!nameSet.has(name)) + for (const { name: name2, value } of state.options) { + if (!nameSet.has(name2)) continue; - usedName = name; + usedName = name2; currentValue = currentValue !== null && currentValue !== void 0 ? currentValue : []; currentValue.push(value); } @@ -21150,7 +21084,7 @@ function Array2(descriptor, initialValueBase, optsBase) { }); } -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/options/Boolean.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/Boolean.mjs function Boolean2(descriptor, initialValueBase, optsBase) { const [initialValue, opts] = rerouteArguments(initialValueBase, optsBase !== null && optsBase !== void 0 ? optsBase : {}); const optNames = descriptor.split(`,`); @@ -21168,8 +21102,8 @@ function Boolean2(descriptor, initialValueBase, optsBase) { }, transformer(builer, key, state) { let currentValue = initialValue; - for (const { name, value } of state.options) { - if (!nameSet.has(name)) + for (const { name: name2, value } of state.options) { + if (!nameSet.has(name2)) continue; currentValue = value; } @@ -21178,7 +21112,7 @@ function Boolean2(descriptor, initialValueBase, optsBase) { }); } -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/options/Counter.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/Counter.mjs function Counter(descriptor, initialValueBase, optsBase) { const [initialValue, opts] = rerouteArguments(initialValueBase, optsBase !== null && optsBase !== void 0 ? optsBase : {}); const optNames = descriptor.split(`,`); @@ -21196,8 +21130,8 @@ function Counter(descriptor, initialValueBase, optsBase) { }, transformer(builder, key, state) { let currentValue = initialValue; - for (const { name, value } of state.options) { - if (!nameSet.has(name)) + for (const { name: name2, value } of state.options) { + if (!nameSet.has(name2)) continue; currentValue !== null && currentValue !== void 0 ? currentValue : currentValue = 0; if (!value) { @@ -21211,7 +21145,7 @@ function Counter(descriptor, initialValueBase, optsBase) { }); } -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/options/Proxy.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/Proxy.mjs function Proxy2(opts = {}) { return makeCommandOption({ definition(builder, key) { @@ -21227,7 +21161,7 @@ function Proxy2(opts = {}) { }); } -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/options/Rest.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/Rest.mjs function Rest(opts = {}) { return makeCommandOption({ definition(builder, key) { @@ -21254,7 +21188,7 @@ function Rest(opts = {}) { }); } -// .yarn/__virtual__/clipanion-virtual-48805df892/0/cache/clipanion-npm-3.2.1-fc9187f56c-6c148bd01a.zip/node_modules/clipanion/lib/advanced/options/String.mjs +// .yarn/__virtual__/clipanion-virtual-dbbb3cfe27/0/cache/clipanion-patch-1b1b878e9f-a833a30963.zip/node_modules/clipanion/lib/advanced/options/String.mjs function StringOption(descriptor, initialValueBase, optsBase) { const [initialValue, opts] = rerouteArguments(initialValueBase, optsBase !== null && optsBase !== void 0 ? optsBase : {}); const { arity = 1 } = opts; @@ -21277,10 +21211,10 @@ function StringOption(descriptor, initialValueBase, optsBase) { usedName = opts.env; currentValue = context.env[opts.env]; } - for (const { name, value } of state.options) { - if (!nameSet.has(name)) + for (const { name: name2, value } of state.options) { + if (!nameSet.has(name2)) continue; - usedName = name; + usedName = name2; currentValue = value; } if (typeof currentValue === `string`) { @@ -21326,11 +21260,11 @@ function String2(descriptor, ...args) { } // package.json -var version = "0.29.2"; +var version = "0.29.3"; // sources/Engine.ts -var import_fs4 = __toESM(require("fs")); -var import_path4 = __toESM(require("path")); +var import_fs9 = __toESM(require("fs")); +var import_path9 = __toESM(require("path")); var import_process3 = __toESM(require("process")); var import_rcompare = __toESM(require_rcompare()); var import_valid2 = __toESM(require_valid()); @@ -21516,14 +21450,14 @@ var config_default = { // sources/corepackUtils.ts var import_crypto2 = require("crypto"); -var import_events2 = require("events"); -var import_fs2 = __toESM(require("fs")); +var import_events4 = require("events"); +var import_fs7 = __toESM(require("fs")); var import_module = __toESM(require("module")); -var import_path2 = __toESM(require("path")); +var import_path7 = __toESM(require("path")); var import_range = __toESM(require_range()); var import_semver = __toESM(require_semver()); var import_lt = __toESM(require_lt()); -var import_parse = __toESM(require_parse()); +var import_parse3 = __toESM(require_parse()); var import_promises = require("timers/promises"); // sources/debugUtils.ts @@ -21553,10 +21487,10 @@ function getTemporaryFolder(target = (0, import_os.tmpdir)()) { while (true) { const rnd = Math.random() * 4294967296; const hex = rnd.toString(16).padStart(8, `0`); - const path10 = (0, import_path.join)(target, `corepack-${import_process.default.pid}-${hex}`); + const path16 = (0, import_path.join)(target, `corepack-${import_process.default.pid}-${hex}`); try { - (0, import_fs.mkdirSync)(path10); - return path10; + (0, import_fs.mkdirSync)(path16); + return path16; } catch (error) { if (error.code === `EEXIST`) { continue; @@ -21581,7 +21515,7 @@ var DEFAULT_HEADERS = { [`Accept`]: `application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8` }; var DEFAULT_NPM_REGISTRY_URL = `https://registry.npmjs.org`; -async function fetchAsJson2(packageName, version2) { +async function fetchAsJson2(packageName, version3) { const npmRegistryUrl = process.env.COREPACK_NPM_REGISTRY || DEFAULT_NPM_REGISTRY_URL; if (process.env.COREPACK_ENABLE_NETWORK === `0`) throw new UsageError(`Network access disabled by the environment; can't reach npm repository ${npmRegistryUrl}`); @@ -21592,15 +21526,15 @@ async function fetchAsJson2(packageName, version2) { const encodedCreds = Buffer.from(`${process.env.COREPACK_NPM_USERNAME}:${process.env.COREPACK_NPM_PASSWORD}`, `utf8`).toString(`base64`); headers.authorization = `Basic ${encodedCreds}`; } - return fetchAsJson(`${npmRegistryUrl}/${packageName}${version2 ? `/${version2}` : ``}`, { headers }); + return fetchAsJson(`${npmRegistryUrl}/${packageName}${version3 ? `/${version3}` : ``}`, { headers }); } -function verifySignature({ signatures, integrity, packageName, version: version2 }) { +function verifySignature({ signatures, integrity, packageName, version: version3 }) { const { npm: keys } = process.env.COREPACK_INTEGRITY_KEYS ? JSON.parse(process.env.COREPACK_INTEGRITY_KEYS) : config_default.keys; const key = keys.find(({ keyid }) => signatures.some((s) => s.keyid === keyid)); const signature = signatures.find(({ keyid }) => keyid === key?.keyid); if (key == null || signature == null) throw new Error(`Cannot find matching keyid: ${JSON.stringify({ signatures, keys })}`); const verifier = (0, import_crypto.createVerify)(`SHA256`); - verifier.end(`${packageName}@${version2}:${integrity}`); + verifier.end(`${packageName}@${version3}:${integrity}`); const valid = verifier.verify( `-----BEGIN PUBLIC KEY----- ${key.key} @@ -21614,16 +21548,16 @@ ${key.key} } async function fetchLatestStableVersion(packageName) { const metadata = await fetchAsJson2(packageName, `latest`); - const { version: version2, dist: { integrity, signatures } } = metadata; + const { version: version3, dist: { integrity, signatures, shasum } } = metadata; if (!shouldSkipIntegrityCheck()) { verifySignature({ packageName, - version: version2, + version: version3, integrity, signatures }); } - return `${version2}+sha512.${Buffer.from(integrity.slice(7), `base64`).toString(`hex`)}`; + return `${version3}+${integrity ? `sha512.${Buffer.from(integrity.slice(7), `base64`).toString(`hex`)}` : `sha1.${shasum}`}`; } async function fetchAvailableTags(packageName) { const metadata = await fetchAsJson2(packageName); @@ -21633,11 +21567,11 @@ async function fetchAvailableVersions(packageName) { const metadata = await fetchAsJson2(packageName); return Object.keys(metadata.versions); } -async function fetchTarballURLAndSignature(packageName, version2) { - const versionMetadata = await fetchAsJson2(packageName, version2); +async function fetchTarballURLAndSignature(packageName, version3) { + const versionMetadata = await fetchAsJson2(packageName, version3); const { tarball, signatures, integrity } = versionMetadata.dist; if (tarball === void 0 || !tarball.startsWith(`http`)) - throw new Error(`${packageName}@${version2} does not have a valid tarball.`); + throw new Error(`${packageName}@${version3} does not have a valid tarball.`); return { tarball, signatures, integrity }; } @@ -21776,10 +21710,10 @@ async function fetchAvailableVersions2(spec) { } } async function findInstalledVersion(installTarget, descriptor) { - const installFolder = import_path2.default.join(installTarget, descriptor.name); + const installFolder = import_path7.default.join(installTarget, descriptor.name); let cacheDirectory; try { - cacheDirectory = await import_fs2.default.promises.opendir(installFolder); + cacheDirectory = await import_fs7.default.promises.opendir(installFolder); } catch (error) { if (error.code === `ENOENT`) { return null; @@ -21790,11 +21724,11 @@ async function findInstalledVersion(installTarget, descriptor) { const range = new import_range.default(descriptor.range); let bestMatch = null; let maxSV = void 0; - for await (const { name } of cacheDirectory) { - if (name.startsWith(`.`)) + for await (const { name: name2 } of cacheDirectory) { + if (name2.startsWith(`.`)) continue; - if (range.test(name) && maxSV?.compare(name) !== 1) { - bestMatch = name; + if (range.test(name2) && maxSV?.compare(name2) !== 1) { + bestMatch = name2; maxSV = new import_semver.default(bestMatch); } } @@ -21827,29 +21761,29 @@ async function download(installTarget, url, algo, binPath = null) { log(`Downloading to ${tmpFolder}`); const stream = await fetchUrlStream(url); const parsedUrl = new URL(url); - const ext = import_path2.default.posix.extname(parsedUrl.pathname); + const ext = import_path7.default.posix.extname(parsedUrl.pathname); let outputFile = null; let sendTo; if (ext === `.tgz`) { - const { default: tar } = await Promise.resolve().then(() => __toESM(require_tar())); - sendTo = tar.x({ + const { extract: tarX } = await Promise.resolve().then(() => (init_extract(), extract_exports)); + sendTo = tarX({ strip: 1, cwd: tmpFolder, - filter: binPath ? (path10) => { - const pos = path10.indexOf(`/`); - return pos !== -1 && path10.slice(pos + 1) === binPath; + filter: binPath ? (path16) => { + const pos2 = path16.indexOf(`/`); + return pos2 !== -1 && path16.slice(pos2 + 1) === binPath; } : void 0 }); } else if (ext === `.js`) { - outputFile = import_path2.default.join(tmpFolder, import_path2.default.posix.basename(parsedUrl.pathname)); - sendTo = import_fs2.default.createWriteStream(outputFile); + outputFile = import_path7.default.join(tmpFolder, import_path7.default.posix.basename(parsedUrl.pathname)); + sendTo = import_fs7.default.createWriteStream(outputFile); } stream.pipe(sendTo); let hash = !binPath ? stream.pipe((0, import_crypto2.createHash)(algo)) : null; - await (0, import_events2.once)(sendTo, `finish`); + await (0, import_events4.once)(sendTo, `finish`); if (binPath) { - const downloadedBin = import_path2.default.join(tmpFolder, binPath); - outputFile = import_path2.default.join(tmpFolder, import_path2.default.basename(downloadedBin)); + const downloadedBin = import_path7.default.join(tmpFolder, binPath); + outputFile = import_path7.default.join(tmpFolder, import_path7.default.basename(downloadedBin)); try { await renameSafe(downloadedBin, outputFile); } catch (err) { @@ -21857,9 +21791,9 @@ async function download(installTarget, url, algo, binPath = null) { throw new Error(`Cannot locate '${binPath}' in downloaded tarball`, { cause: err }); throw err; } - const fileStream = import_fs2.default.createReadStream(outputFile); + const fileStream = import_fs7.default.createReadStream(outputFile); hash = fileStream.pipe((0, import_crypto2.createHash)(algo)); - await (0, import_events2.once)(fileStream, `close`); + await (0, import_events4.once)(fileStream, `close`); } return { tmpFolder, @@ -21869,14 +21803,14 @@ async function download(installTarget, url, algo, binPath = null) { } async function installVersion(installTarget, locator, { spec }) { const locatorIsASupportedPackageManager = isSupportedPackageManagerLocator(locator); - const locatorReference = locatorIsASupportedPackageManager ? (0, import_parse.default)(locator.reference) : parseURLReference(locator); - const { version: version2, build } = locatorReference; - const installFolder = import_path2.default.join(installTarget, locator.name, version2); + const locatorReference = locatorIsASupportedPackageManager ? (0, import_parse3.default)(locator.reference) : parseURLReference(locator); + const { version: version3, build } = locatorReference; + const installFolder = import_path7.default.join(installTarget, locator.name, version3); try { - const corepackFile = import_path2.default.join(installFolder, `.corepack`); - const corepackContent = await import_fs2.default.promises.readFile(corepackFile, `utf8`); + const corepackFile = import_path7.default.join(installFolder, `.corepack`); + const corepackContent = await import_fs7.default.promises.readFile(corepackFile, `utf8`); const corepackData = JSON.parse(corepackContent); - log(`Reusing ${locator.name}@${locator.reference}`); + log(`Reusing ${locator.name}@${locator.reference} found in ${installFolder}`); return { hash: corepackData.hash, location: installFolder, @@ -21892,11 +21826,11 @@ async function installVersion(installTarget, locator, { spec }) { let integrity; let binPath = null; if (locatorIsASupportedPackageManager) { - url = spec.url.replace(`{}`, version2); + url = spec.url.replace(`{}`, version3); if (process.env.COREPACK_NPM_REGISTRY) { const registry = getRegistryFromPackageManagerSpec(spec); if (registry.type === `npm`) { - ({ tarball: url, signatures, integrity } = await fetchTarballURLAndSignature(registry.package, version2)); + ({ tarball: url, signatures, integrity } = await fetchTarballURLAndSignature(registry.package, version3)); if (registry.bin) { binPath = registry.bin; } @@ -21907,7 +21841,7 @@ async function installVersion(installTarget, locator, { spec }) { ); } } else { - url = decodeURIComponent(version2); + url = decodeURIComponent(version3); if (process.env.COREPACK_NPM_REGISTRY && url.startsWith(DEFAULT_NPM_REGISTRY_URL)) { url = url.replace( DEFAULT_NPM_REGISTRY_URL, @@ -21915,7 +21849,7 @@ async function installVersion(installTarget, locator, { spec }) { ); } } - log(`Installing ${locator.name}@${version2} from ${url}`); + log(`Installing ${locator.name}@${version3} from ${url}`); const algo = build[0] ?? `sha512`; const { tmpFolder, outputFile, hash: actualHash } = await download(installTarget, url, algo, binPath); let bin; @@ -21930,7 +21864,7 @@ async function installVersion(installTarget, locator, { spec }) { if (locatorIsASupportedPackageManager && isValidBinSpec(spec.bin)) { bin = spec.bin; } else { - const { name: packageName, bin: packageBin } = require(import_path2.default.join(tmpFolder, `package.json`)); + const { name: packageName, bin: packageBin } = require(import_path7.default.join(tmpFolder, `package.json`)); if (typeof packageBin === `string`) { bin = { [packageName]: packageBin }; } else if (isValidBinSpec(packageBin)) { @@ -21944,27 +21878,27 @@ async function installVersion(installTarget, locator, { spec }) { const registry = getRegistryFromPackageManagerSpec(spec); if (registry.type === `npm` && !registry.bin && !shouldSkipIntegrityCheck()) { if (signatures == null || integrity == null) - ({ signatures, integrity } = await fetchTarballURLAndSignature(registry.package, version2)); - verifySignature({ signatures, integrity, packageName: registry.package, version: version2 }); + ({ signatures, integrity } = await fetchTarballURLAndSignature(registry.package, version3)); + verifySignature({ signatures, integrity, packageName: registry.package, version: version3 }); build[1] = Buffer.from(integrity.slice(`sha512-`.length), `base64`).toString(`hex`); } } if (build[1] && actualHash !== build[1]) throw new Error(`Mismatch hashes. Expected ${build[1]}, got ${actualHash}`); const serializedHash = `${algo}.${actualHash}`; - await import_fs2.default.promises.writeFile(import_path2.default.join(tmpFolder, `.corepack`), JSON.stringify({ + await import_fs7.default.promises.writeFile(import_path7.default.join(tmpFolder, `.corepack`), JSON.stringify({ locator, bin, hash: serializedHash })); - await import_fs2.default.promises.mkdir(import_path2.default.dirname(installFolder), { recursive: true }); + await import_fs7.default.promises.mkdir(import_path7.default.dirname(installFolder), { recursive: true }); try { await renameSafe(tmpFolder, installFolder); } catch (err) { if (err.code === `ENOTEMPTY` || // On Windows the error code is EPERM so we check if it is a directory - err.code === `EPERM` && (await import_fs2.default.promises.stat(installFolder)).isDirectory()) { + err.code === `EPERM` && (await import_fs7.default.promises.stat(installFolder)).isDirectory()) { log(`Another instance of corepack installed ${locator.name}@${locator.reference}`); - await import_fs2.default.promises.rm(tmpFolder, { recursive: true, force: true }); + await import_fs7.default.promises.rm(tmpFolder, { recursive: true, force: true }); } else { throw err; } @@ -21973,14 +21907,14 @@ async function installVersion(installTarget, locator, { spec }) { const lastKnownGood = await getLastKnownGood(); const defaultVersion = getLastKnownGoodFromFileContent(lastKnownGood, locator.name); if (defaultVersion) { - const currentDefault = (0, import_parse.default)(defaultVersion); + const currentDefault = (0, import_parse3.default)(defaultVersion); const downloadedVersion = locatorReference; if (currentDefault.major === downloadedVersion.major && (0, import_lt.default)(currentDefault, downloadedVersion)) { await activatePackageManager(lastKnownGood, locator); } } } - log(`Install finished`); + log(`Download and install of ${locator.name}@${locator.reference} is finished`); return { location: installFolder, bin, @@ -21991,14 +21925,14 @@ async function renameSafe(oldPath, newPath) { if (process.platform === `win32`) { await renameUnderWindows(oldPath, newPath); } else { - await import_fs2.default.promises.rename(oldPath, newPath); + await import_fs7.default.promises.rename(oldPath, newPath); } } async function renameUnderWindows(oldPath, newPath) { const retries = 5; for (let i = 0; i < retries; i++) { try { - await import_fs2.default.promises.rename(oldPath, newPath); + await import_fs7.default.promises.rename(oldPath, newPath); break; } catch (err) { if ((err.code === `ENOENT` || err.code === `EPERM`) && i < retries - 1) { @@ -22014,17 +21948,17 @@ async function runVersion(locator, installSpec, binName, args) { let binPath = null; const bin = installSpec.bin ?? installSpec.spec.bin; if (Array.isArray(bin)) { - if (bin.some((name) => name === binName)) { + if (bin.some((name2) => name2 === binName)) { const parsedUrl = new URL(installSpec.spec.url); - const ext = import_path2.default.posix.extname(parsedUrl.pathname); + const ext = import_path7.default.posix.extname(parsedUrl.pathname); if (ext === `.js`) { - binPath = import_path2.default.join(installSpec.location, import_path2.default.posix.basename(parsedUrl.pathname)); + binPath = import_path7.default.join(installSpec.location, import_path7.default.posix.basename(parsedUrl.pathname)); } } } else { - for (const [name, dest] of Object.entries(bin)) { - if (name === binName) { - binPath = import_path2.default.join(installSpec.location, dest); + for (const [name2, dest] of Object.entries(bin)) { + if (name2 === binName) { + binPath = import_path7.default.join(installSpec.location, dest); break; } } @@ -22033,7 +21967,7 @@ async function runVersion(locator, installSpec, binName, args) { throw new Error(`Assertion failed: Unable to locate path for bin '${binName}'`); if (locator.name !== `npm` || (0, import_lt.default)(locator.reference, `9.7.0`)) await Promise.resolve().then(() => __toESM(require_v8_compile_cache())); - process.env.COREPACK_ROOT = import_path2.default.dirname(require.resolve("corepack/package.json")); + process.env.COREPACK_ROOT = import_path7.default.dirname(require.resolve("corepack/package.json")); process.argv = [ process.execPath, binPath, @@ -22050,18 +21984,18 @@ function shouldSkipIntegrityCheck() { // sources/semverUtils.ts var import_range2 = __toESM(require_range()); var import_semver2 = __toESM(require_semver()); -function satisfiesWithPrereleases(version2, range, loose = false) { +function satisfiesWithPrereleases(version3, range, loose = false) { let semverRange; try { semverRange = new import_range2.default(range, loose); } catch (err) { return false; } - if (!version2) + if (!version3) return false; let semverVersion; try { - semverVersion = new import_semver2.default(version2, semverRange.loose); + semverVersion = new import_semver2.default(version3, semverRange.loose); if (semverVersion.prerelease) { semverVersion.prerelease = []; } @@ -22079,8 +22013,8 @@ function satisfiesWithPrereleases(version2, range, loose = false) { } // sources/specUtils.ts -var import_fs3 = __toESM(require("fs")); -var import_path3 = __toESM(require("path")); +var import_fs8 = __toESM(require("fs")); +var import_path8 = __toESM(require("path")); var import_valid = __toESM(require_valid()); // sources/nodeUtils.ts @@ -22141,47 +22075,47 @@ function isSupportedPackageManager(value) { // sources/specUtils.ts var nodeModulesRegExp = /[\\/]node_modules[\\/](@[^\\/]*[\\/])?([^@\\/][^\\/]*)$/; -function parseSpec(raw, source, { enforceExactVersion = true } = {}) { - if (typeof raw !== `string`) +function parseSpec(raw2, source, { enforceExactVersion = true } = {}) { + if (typeof raw2 !== `string`) throw new UsageError(`Invalid package manager specification in ${source}; expected a string`); - const atIndex = raw.indexOf(`@`); - if (atIndex === -1 || atIndex === raw.length - 1) { + const atIndex = raw2.indexOf(`@`); + if (atIndex === -1 || atIndex === raw2.length - 1) { if (enforceExactVersion) - throw new UsageError(`No version specified for ${raw} in "packageManager" of ${source}`); - const name2 = atIndex === -1 ? raw : raw.slice(0, -1); - if (!isSupportedPackageManager(name2)) - throw new UsageError(`Unsupported package manager specification (${name2})`); + throw new UsageError(`No version specified for ${raw2} in "packageManager" of ${source}`); + const name3 = atIndex === -1 ? raw2 : raw2.slice(0, -1); + if (!isSupportedPackageManager(name3)) + throw new UsageError(`Unsupported package manager specification (${name3})`); return { - name: name2, + name: name3, range: `*` }; } - const name = raw.slice(0, atIndex); - const range = raw.slice(atIndex + 1); + const name2 = raw2.slice(0, atIndex); + const range = raw2.slice(atIndex + 1); const isURL = URL.canParse(range); if (!isURL) { if (enforceExactVersion && !(0, import_valid.default)(range)) - throw new UsageError(`Invalid package manager specification in ${source} (${raw}); expected a semver version${enforceExactVersion ? `` : `, range, or tag`}`); - if (!isSupportedPackageManager(name)) { - throw new UsageError(`Unsupported package manager specification (${raw})`); + throw new UsageError(`Invalid package manager specification in ${source} (${raw2}); expected a semver version${enforceExactVersion ? `` : `, range, or tag`}`); + if (!isSupportedPackageManager(name2)) { + throw new UsageError(`Unsupported package manager specification (${raw2})`); } - } else if (isSupportedPackageManager(name) && process.env.COREPACK_ENABLE_UNSAFE_CUSTOM_URLS !== `1`) { - throw new UsageError(`Illegal use of URL for known package manager. Instead, select a specific version, or set COREPACK_ENABLE_UNSAFE_CUSTOM_URLS=1 in your environment (${raw})`); + } else if (isSupportedPackageManager(name2) && process.env.COREPACK_ENABLE_UNSAFE_CUSTOM_URLS !== `1`) { + throw new UsageError(`Illegal use of URL for known package manager. Instead, select a specific version, or set COREPACK_ENABLE_UNSAFE_CUSTOM_URLS=1 in your environment (${raw2})`); } return { - name, + name: name2, range }; } async function setLocalPackageManager(cwd, info) { const lookup = await loadSpec(cwd); - const content = lookup.type !== `NoProject` ? await import_fs3.default.promises.readFile(lookup.target, `utf8`) : ``; + const content = lookup.type !== `NoProject` ? await import_fs8.default.promises.readFile(lookup.target, `utf8`) : ``; const { data, indent } = readPackageJson(content); const previousPackageManager = data.packageManager ?? `unknown`; data.packageManager = `${info.locator.name}@${info.locator.reference}`; const newContent = normalizeLineEndings(content, `${JSON.stringify(data, null, indent)} `); - await import_fs3.default.promises.writeFile(lookup.target, newContent, `utf8`); + await import_fs8.default.promises.writeFile(lookup.target, newContent, `utf8`); return { previousPackageManager }; @@ -22192,13 +22126,14 @@ async function loadSpec(initialCwd) { let selection = null; while (nextCwd !== currCwd && (!selection || !selection.data.packageManager)) { currCwd = nextCwd; - nextCwd = import_path3.default.dirname(currCwd); + nextCwd = import_path8.default.dirname(currCwd); if (nodeModulesRegExp.test(currCwd)) continue; - const manifestPath = import_path3.default.join(currCwd, `package.json`); + const manifestPath = import_path8.default.join(currCwd, `package.json`); + log(`Checking ${manifestPath}`); let content; try { - content = await import_fs3.default.promises.readFile(manifestPath, `utf8`); + content = await import_fs8.default.promises.readFile(manifestPath, `utf8`); } catch (err) { if (err?.code === `ENOENT`) continue; throw err; @@ -22209,52 +22144,65 @@ async function loadSpec(initialCwd) { } catch { } if (typeof data !== `object` || data === null) - throw new UsageError(`Invalid package.json in ${import_path3.default.relative(initialCwd, manifestPath)}`); + throw new UsageError(`Invalid package.json in ${import_path8.default.relative(initialCwd, manifestPath)}`); selection = { data, manifestPath }; } if (selection === null) - return { type: `NoProject`, target: import_path3.default.join(initialCwd, `package.json`) }; + return { type: `NoProject`, target: import_path8.default.join(initialCwd, `package.json`) }; const rawPmSpec = selection.data.packageManager; if (typeof rawPmSpec === `undefined`) return { type: `NoSpec`, target: selection.manifestPath }; return { type: `Found`, target: selection.manifestPath, - spec: parseSpec(rawPmSpec, import_path3.default.relative(initialCwd, selection.manifestPath)) + spec: parseSpec(rawPmSpec, import_path8.default.relative(initialCwd, selection.manifestPath)) }; } // sources/Engine.ts function getLastKnownGoodFilePath() { - return import_path4.default.join(getCorepackHomeFolder(), `lastKnownGood.json`); + const lkg = import_path9.default.join(getCorepackHomeFolder(), `lastKnownGood.json`); + log(`LastKnownGood file would be located at ${lkg}`); + return lkg; } async function getLastKnownGood() { - let raw; + let raw2; try { - raw = await import_fs4.default.promises.readFile(getLastKnownGoodFilePath(), `utf8`); + raw2 = await import_fs9.default.promises.readFile(getLastKnownGoodFilePath(), `utf8`); } catch (err) { - if (err?.code === `ENOENT`) return {}; + if (err?.code === `ENOENT`) { + log(`No LastKnownGood version found in Corepack home.`); + return {}; + } throw err; } try { - const parsed = JSON.parse(raw); - if (!parsed) return {}; - if (typeof parsed !== `object`) return {}; + const parsed = JSON.parse(raw2); + if (!parsed) { + log(`Invalid LastKnowGood file in Corepack home (JSON parsable, but falsy)`); + return {}; + } + if (typeof parsed !== `object`) { + log(`Invalid LastKnowGood file in Corepack home (JSON parsable, but non-object)`); + return {}; + } Object.entries(parsed).forEach(([key, value]) => { if (typeof value !== `string`) { + log(`Ignoring key ${key} in LastKnownGood file as its value is not a string`); delete parsed[key]; } }); return parsed; } catch { + log(`Invalid LastKnowGood file in Corepack home (maybe not JSON parsable)`); return {}; } } async function createLastKnownGoodFile(lastKnownGood) { const content = `${JSON.stringify(lastKnownGood, null, 2)} `; - await import_fs4.default.promises.mkdir(getCorepackHomeFolder(), { recursive: true }); - await import_fs4.default.promises.writeFile(getLastKnownGoodFilePath(), content, `utf8`); + await import_fs9.default.promises.mkdir(getCorepackHomeFolder(), { recursive: true }); + await import_fs9.default.promises.writeFile(getLastKnownGoodFilePath(), content, `utf8`); } function getLastKnownGoodFromFileContent(lastKnownGood, packageManager) { if (Object.hasOwn(lastKnownGood, packageManager)) @@ -22311,20 +22259,20 @@ var Engine = class { throw new Error(`Assertion failed: Specified resolution (${locator.reference}) isn't supported by any of ${ranges.join(`, `)}`); return definition.ranges[range]; } - getBinariesFor(name) { + getBinariesFor(name2) { const binNames = /* @__PURE__ */ new Set(); - for (const rangeDefinition of Object.values(this.config.definitions[name].ranges)) { + for (const rangeDefinition of Object.values(this.config.definitions[name2].ranges)) { const bins = Array.isArray(rangeDefinition.bin) ? rangeDefinition.bin : Object.keys(rangeDefinition.bin); - for (const name2 of bins) { - binNames.add(name2); + for (const name3 of bins) { + binNames.add(name3); } } return binNames; } async getDefaultDescriptors() { const locators = []; - for (const name of SupportedPackageManagerSet) - locators.push({ name, range: await this.getDefaultVersion(name) }); + for (const name2 of SupportedPackageManagerSet) + locators.push({ name: name2, range: await this.getDefaultVersion(name2) }); return locators; } async getDefaultVersion(packageManager) { @@ -22333,17 +22281,23 @@ var Engine = class { throw new UsageError(`This package manager (${packageManager}) isn't supported by this corepack build`); const lastKnownGood = await getLastKnownGood(); const lastKnownGoodForThisPackageManager = getLastKnownGoodFromFileContent(lastKnownGood, packageManager); - if (lastKnownGoodForThisPackageManager) + if (lastKnownGoodForThisPackageManager) { + log(`Search for default version: Found ${packageManager}@${lastKnownGoodForThisPackageManager} in LastKnownGood file`); return lastKnownGoodForThisPackageManager; - if (import_process3.default.env.COREPACK_DEFAULT_TO_LATEST === `0`) + } + if (import_process3.default.env.COREPACK_DEFAULT_TO_LATEST === `0`) { + log(`Search for default version: As defined in environment, defaulting to internal config ${packageManager}@${definition.default}`); return definition.default; + } const reference = await fetchLatestStableVersion2(definition.fetchLatestFrom); + log(`Search for default version: found in remote registry ${packageManager}@${reference}`); try { await activatePackageManager(lastKnownGood, { name: packageManager, reference }); } catch { + log(`Search for default version: could not activate registry version`); } return reference; } @@ -22394,6 +22348,7 @@ var Engine = class { const result = await loadSpec(initialCwd); switch (result.type) { case `NoProject`: + log(`Falling back to ${fallbackDescriptor.name}@${fallbackDescriptor.range} as no project manifest were found`); return fallbackDescriptor; case `NoSpec`: { if (import_process3.default.env.COREPACK_ENABLE_AUTO_PIN !== `0`) { @@ -22404,18 +22359,21 @@ var Engine = class { console.error(`! The local project doesn't define a 'packageManager' field. Corepack will now add one referencing ${installSpec.locator.name}@${installSpec.locator.reference}.`); console.error(`! For more details about this field, consult the documentation at https://nodejs.org/api/packages.html#packagemanager`); console.error(); - await setLocalPackageManager(import_path4.default.dirname(result.target), installSpec); + await setLocalPackageManager(import_path9.default.dirname(result.target), installSpec); } + log(`Falling back to ${fallbackDescriptor.name}@${fallbackDescriptor.range} in the absence of "packageManage" field in ${result.target}`); return fallbackDescriptor; } case `Found`: { if (result.spec.name !== locator.name) { if (transparent) { + log(`Falling back to ${fallbackDescriptor.name}@${fallbackDescriptor.range} in a ${result.spec.name}@${result.spec.range} project`); return fallbackDescriptor; } else { throw new UsageError(`This project is configured to use ${result.spec.name} because ${result.target} has a "packageManager" field`); } } else { + log(`Using ${result.spec.name}@${result.spec.range} as defined in project manifest ${result.target}`); return result.spec; } } @@ -22489,7 +22447,7 @@ var Engine = class { const packageManagerSpec = definition.ranges[range]; const registry = getRegistryFromPackageManagerSpec(packageManagerSpec); const versions2 = await fetchAvailableVersions2(registry); - return versions2.filter((version2) => satisfiesWithPrereleases(version2, finalDescriptor.range)); + return versions2.filter((version3) => satisfiesWithPrereleases(version3, finalDescriptor.range)); })); const highestVersion = [...new Set(versions.flat())].sort(import_rcompare.default); if (highestVersion.length === 0) @@ -22499,7 +22457,7 @@ var Engine = class { }; // sources/commands/Cache.ts -var import_fs5 = __toESM(require("fs")); +var import_fs10 = __toESM(require("fs")); var CacheCommand = class extends Command { static paths = [ [`cache`, `clean`], @@ -22512,13 +22470,13 @@ var CacheCommand = class extends Command { ` }); async execute() { - await import_fs5.default.promises.rm(getInstallFolder(), { recursive: true, force: true }); + await import_fs10.default.promises.rm(getInstallFolder(), { recursive: true, force: true }); } }; // sources/commands/Disable.ts -var import_fs6 = __toESM(require("fs")); -var import_path5 = __toESM(require("path")); +var import_fs11 = __toESM(require("fs")); +var import_path10 = __toESM(require("path")); var import_which = __toESM(require_lib()); var DisableCommand = class extends Command { static paths = [ @@ -22549,22 +22507,22 @@ var DisableCommand = class extends Command { async execute() { let installDirectory = this.installDirectory; if (typeof installDirectory === `undefined`) - installDirectory = import_path5.default.dirname(await (0, import_which.default)(`corepack`)); + installDirectory = import_path10.default.dirname(await (0, import_which.default)(`corepack`)); const names = this.names.length === 0 ? SupportedPackageManagerSetWithoutNpm : this.names; const allBinNames = []; - for (const name of new Set(names)) { - if (!isSupportedPackageManager(name)) - throw new UsageError(`Invalid package manager name '${name}'`); - const binNames = this.context.engine.getBinariesFor(name); + for (const name2 of new Set(names)) { + if (!isSupportedPackageManager(name2)) + throw new UsageError(`Invalid package manager name '${name2}'`); + const binNames = this.context.engine.getBinariesFor(name2); allBinNames.push(...binNames); } const removeLink = process.platform === `win32` ? (binName) => this.removeWin32Link(installDirectory, binName) : (binName) => this.removePosixLink(installDirectory, binName); await Promise.all(allBinNames.map(removeLink)); } async removePosixLink(installDirectory, binName) { - const file = import_path5.default.join(installDirectory, binName); + const file = import_path10.default.join(installDirectory, binName); try { - await import_fs6.default.promises.unlink(file); + await import_fs11.default.promises.unlink(file); } catch (err) { if (err.code !== `ENOENT`) { throw err; @@ -22573,9 +22531,9 @@ var DisableCommand = class extends Command { } async removeWin32Link(installDirectory, binName) { for (const ext of [``, `.ps1`, `.cmd`]) { - const file = import_path5.default.join(installDirectory, `${binName}${ext}`); + const file = import_path10.default.join(installDirectory, `${binName}${ext}`); try { - await import_fs6.default.promises.unlink(file); + await import_fs11.default.promises.unlink(file); } catch (err) { if (err.code !== `ENOENT`) { throw err; @@ -22587,8 +22545,8 @@ var DisableCommand = class extends Command { // sources/commands/Enable.ts var import_cmd_shim = __toESM(require_cmd_shim()); -var import_fs7 = __toESM(require("fs")); -var import_path6 = __toESM(require("path")); +var import_fs12 = __toESM(require("fs")); +var import_path11 = __toESM(require("path")); var import_which2 = __toESM(require_lib()); var EnableCommand = class extends Command { static paths = [ @@ -22619,47 +22577,47 @@ var EnableCommand = class extends Command { async execute() { let installDirectory = this.installDirectory; if (typeof installDirectory === `undefined`) - installDirectory = import_path6.default.dirname(await (0, import_which2.default)(`corepack`)); - installDirectory = import_fs7.default.realpathSync(installDirectory); + installDirectory = import_path11.default.dirname(await (0, import_which2.default)(`corepack`)); + installDirectory = import_fs12.default.realpathSync(installDirectory); const manifestPath = require.resolve("corepack/package.json"); - const distFolder = import_path6.default.join(import_path6.default.dirname(manifestPath), `dist`); - if (!import_fs7.default.existsSync(distFolder)) + const distFolder = import_path11.default.join(import_path11.default.dirname(manifestPath), `dist`); + if (!import_fs12.default.existsSync(distFolder)) throw new Error(`Assertion failed: The stub folder doesn't exist`); const names = this.names.length === 0 ? SupportedPackageManagerSetWithoutNpm : this.names; const allBinNames = []; - for (const name of new Set(names)) { - if (!isSupportedPackageManager(name)) - throw new UsageError(`Invalid package manager name '${name}'`); - const binNames = this.context.engine.getBinariesFor(name); + for (const name2 of new Set(names)) { + if (!isSupportedPackageManager(name2)) + throw new UsageError(`Invalid package manager name '${name2}'`); + const binNames = this.context.engine.getBinariesFor(name2); allBinNames.push(...binNames); } const generateLink = process.platform === `win32` ? (binName) => this.generateWin32Link(installDirectory, distFolder, binName) : (binName) => this.generatePosixLink(installDirectory, distFolder, binName); await Promise.all(allBinNames.map(generateLink)); } async generatePosixLink(installDirectory, distFolder, binName) { - const file = import_path6.default.join(installDirectory, binName); - const symlink = import_path6.default.relative(installDirectory, import_path6.default.join(distFolder, `${binName}.js`)); - if (import_fs7.default.existsSync(file)) { - const currentSymlink = await import_fs7.default.promises.readlink(file); + const file = import_path11.default.join(installDirectory, binName); + const symlink = import_path11.default.relative(installDirectory, import_path11.default.join(distFolder, `${binName}.js`)); + if (import_fs12.default.existsSync(file)) { + const currentSymlink = await import_fs12.default.promises.readlink(file); if (currentSymlink !== symlink) { - await import_fs7.default.promises.unlink(file); + await import_fs12.default.promises.unlink(file); } else { return; } } - await import_fs7.default.promises.symlink(symlink, file); + await import_fs12.default.promises.symlink(symlink, file); } async generateWin32Link(installDirectory, distFolder, binName) { - const file = import_path6.default.join(installDirectory, binName); - await (0, import_cmd_shim.default)(import_path6.default.join(distFolder, `${binName}.js`), file, { + const file = import_path11.default.join(installDirectory, binName); + await (0, import_cmd_shim.default)(import_path11.default.join(distFolder, `${binName}.js`), file, { createCmdFile: true }); } }; // sources/commands/InstallGlobal.ts -var import_fs8 = __toESM(require("fs")); -var import_path7 = __toESM(require("path")); +var import_fs13 = __toESM(require("fs")); +var import_path12 = __toESM(require("path")); // sources/commands/Base.ts var BaseCommand = class extends Command { @@ -22726,7 +22684,7 @@ var InstallGlobalCommand = class extends BaseCommand { throw new UsageError(`No package managers specified`); await Promise.all(this.args.map((arg) => { if (arg.endsWith(`.tgz`)) { - return this.installFromTarball(import_path7.default.resolve(this.context.cwd, arg)); + return this.installFromTarball(import_path12.default.resolve(this.context.cwd, arg)); } else { return this.installFromDescriptor(parseSpec(arg, `CLI arguments`, { enforceExactVersion: false })); } @@ -22754,9 +22712,9 @@ var InstallGlobalCommand = class extends BaseCommand { async installFromTarball(p) { const installFolder = getInstallFolder(); const archiveEntries = /* @__PURE__ */ new Map(); - const { default: tar } = await Promise.resolve().then(() => __toESM(require_tar())); + const { list: tarT } = await Promise.resolve().then(() => (init_list(), list_exports)); let hasShortEntries = false; - await tar.t({ file: p, onentry: (entry) => { + await tarT({ file: p, onentry: (entry) => { const segments = entry.path.split(/\//g); if (segments.length > 0 && segments[segments.length - 1] !== `.corepack`) return; @@ -22771,15 +22729,16 @@ var InstallGlobalCommand = class extends BaseCommand { } }); if (hasShortEntries || archiveEntries.size < 1) throw new UsageError(`Invalid archive format; did it get generated by 'corepack pack'?`); - for (const [name, references] of archiveEntries) { + const { extract: tarX } = await Promise.resolve().then(() => (init_extract(), extract_exports)); + for (const [name2, references] of archiveEntries) { for (const reference of references) { - if (!isSupportedPackageManager(name)) - throw new UsageError(`Unsupported package manager '${name}'`); - this.log({ name, reference }); - await import_fs8.default.promises.mkdir(installFolder, { recursive: true }); - await tar.x({ file: p, cwd: installFolder }, [`${name}/${reference}`]); + if (!isSupportedPackageManager(name2)) + throw new UsageError(`Unsupported package manager '${name2}'`); + this.log({ name: name2, reference }); + await import_fs13.default.promises.mkdir(installFolder, { recursive: true }); + await tarX({ file: p, cwd: installFolder }, [`${name2}/${reference}`]); if (!this.cacheOnly) { - await this.context.engine.activatePackageManager({ name, reference }); + await this.context.engine.activatePackageManager({ name: name2, reference }); } } } @@ -22816,7 +22775,7 @@ var InstallLocalCommand = class extends BaseCommand { // sources/commands/Pack.ts var import_promises2 = require("fs/promises"); -var import_path8 = __toESM(require("path")); +var import_path15 = __toESM(require("path")); var PackCommand = class extends BaseCommand { static paths = [ [`pack`] @@ -22857,17 +22816,17 @@ var PackCommand = class extends BaseCommand { installLocations.push(packageManagerInfo.location); } const baseInstallFolder = getInstallFolder(); - const outputPath = import_path8.default.resolve(this.context.cwd, this.output ?? `corepack.tgz`); + const outputPath = import_path15.default.resolve(this.context.cwd, this.output ?? `corepack.tgz`); if (!this.json) { this.context.stdout.write(` `); - this.context.stdout.write(`Packing the selected tools in ${import_path8.default.basename(outputPath)}... + this.context.stdout.write(`Packing the selected tools in ${import_path15.default.basename(outputPath)}... `); } - const { default: tar } = await Promise.resolve().then(() => __toESM(require_tar())); + const { create: tarC } = await Promise.resolve().then(() => (init_create(), create_exports)); await (0, import_promises2.mkdir)(baseInstallFolder, { recursive: true }); - await tar.c({ gzip: true, cwd: baseInstallFolder, file: import_path8.default.resolve(outputPath) }, installLocations.map((location) => { - return import_path8.default.relative(baseInstallFolder, location); + await tarC({ gzip: true, cwd: baseInstallFolder, file: import_path15.default.resolve(outputPath) }, installLocations.map((location) => { + return import_path15.default.relative(baseInstallFolder, location); })); if (this.json) { this.context.stdout.write(`${JSON.stringify(outputPath)} @@ -22959,7 +22918,7 @@ var UseCommand = class extends BaseCommand { // sources/commands/deprecated/Hydrate.ts var import_promises3 = require("fs/promises"); -var import_path9 = __toESM(require("path")); +var import_path16 = __toESM(require("path")); var HydrateCommand = class extends Command { static paths = [ [`hydrate`] @@ -22970,11 +22929,11 @@ var HydrateCommand = class extends Command { fileName = options_exports.String(); async execute() { const installFolder = getInstallFolder(); - const fileName = import_path9.default.resolve(this.context.cwd, this.fileName); + const fileName = import_path16.default.resolve(this.context.cwd, this.fileName); const archiveEntries = /* @__PURE__ */ new Map(); let hasShortEntries = false; - const { default: tar } = await Promise.resolve().then(() => __toESM(require_tar())); - await tar.t({ file: fileName, onentry: (entry) => { + const { list: tarT } = await Promise.resolve().then(() => (init_list(), list_exports)); + await tarT({ file: fileName, onentry: (entry) => { const segments = entry.path.split(/\//g); if (segments.length < 3) { hasShortEntries = true; @@ -22987,20 +22946,21 @@ var HydrateCommand = class extends Command { } }); if (hasShortEntries || archiveEntries.size < 1) throw new UsageError(`Invalid archive format; did it get generated by 'corepack prepare'?`); - for (const [name, references] of archiveEntries) { + const { extract: tarX } = await Promise.resolve().then(() => (init_extract(), extract_exports)); + for (const [name2, references] of archiveEntries) { for (const reference of references) { - if (!isSupportedPackageManager(name)) - throw new UsageError(`Unsupported package manager '${name}'`); + if (!isSupportedPackageManager(name2)) + throw new UsageError(`Unsupported package manager '${name2}'`); if (this.activate) - this.context.stdout.write(`Hydrating ${name}@${reference} for immediate activation... + this.context.stdout.write(`Hydrating ${name2}@${reference} for immediate activation... `); else - this.context.stdout.write(`Hydrating ${name}@${reference}... + this.context.stdout.write(`Hydrating ${name2}@${reference}... `); await (0, import_promises3.mkdir)(installFolder, { recursive: true }); - await tar.x({ file: fileName, cwd: installFolder }, [`${name}/${reference}`]); + await tarX({ file: fileName, cwd: installFolder }, [`${name2}/${reference}`]); if (this.activate) { - await this.context.engine.activatePackageManager({ name, reference }); + await this.context.engine.activatePackageManager({ name: name2, reference }); } } } @@ -23011,7 +22971,7 @@ var HydrateCommand = class extends Command { // sources/commands/deprecated/Prepare.ts var import_promises4 = require("fs/promises"); -var import_path10 = __toESM(require("path")); +var import_path17 = __toESM(require("path")); var PrepareCommand = class extends Command { static paths = [ [`prepare`] @@ -23065,14 +23025,14 @@ var PrepareCommand = class extends Command { if (this.output) { const outputName = typeof this.output === `string` ? this.output : `corepack.tgz`; const baseInstallFolder = getInstallFolder(); - const outputPath = import_path10.default.resolve(this.context.cwd, outputName); + const outputPath = import_path17.default.resolve(this.context.cwd, outputName); if (!this.json) - this.context.stdout.write(`Packing the selected tools in ${import_path10.default.basename(outputPath)}... + this.context.stdout.write(`Packing the selected tools in ${import_path17.default.basename(outputPath)}... `); - const { default: tar } = await Promise.resolve().then(() => __toESM(require_tar())); + const { create: tarC } = await Promise.resolve().then(() => (init_create(), create_exports)); await (0, import_promises4.mkdir)(baseInstallFolder, { recursive: true }); - await tar.c({ gzip: true, cwd: baseInstallFolder, file: import_path10.default.resolve(outputPath) }, installLocations.map((location) => { - return import_path10.default.relative(baseInstallFolder, location); + await tarC({ gzip: true, cwd: baseInstallFolder, file: import_path17.default.resolve(outputPath) }, installLocations.map((location) => { + return import_path17.default.relative(baseInstallFolder, location); })); if (this.json) { this.context.stdout.write(`${JSON.stringify(outputPath)} @@ -23128,9 +23088,9 @@ async function runMain(argv) { cwd: process.cwd(), engine }; - const code = await cli.run(argv, context); - if (code !== 0) { - process.exitCode ??= code; + const code2 = await cli.run(argv, context); + if (code2 !== 0) { + process.exitCode ??= code2; } } else { await engine.executePackageManagerRequest(request, { diff --git a/deps/corepack/package.json b/deps/corepack/package.json index 82dffa34405c23..04a12cdc80d95d 100644 --- a/deps/corepack/package.json +++ b/deps/corepack/package.json @@ -1,6 +1,6 @@ { "name": "corepack", - "version": "0.29.2", + "version": "0.29.3", "homepage": "https://github.com/nodejs/corepack#readme", "bugs": { "url": "https://github.com/nodejs/corepack/issues" @@ -18,35 +18,28 @@ "license": "MIT", "packageManager": "yarn@4.3.1+sha224.934d21773e22af4b69a7032a2d3b4cb38c1f7c019624777cc9916b23", "devDependencies": { - "@babel/core": "^7.14.3", - "@babel/plugin-transform-modules-commonjs": "^7.14.0", - "@babel/preset-typescript": "^7.13.0", - "@jest/globals": "^29.0.0", "@types/debug": "^4.1.5", - "@types/jest": "^29.0.0", "@types/node": "^20.4.6", "@types/proxy-from-env": "^1", "@types/semver": "^7.1.0", - "@types/tar": "^6.0.0", "@types/which": "^3.0.0", "@yarnpkg/eslint-config": "^2.0.0", "@yarnpkg/fslib": "^3.0.0-rc.48", "@zkochan/cmd-shim": "^6.0.0", - "babel-plugin-dynamic-import-node": "^2.3.3", "better-sqlite3": "^10.0.0", - "clipanion": "^3.0.1", + "clipanion": "patch:clipanion@npm%3A3.2.1#~/.yarn/patches/clipanion-npm-3.2.1-fc9187f56c.patch", "debug": "^4.1.1", "esbuild": "^0.21.0", "eslint": "^8.57.0", - "jest": "^29.0.0", "proxy-from-env": "^1.1.0", - "semver": "^7.5.2", + "semver": "^7.6.3", "supports-color": "^9.0.0", - "tar": "^6.2.1", + "tar": "^7.4.0", "tsx": "^4.16.2", "typescript": "^5.3.3", "undici": "^6.19.2", "v8-compile-cache": "^2.3.0", + "vitest": "^2.0.3", "which": "^4.0.0" }, "resolutions": { @@ -62,7 +55,7 @@ "postpack": "run clean", "rimraf": "node -e 'for(let i=2;i~EnginePointer(); + return *new (this) EnginePointer(std::move(other)); +} + +void EnginePointer::reset(ENGINE* engine_, bool finish_on_exit_) { + if (engine != nullptr) { + if (finish_on_exit) { + // This also does the equivalent of ENGINE_free. + ENGINE_finish(engine); + } else { + ENGINE_free(engine); + } + } + engine = engine_; + finish_on_exit = finish_on_exit_; +} + +ENGINE* EnginePointer::release() { + ENGINE* ret = engine; + engine = nullptr; + finish_on_exit = false; + return ret; +} + +EnginePointer EnginePointer::getEngineByName(const std::string_view name, + CryptoErrorList* errors) { + MarkPopErrorOnReturn mark_pop_error_on_return(errors); + EnginePointer engine(ENGINE_by_id(name.data())); + if (!engine) { + // Engine not found, try loading dynamically. + engine = EnginePointer(ENGINE_by_id("dynamic")); + if (engine) { + if (!ENGINE_ctrl_cmd_string(engine.get(), "SO_PATH", name.data(), 0) || + !ENGINE_ctrl_cmd_string(engine.get(), "LOAD", nullptr, 0)) { + engine.reset(); + } + } + } + return std::move(engine); +} + +bool EnginePointer::setAsDefault(uint32_t flags, CryptoErrorList* errors) { + if (engine == nullptr) return false; + ClearErrorOnReturn clear_error_on_return(errors); + return ENGINE_set_default(engine, flags) != 0; +} + +bool EnginePointer::init(bool finish_on_exit) { + if (engine == nullptr) return false; + if (finish_on_exit) setFinishOnExit(); + return ENGINE_init(engine) == 1; +} + +EVPKeyPointer EnginePointer::loadPrivateKey(const std::string_view key_name) { + if (engine == nullptr) return EVPKeyPointer(); + return EVPKeyPointer(ENGINE_load_private_key(engine, key_name.data(), nullptr, nullptr)); +} + +void EnginePointer::initEnginesOnce() { + static bool initialized = false; + if (!initialized) { + ENGINE_load_builtin_engines(); + ENGINE_register_all_complete(); + initialized = true; + } +} + +#endif // OPENSSL_NO_ENGINE + +} // namespace ncrypto diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc new file mode 100644 index 00000000000000..b3e6a57edc1b0e --- /dev/null +++ b/deps/ncrypto/ncrypto.cc @@ -0,0 +1,223 @@ +#include "ncrypto.h" +#include +#include +#include "openssl/bn.h" +#if OPENSSL_VERSION_MAJOR >= 3 +#include "openssl/provider.h" +#endif + +namespace ncrypto { + +// ============================================================================ + +ClearErrorOnReturn::ClearErrorOnReturn(CryptoErrorList* errors) : errors_(errors) { + ERR_clear_error(); +} + +ClearErrorOnReturn::~ClearErrorOnReturn() { + if (errors_ != nullptr) errors_->capture(); + ERR_clear_error(); +} + +int ClearErrorOnReturn::peeKError() { return ERR_peek_error(); } + +MarkPopErrorOnReturn::MarkPopErrorOnReturn(CryptoErrorList* errors) : errors_(errors) { + ERR_set_mark(); +} + +MarkPopErrorOnReturn::~MarkPopErrorOnReturn() { + if (errors_ != nullptr) errors_->capture(); + ERR_pop_to_mark(); +} + +int MarkPopErrorOnReturn::peekError() { return ERR_peek_error(); } + +CryptoErrorList::CryptoErrorList(CryptoErrorList::Option option) { + if (option == Option::CAPTURE_ON_CONSTRUCT) capture(); +} + +void CryptoErrorList::capture() { + errors_.clear(); + while(const auto err = ERR_get_error()) { + char buf[256]; + ERR_error_string_n(err, buf, sizeof(buf)); + errors_.emplace_front(buf); + } +} + +void CryptoErrorList::add(std::string error) { + errors_.push_back(error); +} + +std::optional CryptoErrorList::pop_back() { + if (errors_.empty()) return std::nullopt; + std::string error = errors_.back(); + errors_.pop_back(); + return error; +} + +std::optional CryptoErrorList::pop_front() { + if (errors_.empty()) return std::nullopt; + std::string error = errors_.front(); + errors_.pop_front(); + return error; +} + +// ============================================================================ +bool isFipsEnabled() { +#if OPENSSL_VERSION_MAJOR >= 3 + return EVP_default_properties_is_fips_enabled(nullptr) == 1; +#else + return FIPS_mode() == 1; +#endif +} + +bool setFipsEnabled(bool enable, CryptoErrorList* errors) { + if (isFipsEnabled() == enable) return true; + ClearErrorOnReturn clearErrorOnReturn(errors); +#if OPENSSL_VERSION_MAJOR >= 3 + return EVP_default_properties_enable_fips(nullptr, enable ? 1 : 0) == 1; +#else + return FIPS_mode_set(enable ? 1 : 0) == 1; +#endif +} + +bool testFipsEnabled() { +#if OPENSSL_VERSION_MAJOR >= 3 + OSSL_PROVIDER* fips_provider = nullptr; + if (OSSL_PROVIDER_available(nullptr, "fips")) { + fips_provider = OSSL_PROVIDER_load(nullptr, "fips"); + } + const auto enabled = fips_provider == nullptr ? 0 : + OSSL_PROVIDER_self_test(fips_provider) ? 1 : 0; +#else +#ifdef OPENSSL_FIPS + const auto enabled = FIPS_selftest() ? 1 : 0; +#else // OPENSSL_FIPS + const auto enabled = 0; +#endif // OPENSSL_FIPS +#endif + + return enabled; +} + +// ============================================================================ +// Bignum +BignumPointer::BignumPointer(BIGNUM* bignum) : bn_(bignum) {} + +BignumPointer::BignumPointer(BignumPointer&& other) noexcept + : bn_(other.release()) {} + +BignumPointer& BignumPointer::operator=(BignumPointer&& other) noexcept { + if (this == &other) return *this; + this->~BignumPointer(); + return *new (this) BignumPointer(std::move(other)); +} + +BignumPointer::~BignumPointer() { reset(); } + +void BignumPointer::reset(BIGNUM* bn) { + bn_.reset(bn); +} + +BIGNUM* BignumPointer::release() { + return bn_.release(); +} + +size_t BignumPointer::byteLength() { + if (bn_ == nullptr) return 0; + return BN_num_bytes(bn_.get()); +} + +std::vector BignumPointer::encode() { + return encodePadded(bn_.get(), byteLength()); +} + +std::vector BignumPointer::encodePadded(size_t size) { + return encodePadded(bn_.get(), size); +} + +std::vector BignumPointer::encode(const BIGNUM* bn) { + return encodePadded(bn, bn != nullptr ? BN_num_bytes(bn) : 0); +} + +std::vector BignumPointer::encodePadded(const BIGNUM* bn, size_t s) { + if (bn == nullptr) return std::vector(0); + size_t size = std::max(s, static_cast(BN_num_bytes(bn))); + std::vector buf(size); + BN_bn2binpad(bn, buf.data(), size); + return buf; +} + +bool BignumPointer::operator==(const BignumPointer& other) noexcept { + if (bn_ == nullptr && other.bn_ != nullptr) return false; + if (bn_ != nullptr && other.bn_ == nullptr) return false; + if (bn_ == nullptr && other.bn_ == nullptr) return true; + return BN_cmp(bn_.get(), other.bn_.get()) == 0; +} + +bool BignumPointer::operator==(const BIGNUM* other) noexcept { + if (bn_ == nullptr && other != nullptr) return false; + if (bn_ != nullptr && other == nullptr) return false; + if (bn_ == nullptr && other == nullptr) return true; + return BN_cmp(bn_.get(), other) == 0; +} + +// ============================================================================ +// Utility methods + +bool CSPRNG(void* buffer, size_t length) { + auto buf = reinterpret_cast(buffer); + do { + if (1 == RAND_status()) { +#if OPENSSL_VERSION_MAJOR >= 3 + if (1 == RAND_bytes_ex(nullptr, buf, length, 0)) { + return true; + } +#else + while (length > INT_MAX && 1 == RAND_bytes(buf, INT_MAX)) { + buf += INT_MAX; + length -= INT_MAX; + } + if (length <= INT_MAX && 1 == RAND_bytes(buf, static_cast(length))) + return true; +#endif + } +#if OPENSSL_VERSION_MAJOR >= 3 + const auto code = ERR_peek_last_error(); + // A misconfigured OpenSSL 3 installation may report 1 from RAND_poll() + // and RAND_status() but fail in RAND_bytes() if it cannot look up + // a matching algorithm for the CSPRNG. + if (ERR_GET_LIB(code) == ERR_LIB_RAND) { + const auto reason = ERR_GET_REASON(code); + if (reason == RAND_R_ERROR_INSTANTIATING_DRBG || + reason == RAND_R_UNABLE_TO_FETCH_DRBG || + reason == RAND_R_UNABLE_TO_CREATE_DRBG) { + return false; + } + } +#endif + } while (1 == RAND_poll()); + + return false; +} + +int NoPasswordCallback(char* buf, int size, int rwflag, void* u) { + return 0; +} + +int PasswordCallback(char* buf, int size, int rwflag, void* u) { + const Buffer* passphrase = static_cast(u); + if (passphrase != nullptr) { + size_t buflen = static_cast(size); + size_t len = passphrase->len; + if (buflen < len) + return -1; + memcpy(buf, reinterpret_cast(passphrase->data), len); + return len; + } + + return -1; +} + +} // namespace ncrypto diff --git a/deps/ncrypto/ncrypto.gyp b/deps/ncrypto/ncrypto.gyp new file mode 100644 index 00000000000000..cf9b7c6cdb6d2c --- /dev/null +++ b/deps/ncrypto/ncrypto.gyp @@ -0,0 +1,27 @@ +{ + 'variables': { + 'ncrypto_sources': [ + 'engine.cc', + 'ncrypto.cc', + 'ncrypto.h', + ], + }, + 'targets': [ + { + 'target_name': 'ncrypto', + 'type': 'static_library', + 'include_dirs': ['.'], + 'direct_dependent_settings': { + 'include_dirs': ['.'], + }, + 'sources': [ '<@(ncrypto_sources)' ], + 'conditions': [ + ['node_shared_openssl=="false"', { + 'dependencies': [ + '../openssl/openssl.gyp:openssl' + ] + }], + ] + }, + ] +} diff --git a/deps/ncrypto/ncrypto.h b/deps/ncrypto/ncrypto.h new file mode 100644 index 00000000000000..6fb66fe5234d85 --- /dev/null +++ b/deps/ncrypto/ncrypto.h @@ -0,0 +1,298 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include "openssl/bn.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifndef OPENSSL_NO_ENGINE +# include +#endif // !OPENSSL_NO_ENGINE +// The FIPS-related functions are only available +// when the OpenSSL itself was compiled with FIPS support. +#if defined(OPENSSL_FIPS) && OPENSSL_VERSION_MAJOR < 3 +# include +#endif // OPENSSL_FIPS + +#ifdef __GNUC__ +#define NCRYPTO_MUST_USE_RESULT __attribute__((warn_unused_result)) +#else +#define NCRYPTO_MUST_USE_RESULT +#endif + +namespace ncrypto { + +// ============================================================================ +// Utility macros + +#if NCRYPTO_DEVELOPMENT_CHECKS +#define NCRYPTO_STR(x) #x +#define NCRYPTO_REQUIRE(EXPR) \ + { \ + if (!(EXPR) { abort(); }) } + +#define NCRYPTO_FAIL(MESSAGE) \ + do { \ + std::cerr << "FAIL: " << (MESSAGE) << std::endl; \ + abort(); \ + } while (0); +#define NCRYPTO_ASSERT_EQUAL(LHS, RHS, MESSAGE) \ + do { \ + if (LHS != RHS) { \ + std::cerr << "Mismatch: '" << LHS << "' - '" << RHS << "'" << std::endl; \ + NCRYPTO_FAIL(MESSAGE); \ + } \ + } while (0); +#define NCRYPTO_ASSERT_TRUE(COND) \ + do { \ + if (!(COND)) { \ + std::cerr << "Assert at line " << __LINE__ << " of file " << __FILE__ \ + << std::endl; \ + NCRYPTO_FAIL(NCRYPTO_STR(COND)); \ + } \ + } while (0); +#else +#define NCRYPTO_FAIL(MESSAGE) +#define NCRYPTO_ASSERT_EQUAL(LHS, RHS, MESSAGE) +#define NCRYPTO_ASSERT_TRUE(COND) +#endif + +#define NCRYPTO_DISALLOW_COPY(Name) \ + Name(const Name&) = delete; \ + Name& operator=(const Name&) = delete; +#define NCRYPTO_DISALLOW_MOVE(Name) \ + Name(Name&&) = delete; \ + Name& operator=(Name&&) = delete; +#define NCRYPTO_DISALLOW_COPY_AND_MOVE(Name) \ + NCRYPTO_DISALLOW_COPY(Name) \ + NCRYPTO_DISALLOW_MOVE(Name) +#define NCRYPTO_DISALLOW_NEW_DELETE() \ + void* operator new(size_t) = delete; \ + void operator delete(void*) = delete; + +// ============================================================================ +// Error handling utilities + +// Capture the current OpenSSL Error Stack. The stack will be ordered such +// that the error currently at the top of the stack is at the end of the +// list and the error at the bottom of the stack is at the beginning. +class CryptoErrorList final { +public: + enum class Option { + NONE, + CAPTURE_ON_CONSTRUCT + }; + CryptoErrorList(Option option = Option::CAPTURE_ON_CONSTRUCT); + + void capture(); + + // Add an error message to the end of the stack. + void add(std::string message); + + inline const std::string& peek_back() const { return errors_.back(); } + inline size_t size() const { return errors_.size(); } + inline bool empty() const { return errors_.empty(); } + + inline auto begin() const noexcept { return errors_.begin(); } + inline auto end() const noexcept { return errors_.end(); } + inline auto rbegin() const noexcept { return errors_.rbegin(); } + inline auto rend() const noexcept { return errors_.rend(); } + + std::optional pop_back(); + std::optional pop_front(); + +private: + std::list errors_; +}; + +// Forcibly clears the error stack on destruction. This stops stale errors +// from popping up later in the lifecycle of crypto operations where they +// would cause spurious failures. It is a rather blunt method, though, and +// ERR_clear_error() isn't necessarily cheap. +// +// If created with a pointer to a CryptoErrorList, the current OpenSSL error +// stack will be captured before clearing the error. +class ClearErrorOnReturn final { +public: + ClearErrorOnReturn(CryptoErrorList* errors = nullptr); + ~ClearErrorOnReturn(); + NCRYPTO_DISALLOW_COPY_AND_MOVE(ClearErrorOnReturn) + NCRYPTO_DISALLOW_NEW_DELETE() + + int peeKError(); + +private: + CryptoErrorList* errors_; +}; + +// Pop errors from OpenSSL's error stack that were added between when this +// was constructed and destructed. +// +// If created with a pointer to a CryptoErrorList, the current OpenSSL error +// stack will be captured before resetting the error to the mark. +class MarkPopErrorOnReturn final { +public: + MarkPopErrorOnReturn(CryptoErrorList* errors = nullptr); + ~MarkPopErrorOnReturn(); + NCRYPTO_DISALLOW_COPY_AND_MOVE(MarkPopErrorOnReturn) + NCRYPTO_DISALLOW_NEW_DELETE() + + int peekError(); + +private: + CryptoErrorList* errors_; +}; + +// ============================================================================ +// Various smart pointer aliases for OpenSSL types. + +template +struct FunctionDeleter { + void operator()(T* pointer) const { function(pointer); } + typedef std::unique_ptr Pointer; +}; + +template +using DeleteFnPtr = typename FunctionDeleter::Pointer; + +using BignumCtxPointer = DeleteFnPtr; +using BIOPointer = DeleteFnPtr; +using CipherCtxPointer = DeleteFnPtr; +using DHPointer = DeleteFnPtr; +using DSAPointer = DeleteFnPtr; +using DSASigPointer = DeleteFnPtr; +using ECDSASigPointer = DeleteFnPtr; +using ECPointer = DeleteFnPtr; +using ECGroupPointer = DeleteFnPtr; +using ECKeyPointer = DeleteFnPtr; +using ECPointPointer = DeleteFnPtr; +using EVPKeyCtxPointer = DeleteFnPtr; +using EVPKeyPointer = DeleteFnPtr; +using EVPMDCtxPointer = DeleteFnPtr; +using HMACCtxPointer = DeleteFnPtr; +using NetscapeSPKIPointer = DeleteFnPtr; +using PKCS8Pointer = DeleteFnPtr; +using RSAPointer = DeleteFnPtr; +using SSLCtxPointer = DeleteFnPtr; +using SSLPointer = DeleteFnPtr; +using SSLSessionPointer = DeleteFnPtr; +using X509Pointer = DeleteFnPtr; + +class BignumPointer final { + public: + BignumPointer() = default; + explicit BignumPointer(BIGNUM* bignum); + BignumPointer(BignumPointer&& other) noexcept; + BignumPointer& operator=(BignumPointer&& other) noexcept; + NCRYPTO_DISALLOW_COPY(BignumPointer) + ~BignumPointer(); + + bool operator==(const BignumPointer& other) noexcept; + bool operator==(const BIGNUM* other) noexcept; + inline bool operator==(std::nullptr_t) noexcept { return bn_ == nullptr; } + inline operator bool() const { return bn_ != nullptr; } + inline BIGNUM* get() const noexcept { return bn_.get(); } + void reset(BIGNUM* bn = nullptr); + BIGNUM* release(); + + size_t byteLength(); + + std::vector encode(); + std::vector encodePadded(size_t size); + + static std::vector encode(const BIGNUM* bn); + static std::vector encodePadded(const BIGNUM* bn, size_t size); + + private: + DeleteFnPtr bn_; +}; + +#ifndef OPENSSL_NO_ENGINE +class EnginePointer final { +public: + EnginePointer() = default; + + explicit EnginePointer(ENGINE* engine_, bool finish_on_exit = false); + EnginePointer(EnginePointer&& other) noexcept; + EnginePointer& operator=(EnginePointer&& other) noexcept; + NCRYPTO_DISALLOW_COPY(EnginePointer) + ~EnginePointer(); + + inline operator bool() const { return engine != nullptr; } + inline ENGINE* get() { return engine; } + inline void setFinishOnExit() { finish_on_exit = true; } + + void reset(ENGINE* engine_ = nullptr, bool finish_on_exit_ = false); + + bool setAsDefault(uint32_t flags, CryptoErrorList* errors = nullptr); + bool init(bool finish_on_exit = false); + EVPKeyPointer loadPrivateKey(const std::string_view key_name); + + // Release ownership of the ENGINE* pointer. + ENGINE* release(); + + // Retrieve an OpenSSL Engine instance by name. If the name does not + // identify a valid named engine, the returned EnginePointer will be + // empty. + static EnginePointer getEngineByName(const std::string_view name, + CryptoErrorList* errors = nullptr); + + // Call once when initializing OpenSSL at startup for the process. + static void initEnginesOnce(); + +private: + ENGINE* engine = nullptr; + bool finish_on_exit = false; +}; +#endif // !OPENSSL_NO_ENGINE + +// ============================================================================ +// FIPS +bool isFipsEnabled(); + +bool setFipsEnabled(bool enabled, CryptoErrorList* errors); + +bool testFipsEnabled(); + +// ============================================================================ +// Various utilities + +struct Buffer { + const void* data; + size_t len; +}; + +bool CSPRNG(void* buffer, size_t length) NCRYPTO_MUST_USE_RESULT; + +// This callback is used to avoid the default passphrase callback in OpenSSL +// which will typically prompt for the passphrase. The prompting is designed +// for the OpenSSL CLI, but works poorly for some environments like Node.js +// because it involves synchronous interaction with the controlling terminal, +// something we never want, and use this function to avoid it. +int NoPasswordCallback(char* buf, int size, int rwflag, void* u); + +int PasswordCallback(char* buf, int size, int rwflag, void* u); + +// ============================================================================ +// Version metadata +#define NCRYPTO_VERSION "0.0.1" + +enum { + NCRYPTO_VERSION_MAJOR = 0, + NCRYPTO_VERSION_MINOR = 0, + NCRYPTO_VERSION_REVISION = 1, +}; + +} // namespace ncrypto diff --git a/deps/ncrypto/unofficial.gni b/deps/ncrypto/unofficial.gni new file mode 100644 index 00000000000000..2d4edb079b241f --- /dev/null +++ b/deps/ncrypto/unofficial.gni @@ -0,0 +1,31 @@ +# This file is used by GN for building, which is NOT the build system used for +# building official binaries. +# Please edit the gyp files if you are making changes to build system. + +import("../../node.gni") +import("$node_v8_path/gni/v8.gni") + +# The actual configurations are put inside a template in unofficial.gni to +# prevent accidental edits from contributors. +template("ncrypto_gn_build") { + config("ncrypto_config") { + include_dirs = [ "." ] + cflags = [ + "-Wno-deprecated-declarations", + "-Wno-pessimizing-move", + "-Wno-shadow", + ] + } + + gypi_values = exec_script("../../tools/gypi_to_gn.py", + [ rebase_path("ncrypto.gyp") ], + "scope", + [ "ncrypto.gyp" ]) + + source_set(target_name) { + forward_variables_from(invoker, "*") + public_configs = [ ":ncrypto_config" ] + sources = gypi_values.ncrypto_sources + deps = [ "../openssl" ] + } +} diff --git a/deps/v8/include/v8-local-handle.h b/deps/v8/include/v8-local-handle.h index 46f7308431af0d..fd543ae3aaa4fa 100644 --- a/deps/v8/include/v8-local-handle.h +++ b/deps/v8/include/v8-local-handle.h @@ -398,8 +398,7 @@ class V8_TRIVIAL_ABI Local : public LocalBase, explicit Local(const Local& other, no_checking_tag do_not_check) : LocalBase(other), StackAllocated(do_not_check) {} - V8_INLINE explicit Local(const LocalBase& other) - : LocalBase(other) {} + V8_INLINE explicit Local(const LocalBase& other) : LocalBase(other) {} V8_INLINE static Local FromSlot(internal::Address* slot) { return Local(LocalBase::FromSlot(slot)); diff --git a/deps/v8/src/base/macros.h b/deps/v8/src/base/macros.h index 210885af3c3c0a..d404b6120ab86f 100644 --- a/deps/v8/src/base/macros.h +++ b/deps/v8/src/base/macros.h @@ -173,7 +173,7 @@ namespace base { // base::is_trivially_copyable will differ for these cases. template struct is_trivially_copyable { -#if V8_CC_MSVC +#if V8_CC_MSVC || (__GNUC__ == 12 && __GNUC_MINOR__ <= 2) // Unfortunately, MSVC 2015 is broken in that std::is_trivially_copyable can // be false even though it should be true according to the standard. // (status at 2018-02-26, observed on the msvc waterfall bot). @@ -181,6 +181,11 @@ struct is_trivially_copyable { // intended, so we reimplement this according to the standard. // See also https://developercommunity.visualstudio.com/content/problem/ // 170883/msvc-type-traits-stdis-trivial-is-bugged.html. + // + // GCC 12.1 and 12.2 are broken too, they are shipped by some stable Linux + // distributions, so the same polyfill is also used. + // See + // https://gcc.gnu.org/git/?p=gcc.git;a=commitdiff;h=aeba3e009b0abfccaf01797556445dbf891cc8dc static constexpr bool value = // Copy constructor is trivial or deleted. (std::is_trivially_copy_constructible::value || diff --git a/deps/v8/src/builtins/base.tq b/deps/v8/src/builtins/base.tq index 02812274b79e58..3179bc500a3853 100644 --- a/deps/v8/src/builtins/base.tq +++ b/deps/v8/src/builtins/base.tq @@ -1313,7 +1313,6 @@ extern macro ChangeUint32ToWord(uint32): uintptr; // Doesn't sign-extend. extern macro ChangeInt32ToInt64(int32): int64; // Sign-extends. extern macro ChangeUint32ToUint64(uint32): uint64; // Doesn't sign-extend. extern macro LoadNativeContext(Context): NativeContext; -extern macro GetContinuationPreservedEmbedderData(): Object; extern macro TruncateFloat64ToFloat16(float64): float16; extern macro TruncateFloat32ToFloat16(float32): float16; extern macro TruncateFloat64ToFloat32(float64): float32; diff --git a/deps/v8/src/builtins/promise-misc.tq b/deps/v8/src/builtins/promise-misc.tq index b769435d6386bc..1b0611f9b9559e 100644 --- a/deps/v8/src/builtins/promise-misc.tq +++ b/deps/v8/src/builtins/promise-misc.tq @@ -30,6 +30,11 @@ extern macro PromiseBuiltinsAssembler::IsIsolatePromiseHookEnabled(uint32): extern macro PromiseBuiltinsAssembler::PromiseHookFlags(): uint32; +namespace macros { +extern macro GetContinuationPreservedEmbedderData(): Object; +extern macro SetContinuationPreservedEmbedderData(Object): void; +} + namespace promise { extern macro IsFunctionWithPrototypeSlotMap(Map): bool; @@ -80,7 +85,7 @@ macro NewPromiseFulfillReactionJobTask( return new PromiseFulfillReactionJobTask{ map: PromiseFulfillReactionJobTaskMapConstant(), continuation_preserved_embedder_data: - GetContinuationPreservedEmbedderData(), + macros::GetContinuationPreservedEmbedderData(), argument, context: handlerContext, handler, @@ -108,7 +113,7 @@ macro NewPromiseRejectReactionJobTask( return new PromiseRejectReactionJobTask{ map: PromiseRejectReactionJobTaskMapConstant(), continuation_preserved_embedder_data: - GetContinuationPreservedEmbedderData(), + macros::GetContinuationPreservedEmbedderData(), argument, context: handlerContext, handler, @@ -303,7 +308,7 @@ macro NewPromiseReaction( return new PromiseReaction{ map: PromiseReactionMapConstant(), continuation_preserved_embedder_data: - GetContinuationPreservedEmbedderData(), + macros::GetContinuationPreservedEmbedderData(), next: next, reject_handler: rejectHandler, fulfill_handler: fulfillHandler, @@ -347,7 +352,7 @@ macro NewPromiseResolveThenableJobTask( return new PromiseResolveThenableJobTask{ map: PromiseResolveThenableJobTaskMapConstant(), continuation_preserved_embedder_data: - GetContinuationPreservedEmbedderData(), + macros::GetContinuationPreservedEmbedderData(), context: nativeContext, promise_to_resolve: promiseToResolve, thenable, @@ -452,4 +457,18 @@ transitioning macro BranchIfAccessCheckFailed( } } label HasAccess {} } + +@if(V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA) +transitioning javascript builtin GetContinuationPreservedEmbedderData( + js-implicit context: Context, receiver: JSAny)(): JSAny { + return UnsafeCast(macros::GetContinuationPreservedEmbedderData()); +} + +@if(V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA) +transitioning javascript builtin SetContinuationPreservedEmbedderData( + js-implicit context: Context, receiver: JSAny)(data: Object): Undefined { + macros::SetContinuationPreservedEmbedderData(data); + return Undefined; +} + } diff --git a/deps/v8/src/compiler/js-call-reducer.cc b/deps/v8/src/compiler/js-call-reducer.cc index 5e947298f995f1..768a9e8a112eec 100644 --- a/deps/v8/src/compiler/js-call-reducer.cc +++ b/deps/v8/src/compiler/js-call-reducer.cc @@ -5108,6 +5108,12 @@ Reduction JSCallReducer::ReduceJSCall(Node* node, case Builtin::kBigIntAsIntN: case Builtin::kBigIntAsUintN: return ReduceBigIntAsN(node, builtin); +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + case Builtin::kGetContinuationPreservedEmbedderData: + return ReduceGetContinuationPreservedEmbedderData(node); + case Builtin::kSetContinuationPreservedEmbedderData: + return ReduceSetContinuationPreservedEmbedderData(node); +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA default: break; } @@ -8780,6 +8786,39 @@ Reduction JSCallReducer::ReduceJSCallMathMinMaxWithArrayLike(Node* node, return ReplaceWithSubgraph(&a, subgraph); } +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA +Reduction JSCallReducer::ReduceGetContinuationPreservedEmbedderData( + Node* node) { + JSCallNode n(node); + Effect effect = n.effect(); + Control control = n.control(); + + Node* value = effect = graph()->NewNode( + simplified()->GetContinuationPreservedEmbedderData(), effect); + + ReplaceWithValue(node, value, effect, control); + return Replace(node); +} + +Reduction JSCallReducer::ReduceSetContinuationPreservedEmbedderData( + Node* node) { + JSCallNode n(node); + Effect effect = n.effect(); + Control control = n.control(); + + if (n.ArgumentCount() == 0) return NoChange(); + + effect = + graph()->NewNode(simplified()->SetContinuationPreservedEmbedderData(), + n.Argument(0), effect); + + Node* value = jsgraph()->UndefinedConstant(); + + ReplaceWithValue(node, value, effect, control); + return Replace(node); +} +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + CompilationDependencies* JSCallReducer::dependencies() const { return broker()->dependencies(); } diff --git a/deps/v8/src/compiler/js-call-reducer.h b/deps/v8/src/compiler/js-call-reducer.h index a8212a03542188..b7697e763f65d4 100644 --- a/deps/v8/src/compiler/js-call-reducer.h +++ b/deps/v8/src/compiler/js-call-reducer.h @@ -239,6 +239,11 @@ class V8_EXPORT_PRIVATE JSCallReducer final : public AdvancedReducer { base::Optional TryReduceJSCallMathMinMaxWithArrayLike(Node* node); Reduction ReduceJSCallMathMinMaxWithArrayLike(Node* node, Builtin builtin); +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + Reduction ReduceGetContinuationPreservedEmbedderData(Node* node); + Reduction ReduceSetContinuationPreservedEmbedderData(Node* node); +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + // The pendant to ReplaceWithValue when using GraphAssembler-based reductions. Reduction ReplaceWithSubgraph(JSCallReducerAssembler* gasm, Node* subgraph); std::pair ReleaseEffectAndControlFromAssembler( diff --git a/deps/v8/src/compiler/opcodes.h b/deps/v8/src/compiler/opcodes.h index e7a154bb055a5f..f52fe76fc16919 100644 --- a/deps/v8/src/compiler/opcodes.h +++ b/deps/v8/src/compiler/opcodes.h @@ -429,6 +429,14 @@ #define SIMPLIFIED_SPECULATIVE_NUMBER_UNOP_LIST(V) V(SpeculativeToNumber) +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA +#define SIMPLIFIED_CPED_OP_LIST(V) \ + V(GetContinuationPreservedEmbedderData) \ + V(SetContinuationPreservedEmbedderData) +#else +#define SIMPLIFIED_CPED_OP_LIST(V) +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + #define SIMPLIFIED_OTHER_OP_LIST(V) \ V(Allocate) \ V(AllocateRaw) \ @@ -534,7 +542,8 @@ V(TransitionElementsKind) \ V(TypeOf) \ V(Unsigned32Divide) \ - V(VerifyType) + V(VerifyType) \ + SIMPLIFIED_CPED_OP_LIST(V) #define SIMPLIFIED_SPECULATIVE_BIGINT_BINOP_LIST(V) \ V(SpeculativeBigIntAdd) \ diff --git a/deps/v8/src/compiler/simplified-lowering.cc b/deps/v8/src/compiler/simplified-lowering.cc index cc8221152a5d55..f1bd6f3630adae 100644 --- a/deps/v8/src/compiler/simplified-lowering.cc +++ b/deps/v8/src/compiler/simplified-lowering.cc @@ -4635,6 +4635,17 @@ class RepresentationSelector { SetOutput(node, LoadRepresentationOf(node->op()).representation()); return; +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + case IrOpcode::kGetContinuationPreservedEmbedderData: + SetOutput(node, MachineRepresentation::kTagged); + return; + + case IrOpcode::kSetContinuationPreservedEmbedderData: + ProcessInput(node, 0, UseInfo::AnyTagged()); + SetOutput(node, MachineRepresentation::kNone); + return; +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + default: FATAL( "Representation inference: unsupported opcode %i (%s), node #%i\n.", diff --git a/deps/v8/src/compiler/simplified-operator.cc b/deps/v8/src/compiler/simplified-operator.cc index b4c6019e58f574..5f3fb51fb584f7 100644 --- a/deps/v8/src/compiler/simplified-operator.cc +++ b/deps/v8/src/compiler/simplified-operator.cc @@ -1339,6 +1339,26 @@ struct SimplifiedOperatorGlobalCache final { kSpeculativeToBigIntBigInt64Operator; SpeculativeToBigIntOperator kSpeculativeToBigIntBigIntOperator; + +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + struct GetContinuationPreservedEmbedderDataOperator : public Operator { + GetContinuationPreservedEmbedderDataOperator() + : Operator(IrOpcode::kGetContinuationPreservedEmbedderData, + Operator::kNoThrow | Operator::kNoDeopt | Operator::kNoWrite, + "GetContinuationPreservedEmbedderData", 0, 1, 0, 1, 1, 0) {} + }; + GetContinuationPreservedEmbedderDataOperator + kGetContinuationPreservedEmbedderData; + + struct SetContinuationPreservedEmbedderDataOperator : public Operator { + SetContinuationPreservedEmbedderDataOperator() + : Operator(IrOpcode::kSetContinuationPreservedEmbedderData, + Operator::kNoThrow | Operator::kNoDeopt | Operator::kNoRead, + "SetContinuationPreservedEmbedderData", 1, 1, 0, 0, 1, 0) {} + }; + SetContinuationPreservedEmbedderDataOperator + kSetContinuationPreservedEmbedderData; +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA }; namespace { @@ -2198,6 +2218,18 @@ const Operator* SimplifiedOperatorBuilder::StoreField( 2, 1, 1, 0, 1, 0, store_access); } +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA +const Operator* +SimplifiedOperatorBuilder::GetContinuationPreservedEmbedderData() { + return &cache_.kGetContinuationPreservedEmbedderData; +} + +const Operator* +SimplifiedOperatorBuilder::SetContinuationPreservedEmbedderData() { + return &cache_.kSetContinuationPreservedEmbedderData; +} +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + const Operator* SimplifiedOperatorBuilder::LoadMessage() { return zone()->New(IrOpcode::kLoadMessage, Operator::kEliminatable, "LoadMessage", 1, 1, 1, 1, 1, 0); diff --git a/deps/v8/src/compiler/simplified-operator.h b/deps/v8/src/compiler/simplified-operator.h index bf8b43817988c1..1ba4dfd380477b 100644 --- a/deps/v8/src/compiler/simplified-operator.h +++ b/deps/v8/src/compiler/simplified-operator.h @@ -1218,6 +1218,11 @@ class V8_EXPORT_PRIVATE SimplifiedOperatorBuilder final const FastApiCallFunctionVector& c_candidate_functions, FeedbackSource const& feedback, CallDescriptor* descriptor); +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + const Operator* GetContinuationPreservedEmbedderData(); + const Operator* SetContinuationPreservedEmbedderData(); +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + private: Zone* zone() const { return zone_; } diff --git a/deps/v8/src/compiler/turboshaft/assembler.h b/deps/v8/src/compiler/turboshaft/assembler.h index 8493aca79ddc89..19b010c55375db 100644 --- a/deps/v8/src/compiler/turboshaft/assembler.h +++ b/deps/v8/src/compiler/turboshaft/assembler.h @@ -3855,6 +3855,16 @@ class TurboshaftAssemblerOpInterface } #endif // V8_ENABLE_WEBASSEMBLY +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + V GetContinuationPreservedEmbedderData() { + return ReduceIfReachableGetContinuationPreservedEmbedderData(); + } + + void SetContinuationPreservedEmbedderData(V data) { + ReduceIfReachableSetContinuationPreservedEmbedderData(data); + } +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + template V resolve(const V& v) { return v; diff --git a/deps/v8/src/compiler/turboshaft/graph-builder.cc b/deps/v8/src/compiler/turboshaft/graph-builder.cc index 4703885b5d6649..a749509f2d96f4 100644 --- a/deps/v8/src/compiler/turboshaft/graph-builder.cc +++ b/deps/v8/src/compiler/turboshaft/graph-builder.cc @@ -2263,6 +2263,14 @@ OpIndex GraphBuilder::Process( return OpIndex::Invalid(); } +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + case IrOpcode::kGetContinuationPreservedEmbedderData: + return __ GetContinuationPreservedEmbedderData(); + case IrOpcode::kSetContinuationPreservedEmbedderData: + __ SetContinuationPreservedEmbedderData(Map(node->InputAt(0))); + return OpIndex::Invalid(); +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + default: std::cerr << "unsupported node type: " << *node->op() << "\n"; node->Print(std::cerr); diff --git a/deps/v8/src/compiler/turboshaft/machine-lowering-reducer-inl.h b/deps/v8/src/compiler/turboshaft/machine-lowering-reducer-inl.h index 8f37ef00f7edc1..d451bb4af52a2a 100644 --- a/deps/v8/src/compiler/turboshaft/machine-lowering-reducer-inl.h +++ b/deps/v8/src/compiler/turboshaft/machine-lowering-reducer-inl.h @@ -3164,6 +3164,25 @@ class MachineLoweringReducer : public Next { } } +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + V REDUCE(GetContinuationPreservedEmbedderData)() { + return __ Load( + __ ExternalConstant( + ExternalReference::continuation_preserved_embedder_data(isolate_)), + LoadOp::Kind::RawAligned(), MemoryRepresentation::TaggedPointer()); + } + + OpIndex REDUCE(SetContinuationPreservedEmbedderData)(V data) { + __ Store( + __ ExternalConstant( + ExternalReference::continuation_preserved_embedder_data(isolate_)), + data, StoreOp::Kind::RawAligned(), + MemoryRepresentation::TaggedPointer(), + WriteBarrierKind::kNoWriteBarrier); + return OpIndex::Invalid(); + } +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + private: V BuildUint32Mod(V left, V right) { Label done(this); diff --git a/deps/v8/src/compiler/turboshaft/maglev-graph-building-phase.cc b/deps/v8/src/compiler/turboshaft/maglev-graph-building-phase.cc index e30cb4c32ed489..379532db613b85 100644 --- a/deps/v8/src/compiler/turboshaft/maglev-graph-building-phase.cc +++ b/deps/v8/src/compiler/turboshaft/maglev-graph-building-phase.cc @@ -994,6 +994,24 @@ class GraphBuilder { return maglev::ProcessResult::kContinue; } +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + maglev::ProcessResult Process( + maglev::GetContinuationPreservedEmbedderData* node, + const maglev::ProcessingState&) { + V data = __ GetContinuationPreservedEmbedderData(); + SetMap(node, data); + return maglev::ProcessResult::kContinue; + } + + maglev::ProcessResult Process( + maglev::SetContinuationPreservedEmbedderData* node, + const maglev::ProcessingState&) { + V data = Map(node->input(0)); + __ SetContinuationPreservedEmbedderData(data); + return maglev::ProcessResult::kContinue; + } +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + template maglev::ProcessResult Process(NodeT* node, const maglev::ProcessingState& state) { diff --git a/deps/v8/src/compiler/turboshaft/operations.h b/deps/v8/src/compiler/turboshaft/operations.h index fc1994105b37d5..5eabc6f755bb27 100644 --- a/deps/v8/src/compiler/turboshaft/operations.h +++ b/deps/v8/src/compiler/turboshaft/operations.h @@ -175,10 +175,19 @@ using Variable = SnapshotTable::Key; V(Switch) \ V(Deoptimize) +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA +#define TURBOSHAFT_CPED_OPERATION_LIST(V) \ + V(GetContinuationPreservedEmbedderData) \ + V(SetContinuationPreservedEmbedderData) +#else +#define TURBOSHAFT_CPED_OPERATION_LIST(V) +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + // These operations should be lowered to Machine operations during // MachineLoweringPhase. #define TURBOSHAFT_SIMPLIFIED_OPERATION_LIST(V) \ TURBOSHAFT_INTL_OPERATION_LIST(V) \ + TURBOSHAFT_CPED_OPERATION_LIST(V) \ V(ArgumentsLength) \ V(BigIntBinop) \ V(BigIntComparison) \ @@ -8115,6 +8124,47 @@ struct SetStackPointerOp : FixedArityOperationT<1, SetStackPointerOp> { #endif // V8_ENABLE_WEBASSEMBLY +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA +struct GetContinuationPreservedEmbedderDataOp + : FixedArityOperationT<0, GetContinuationPreservedEmbedderDataOp> { + static constexpr OpEffects effects = OpEffects().CanReadOffHeapMemory(); + + base::Vector outputs_rep() const { + return RepVector(); + } + + base::Vector inputs_rep( + ZoneVector& storage) const { + return {}; + } + + GetContinuationPreservedEmbedderDataOp() : Base() {} + + void Validate(const Graph& graph) const {} + + auto options() const { return std::tuple{}; } +}; + +struct SetContinuationPreservedEmbedderDataOp + : FixedArityOperationT<1, SetContinuationPreservedEmbedderDataOp> { + static constexpr OpEffects effects = OpEffects().CanWriteOffHeapMemory(); + + base::Vector outputs_rep() const { return {}; } + + base::Vector inputs_rep( + ZoneVector& storage) const { + return MaybeRepVector(); + } + + explicit SetContinuationPreservedEmbedderDataOp(V value) + : Base(value) {} + + void Validate(const Graph& graph) const {} + + auto options() const { return std::tuple{}; } +}; +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + #define OPERATION_EFFECTS_CASE(Name) Name##Op::EffectsIfStatic(), static constexpr base::Optional kOperationEffectsTable[kNumberOfOpcodes] = { diff --git a/deps/v8/src/compiler/typer.cc b/deps/v8/src/compiler/typer.cc index 9a346d134b9557..50ed2ae265d704 100644 --- a/deps/v8/src/compiler/typer.cc +++ b/deps/v8/src/compiler/typer.cc @@ -1192,6 +1192,16 @@ Type Typer::Visitor::TypeCall(Node* node) { return Type::Any(); } Type Typer::Visitor::TypeFastApiCall(Node* node) { return Type::Any(); } +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA +Type Typer::Visitor::TypeGetContinuationPreservedEmbedderData(Node* node) { + return Type::Any(); +} + +Type Typer::Visitor::TypeSetContinuationPreservedEmbedderData(Node* node) { + UNREACHABLE(); +} +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + #if V8_ENABLE_WEBASSEMBLY Type Typer::Visitor::TypeJSWasmCall(Node* node) { const JSWasmCallParameters& op_params = JSWasmCallParametersOf(node->op()); diff --git a/deps/v8/src/compiler/verifier.cc b/deps/v8/src/compiler/verifier.cc index e49766be1981c0..e04996d7bd00e8 100644 --- a/deps/v8/src/compiler/verifier.cc +++ b/deps/v8/src/compiler/verifier.cc @@ -1707,6 +1707,19 @@ void Verifier::Visitor::Check(Node* node, const AllNodes& all) { CHECK_GE(value_count, 1); CheckValueInputIs(node, 0, Type::Any()); // receiver break; +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + case IrOpcode::kGetContinuationPreservedEmbedderData: + CHECK_EQ(value_count, 0); + CHECK_EQ(effect_count, 1); + CheckTypeIs(node, Type::Any()); + break; + case IrOpcode::kSetContinuationPreservedEmbedderData: + CHECK_EQ(value_count, 1); + CHECK_EQ(effect_count, 1); + CheckValueInputIs(node, 0, Type::Any()); + CheckNotTyped(node); + break; +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA case IrOpcode::kSLVerifierHint: // SLVerifierHint is internal to SimplifiedLowering and should never be // seen by the verifier. diff --git a/deps/v8/src/d8/d8.cc b/deps/v8/src/d8/d8.cc index 715ee06c0d075f..7740363d8a355f 100644 --- a/deps/v8/src/d8/d8.cc +++ b/deps/v8/src/d8/d8.cc @@ -2733,6 +2733,20 @@ void Shell::SetTimeout(const v8::FunctionCallbackInfo& info) { PerIsolateData::Get(isolate)->SetTimeout(callback, context); } +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA +void Shell::GetContinuationPreservedEmbedderData( + const v8::FunctionCallbackInfo& info) { + info.GetReturnValue().Set( + info.GetIsolate()->GetContinuationPreservedEmbedderData()); +} +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + +void Shell::GetExtrasBindingObject( + const v8::FunctionCallbackInfo& info) { + Local context = info.GetIsolate()->GetCurrentContext(); + info.GetReturnValue().Set(context->GetExtrasBindingObject()); +} + void Shell::ReadCodeTypeAndArguments( const v8::FunctionCallbackInfo& info, int index, CodeType* code_type, Local* arguments) { @@ -3547,8 +3561,15 @@ Local Shell::CreateD8Template(Isolate* isolate) { FunctionTemplate::New(isolate, ProfilerTriggerSample)); d8_template->Set(isolate, "profiler", profiler_template); } +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + d8_template->Set( + isolate, "getContinuationPreservedEmbedderDataViaAPIForTesting", + FunctionTemplate::New(isolate, GetContinuationPreservedEmbedderData)); +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA d8_template->Set(isolate, "terminate", FunctionTemplate::New(isolate, Terminate)); + d8_template->Set(isolate, "getExtrasBindingObject", + FunctionTemplate::New(isolate, GetExtrasBindingObject)); if (!options.omit_quit) { d8_template->Set(isolate, "quit", FunctionTemplate::New(isolate, Quit)); } diff --git a/deps/v8/src/d8/d8.h b/deps/v8/src/d8/d8.h index b1388f129b881d..f8d42f970df5d0 100644 --- a/deps/v8/src/d8/d8.h +++ b/deps/v8/src/d8/d8.h @@ -665,6 +665,15 @@ class Shell : public i::AllStatic { // the "mkdir -p" command. static void MakeDirectory(const v8::FunctionCallbackInfo& info); static void RemoveDirectory(const v8::FunctionCallbackInfo& info); + +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + static void GetContinuationPreservedEmbedderData( + const v8::FunctionCallbackInfo& info); +#endif // V8_ENABLE_CONTINUATION_PRESERVER_EMBEDDER_DATA + + static void GetExtrasBindingObject( + const v8::FunctionCallbackInfo& info); + static MaybeLocal HostImportModuleDynamically( Local context, Local host_defined_options, Local resource_name, Local specifier, diff --git a/deps/v8/src/debug/debug-evaluate.cc b/deps/v8/src/debug/debug-evaluate.cc index 8e0acf3b817945..1fa6a8e1cd8ebc 100644 --- a/deps/v8/src/debug/debug-evaluate.cc +++ b/deps/v8/src/debug/debug-evaluate.cc @@ -866,6 +866,9 @@ DebugInfo::SideEffectState BuiltinGetSideEffectState(Builtin id) { case Builtin::kConstructWithArrayLike: case Builtin::kGetOwnPropertyDescriptor: case Builtin::kOrdinaryGetOwnPropertyDescriptor: +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + case Builtin::kGetContinuationPreservedEmbedderData: +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA return DebugInfo::kHasNoSideEffect; #ifdef V8_INTL_SUPPORT diff --git a/deps/v8/src/init/bootstrapper.cc b/deps/v8/src/init/bootstrapper.cc index 647f38943a600e..0d5b3ec7e9a455 100644 --- a/deps/v8/src/init/bootstrapper.cc +++ b/deps/v8/src/init/bootstrapper.cc @@ -6383,6 +6383,18 @@ bool Genesis::InstallExtrasBindings() { SimpleInstallFunction(isolate(), extras_binding, "trace", Builtin::kTrace, 5, true); +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + // binding.getContinuationPreservedEmbedderData() + SimpleInstallFunction( + isolate(), extras_binding, "getContinuationPreservedEmbedderData", + Builtin::kGetContinuationPreservedEmbedderData, 0, true); + + // binding.setContinuationPreservedEmbedderData(value) + SimpleInstallFunction( + isolate(), extras_binding, "setContinuationPreservedEmbedderData", + Builtin::kSetContinuationPreservedEmbedderData, 1, true); +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + InitializeConsole(extras_binding); native_context()->set_extras_binding_object(*extras_binding); diff --git a/deps/v8/src/maglev/maglev-graph-builder.cc b/deps/v8/src/maglev/maglev-graph-builder.cc index efcdd6d2028a5e..3b99a44a04e1dc 100644 --- a/deps/v8/src/maglev/maglev-graph-builder.cc +++ b/deps/v8/src/maglev/maglev-graph-builder.cc @@ -6525,6 +6525,21 @@ ReduceResult MaglevGraphBuilder::TryReduceStringPrototypeLocaleCompare( #endif } +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA +ReduceResult MaglevGraphBuilder::TryReduceGetContinuationPreservedEmbedderData( + compiler::JSFunctionRef target, CallArguments& args) { + return AddNewNode({}); +} + +ReduceResult MaglevGraphBuilder::TryReduceSetContinuationPreservedEmbedderData( + compiler::JSFunctionRef target, CallArguments& args) { + if (args.count() == 0) return ReduceResult::Fail(); + + AddNewNode({GetTaggedValue(args[0])}); + return GetRootConstant(RootIndex::kUndefinedValue); +} +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + template ReduceResult MaglevGraphBuilder::TryBuildLoadDataView(const CallArguments& args, ExternalArrayType type) { diff --git a/deps/v8/src/maglev/maglev-graph-builder.h b/deps/v8/src/maglev/maglev-graph-builder.h index bf242495aa4c82..e997e2f6ff846f 100644 --- a/deps/v8/src/maglev/maglev-graph-builder.h +++ b/deps/v8/src/maglev/maglev-graph-builder.h @@ -1690,31 +1690,40 @@ class MaglevGraphBuilder { ExternalArrayType type, Function&& getValue); -#define MAGLEV_REDUCED_BUILTIN(V) \ - V(ArrayForEach) \ - V(ArrayIsArray) \ - V(DataViewPrototypeGetInt8) \ - V(DataViewPrototypeSetInt8) \ - V(DataViewPrototypeGetInt16) \ - V(DataViewPrototypeSetInt16) \ - V(DataViewPrototypeGetInt32) \ - V(DataViewPrototypeSetInt32) \ - V(DataViewPrototypeGetFloat64) \ - V(DataViewPrototypeSetFloat64) \ - V(FunctionPrototypeCall) \ - V(FunctionPrototypeHasInstance) \ - V(ObjectPrototypeHasOwnProperty) \ - V(MathCeil) \ - V(MathFloor) \ - V(MathPow) \ - V(ArrayPrototypePush) \ - V(ArrayPrototypePop) \ - V(MathRound) \ - V(StringConstructor) \ - V(StringFromCharCode) \ - V(StringPrototypeCharCodeAt) \ - V(StringPrototypeCodePointAt) \ - V(StringPrototypeLocaleCompare) \ +#ifdef V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA +#define CONTINUATION_PRESERVED_EMBEDDER_DATA_LIST(V) \ + V(GetContinuationPreservedEmbedderData) \ + V(SetContinuationPreservedEmbedderData) +#else +#define CONTINUATION_PRESERVED_EMBEDDER_DATA_LIST(V) +#endif // V8_ENABLE_CONTINUATION_PRESERVED_EMBEDDER_DATA + +#define MAGLEV_REDUCED_BUILTIN(V) \ + V(ArrayForEach) \ + V(ArrayIsArray) \ + V(DataViewPrototypeGetInt8) \ + V(DataViewPrototypeSetInt8) \ + V(DataViewPrototypeGetInt16) \ + V(DataViewPrototypeSetInt16) \ + V(DataViewPrototypeGetInt32) \ + V(DataViewPrototypeSetInt32) \ + V(DataViewPrototypeGetFloat64) \ + V(DataViewPrototypeSetFloat64) \ + V(FunctionPrototypeCall) \ + V(FunctionPrototypeHasInstance) \ + V(ObjectPrototypeHasOwnProperty) \ + V(MathCeil) \ + V(MathFloor) \ + V(MathPow) \ + V(ArrayPrototypePush) \ + V(ArrayPrototypePop) \ + V(MathRound) \ + V(StringConstructor) \ + V(StringFromCharCode) \ + V(StringPrototypeCharCodeAt) \ + V(StringPrototypeCodePointAt) \ + V(StringPrototypeLocaleCompare) \ + CONTINUATION_PRESERVED_EMBEDDER_DATA_LIST(V) \ IEEE_754_UNARY_LIST(V) #define DEFINE_BUILTIN_REDUCER(Name, ...) \ diff --git a/deps/v8/src/maglev/maglev-ir.cc b/deps/v8/src/maglev/maglev-ir.cc index c2f9bd9fb779d8..c58e86290bd5f3 100644 --- a/deps/v8/src/maglev/maglev-ir.cc +++ b/deps/v8/src/maglev/maglev-ir.cc @@ -5735,6 +5735,36 @@ void CheckTypedArrayNotDetached::GenerateCode(MaglevAssembler* masm, __ DeoptIfBufferDetached(object, scratch, this); } +void GetContinuationPreservedEmbedderData::SetValueLocationConstraints() { + DefineAsRegister(this); +} + +void GetContinuationPreservedEmbedderData::GenerateCode( + MaglevAssembler* masm, const ProcessingState& state) { + Register result = ToRegister(this->result()); + MaglevAssembler::ScratchRegisterScope temps(masm); + Register scratch = temps.GetDefaultScratchRegister(); + MemOperand reference = __ ExternalReferenceAsOperand( + ExternalReference::continuation_preserved_embedder_data(masm->isolate()), + scratch); + __ Move(result, reference); +} + +void SetContinuationPreservedEmbedderData::SetValueLocationConstraints() { + UseRegister(data_input()); +} + +void SetContinuationPreservedEmbedderData::GenerateCode( + MaglevAssembler* masm, const ProcessingState& state) { + Register data = ToRegister(data_input()); + MaglevAssembler::ScratchRegisterScope temps(masm); + Register scratch = temps.GetDefaultScratchRegister(); + MemOperand reference = __ ExternalReferenceAsOperand( + ExternalReference::continuation_preserved_embedder_data(masm->isolate()), + scratch); + __ Move(reference, data); +} + namespace { template diff --git a/deps/v8/src/maglev/maglev-ir.h b/deps/v8/src/maglev/maglev-ir.h index f66f5b50ec06a5..4c8882be60bdc7 100644 --- a/deps/v8/src/maglev/maglev-ir.h +++ b/deps/v8/src/maglev/maglev-ir.h @@ -261,6 +261,7 @@ class MergePointInterpreterFrameState; V(ToString) \ V(NumberToString) \ V(UpdateJSArrayLength) \ + V(GetContinuationPreservedEmbedderData) \ CONSTANT_VALUE_NODE_LIST(V) \ INT32_OPERATIONS_NODE_LIST(V) \ FLOAT64_OPERATIONS_NODE_LIST(V) \ @@ -324,6 +325,7 @@ class MergePointInterpreterFrameState; V(ThrowIfNotSuperConstructor) \ V(TransitionElementsKind) \ V(TransitionElementsKindOrCheckMap) \ + V(SetContinuationPreservedEmbedderData) \ GAP_MOVE_NODE_LIST(V) \ VALUE_NODE_LIST(V) @@ -8729,6 +8731,42 @@ class TransitionElementsKindOrCheckMap const compiler::MapRef transition_target_; }; +class GetContinuationPreservedEmbedderData + : public FixedInputValueNodeT<0, GetContinuationPreservedEmbedderData> { + using Base = FixedInputValueNodeT<0, GetContinuationPreservedEmbedderData>; + + public: + explicit GetContinuationPreservedEmbedderData(uint64_t bitfield) + : Base(bitfield) {} + + void SetValueLocationConstraints(); + void GenerateCode(MaglevAssembler*, const ProcessingState&); + void PrintParams(std::ostream&, MaglevGraphLabeller*) const {} + + static constexpr OpProperties kProperties = + OpProperties::CanRead() | OpProperties::TaggedValue(); +}; + +class SetContinuationPreservedEmbedderData + : public FixedInputNodeT<1, SetContinuationPreservedEmbedderData> { + using Base = FixedInputNodeT<1, SetContinuationPreservedEmbedderData>; + + public: + explicit SetContinuationPreservedEmbedderData(uint64_t bitfield) + : Base(bitfield) {} + + static constexpr + typename Base::InputTypes kInputTypes{ValueRepresentation::kTagged}; + + Input& data_input() { return input(0); } + + void SetValueLocationConstraints(); + void GenerateCode(MaglevAssembler*, const ProcessingState&); + void PrintParams(std::ostream&, MaglevGraphLabeller*) const {} + + static constexpr OpProperties kProperties = OpProperties::CanWrite(); +}; + class ControlNode : public NodeBase { public: // A "hole" in control flow is a control node that unconditionally interrupts diff --git a/deps/v8/src/torque/torque-parser.cc b/deps/v8/src/torque/torque-parser.cc index b47a1110b5e465..ad8fa0986dbf9f 100644 --- a/deps/v8/src/torque/torque-parser.cc +++ b/deps/v8/src/torque/torque-parser.cc @@ -670,36 +670,6 @@ base::Optional MakeTorqueMacroDeclaration( return ParseResult{result}; } -base::Optional MakeTorqueBuiltinDeclaration( - ParseResultIterator* child_results) { - const bool has_custom_interface_descriptor = HasAnnotation( - child_results, ANNOTATION_CUSTOM_INTERFACE_DESCRIPTOR, "builtin"); - auto transitioning = child_results->NextAs(); - auto javascript_linkage = child_results->NextAs(); - auto name = child_results->NextAs(); - if (!IsUpperCamelCase(name->value)) { - NamingConventionError("Builtin", name, "UpperCamelCase"); - } - - auto generic_parameters = child_results->NextAs(); - LintGenericParameters(generic_parameters); - - auto args = child_results->NextAs(); - auto return_type = child_results->NextAs(); - auto body = child_results->NextAs>(); - CallableDeclaration* declaration = MakeNode( - transitioning, javascript_linkage, name, args, return_type, - has_custom_interface_descriptor, body); - Declaration* result = declaration; - if (generic_parameters.empty()) { - if (!body) ReportError("A non-generic declaration needs a body."); - } else { - result = - MakeNode(generic_parameters, declaration); - } - return ParseResult{result}; -} - base::Optional MakeConstDeclaration( ParseResultIterator* child_results) { auto name = child_results->NextAs(); @@ -961,6 +931,46 @@ int GetAnnotationValue(const AnnotationSet& annotations, const char* name, return opt_value.has_value() ? *opt_value : default_value; } +base::Optional MakeTorqueBuiltinDeclaration( + ParseResultIterator* child_results) { + AnnotationSet annotations( + child_results, {ANNOTATION_CUSTOM_INTERFACE_DESCRIPTOR}, {ANNOTATION_IF}); + const bool has_custom_interface_descriptor = + annotations.Contains(ANNOTATION_CUSTOM_INTERFACE_DESCRIPTOR); + auto transitioning = child_results->NextAs(); + auto javascript_linkage = child_results->NextAs(); + auto name = child_results->NextAs(); + if (!IsUpperCamelCase(name->value)) { + NamingConventionError("Builtin", name, "UpperCamelCase"); + } + + auto generic_parameters = child_results->NextAs(); + LintGenericParameters(generic_parameters); + + auto args = child_results->NextAs(); + auto return_type = child_results->NextAs(); + auto body = child_results->NextAs>(); + CallableDeclaration* declaration = MakeNode( + transitioning, javascript_linkage, name, args, return_type, + has_custom_interface_descriptor, body); + Declaration* result = declaration; + if (generic_parameters.empty()) { + if (!body) ReportError("A non-generic declaration needs a body."); + } else { + result = + MakeNode(generic_parameters, declaration); + } + std::vector results; + if (base::Optional condition = + annotations.GetStringParam(ANNOTATION_IF)) { + if (!BuildFlags::GetFlag(*condition, ANNOTATION_IF)) { + return ParseResult{std::move(results)}; + } + } + results.push_back(result); + return ParseResult{std::move(results)}; +} + InstanceTypeConstraints MakeInstanceTypeConstraints( const AnnotationSet& annotations) { InstanceTypeConstraints result; @@ -2863,7 +2873,7 @@ struct TorqueGrammar : Grammar { CheckIf(Token("javascript")), Token("builtin"), &name, TryOrDefault(&genericParameters), ¶meterListAllowVararg, &returnType, &optionalBody}, - AsSingletonVector()), + MakeTorqueBuiltinDeclaration), Rule({CheckIf(Token("transitioning")), &name, &genericSpecializationTypeList, ¶meterListAllowVararg, &returnType, optionalLabelList, &block}, diff --git a/deps/v8/test/mjsunit/extras-cped.js b/deps/v8/test/mjsunit/extras-cped.js new file mode 100644 index 00000000000000..acbffa8a9b37e2 --- /dev/null +++ b/deps/v8/test/mjsunit/extras-cped.js @@ -0,0 +1,85 @@ +// Copyright 2024 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +const { + getContinuationPreservedEmbedderData, + setContinuationPreservedEmbedderData, +} = d8.getExtrasBindingObject(); + + +// Basic set and get +const foo = { bar: 'baz' }; +setContinuationPreservedEmbedderData(foo); +assertEquals(foo, getContinuationPreservedEmbedderData()); + +// Captures at the point a continuation is created +{ + // Resolve path + setContinuationPreservedEmbedderData('init'); + let resolve; + const p = new Promise(r => { + resolve = r; + }); + + setContinuationPreservedEmbedderData('resolve'); + resolve(); + + setContinuationPreservedEmbedderData('continuation-created'); + p.then(deferredVerify('continuation-created')); + setContinuationPreservedEmbedderData('after'); + %PerformMicrotaskCheckpoint(); +} +{ + // Reject path + setContinuationPreservedEmbedderData('init'); + let reject; + const p = new Promise((_, r) => { + reject = r; + }); + + setContinuationPreservedEmbedderData('resolve'); + reject(); + + setContinuationPreservedEmbedderData('continuation-created'); + p.catch(deferredVerify('continuation-created')); + setContinuationPreservedEmbedderData('after'); + %PerformMicrotaskCheckpoint(); +} + +// Should propagate through thenables +function thenable(expected) { + const verify = deferredVerify(expected); + return { + then(fulfill) { + verify(); + fulfill(); + } + } +} + +async function testThenables() { + setContinuationPreservedEmbedderData('plain thenable'); + await thenable('plain thenable'); + + setContinuationPreservedEmbedderData('resolved thenable'); + await Promise.resolve(thenable('resolved thenable')); + + setContinuationPreservedEmbedderData('async returned thenable'); + await (async () => thenable('async returned thenable'))(); +} + +testThenables(); + +%PerformMicrotaskCheckpoint(); + +// +// Test helpers +// +function deferredVerify(expected) { + return () => { + assertEquals(expected, getContinuationPreservedEmbedderData()); + }; +} diff --git a/deps/v8/test/mjsunit/maglev/extras-cped.js b/deps/v8/test/mjsunit/maglev/extras-cped.js new file mode 100644 index 00000000000000..7d63c871d88b1a --- /dev/null +++ b/deps/v8/test/mjsunit/maglev/extras-cped.js @@ -0,0 +1,39 @@ +// Copyright 2024 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +const { + getExtrasBindingObject, + getContinuationPreservedEmbedderDataViaAPIForTesting, +} = d8; +const { + getContinuationPreservedEmbedderData, + setContinuationPreservedEmbedderData, +} = getExtrasBindingObject(); + +function testOpt(v) { + setContinuationPreservedEmbedderData(v); + return getContinuationPreservedEmbedderData(); +} + +const runTestOpt = (v) => { + const data = testOpt(v); + assertEquals(data, v); + assertEquals(getContinuationPreservedEmbedderDataViaAPIForTesting(), v); +}; + +%PrepareFunctionForOptimization(testOpt); + +runTestOpt(5); +runTestOpt(5.5); +runTestOpt({}); + +%OptimizeMaglevOnNextCall(testOpt); + +runTestOpt(5); +runTestOpt(5.5); +runTestOpt({}); + +assertTrue(isMaglevved(testOpt)); diff --git a/deps/v8/test/mjsunit/mjsunit.status b/deps/v8/test/mjsunit/mjsunit.status index f797279ecaf764..8fed543253c44d 100644 --- a/deps/v8/test/mjsunit/mjsunit.status +++ b/deps/v8/test/mjsunit/mjsunit.status @@ -486,6 +486,9 @@ 'compiler/regress-crbug-1201057': [SKIP], 'compiler/regress-crbug-1201082': [SKIP], + 'maglev/extras-cped': [SKIP], + 'turboshaft/extras-cped': [SKIP], + # These tests check that we can trace the compiler. 'tools/compiler-trace-flags': [SKIP], @@ -1432,6 +1435,9 @@ 'regress/regress-1049982-1': [SKIP], 'regress/regress-1049982-2': [SKIP], + 'maglev/extras-cped': [SKIP], + 'turboshaft/extras-cped': [SKIP], + # Wasm serialization relies on TurboFan to be available, hence does not work # in the 'nooptimization' variant. 'wasm/serialization-with-compilation-hints': [SKIP], @@ -2078,6 +2084,7 @@ # the deprecated map. Wiring this through in Maglev would be too messy to be # worth it. 'regress/regress-map-invalidation-2': [FAIL], + 'turboshaft/extras-cped': [SKIP], }], # variant in (stress_maglev, stress_maglev_future, stress_maglev_no_turbofan, maglev_no_turbofan) ['(variant in (stress_maglev, stress_maglev_future, stress_maglev_no_turbofan, maglev_no_turbofan)) and (arch != arm)', { diff --git a/deps/v8/test/mjsunit/turboshaft/extras-cped.js b/deps/v8/test/mjsunit/turboshaft/extras-cped.js new file mode 100644 index 00000000000000..d0ee141ae2df6a --- /dev/null +++ b/deps/v8/test/mjsunit/turboshaft/extras-cped.js @@ -0,0 +1,39 @@ +// Copyright 2024 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// Flags: --allow-natives-syntax + +const { + getExtrasBindingObject, + getContinuationPreservedEmbedderDataViaAPIForTesting, +} = d8; +const { + getContinuationPreservedEmbedderData, + setContinuationPreservedEmbedderData, +} = getExtrasBindingObject(); + +function testOpt(v) { + setContinuationPreservedEmbedderData(v); + return getContinuationPreservedEmbedderData(); +} + +const runTestOpt = (v) => { + const data = testOpt(v); + assertEquals(data, v); + assertEquals(getContinuationPreservedEmbedderDataViaAPIForTesting(), v); +}; + +%PrepareFunctionForOptimization(testOpt); + +runTestOpt(5); +runTestOpt(5.5); +runTestOpt({}); + +%OptimizeFunctionOnNextCall(testOpt); + +runTestOpt(5); +runTestOpt(5.5); +runTestOpt({}); + +assertTrue(isTurboFanned(testOpt)); diff --git a/doc/api/async_hooks.md b/doc/api/async_hooks.md index a5571c30be575d..07793fca90e445 100644 --- a/doc/api/async_hooks.md +++ b/doc/api/async_hooks.md @@ -704,7 +704,7 @@ import { executionAsyncId, executionAsyncResource, createHook, -} from 'async_hooks'; +} from 'node:async_hooks'; const sym = Symbol('state'); // Private symbol to avoid pollution createHook({ diff --git a/doc/api/cli.md b/doc/api/cli.md index 53dd6cdc98c668..efd729e622af85 100644 --- a/doc/api/cli.md +++ b/doc/api/cli.md @@ -490,40 +490,6 @@ For example, to run a module with "development" resolutions: node -C development app.js ``` -### `--test-coverage-exclude` - - - -> Stability: 1 - Experimental - -Excludes specific files from code coverage using a glob pattern, which can match -both absolute and relative file paths. - -This option may be specified multiple times to exclude multiple glob patterns. - -If both `--test-coverage-exclude` and `--test-coverage-include` are provided, -files must meet **both** criteria to be included in the coverage report. - -### `--test-coverage-include` - - - -> Stability: 1 - Experimental - -Includes specific files in code coverage using a glob pattern, which can match -both absolute and relative file paths. - -This option may be specified multiple times to include multiple glob patterns. - -If both `--test-coverage-exclude` and `--test-coverage-include` are provided, -files must meet **both** criteria to be included in the coverage report. - ### `--cpu-prof` > Stability: 1 - Experimental -Enable experimental support for the `https:` protocol in `import` specifiers. +Enable experimental support for the network inspection with Chrome DevTools. ### `--experimental-permission` @@ -1087,6 +1058,17 @@ added: v22.5.0 Enable the experimental [`node:sqlite`][] module. +### `--experimental-strip-types` + + + +> Stability: 1.0 - Early development + +Enable experimental type-stripping for TypeScript files. +For more information, see the [TypeScript type-stripping][] documentation. + ### `--experimental-test-coverage` -Activate inspector on `host:port`. Default is `127.0.0.1:9229`. +Activate inspector on `host:port`. Default is `127.0.0.1:9229`. If port `0` is +specified, a random available port will be used. V8 inspector integration allows tools such as Chrome DevTools and IDEs to debug and profile Node.js instances. The tools attach to Node.js instances via a @@ -1482,7 +1465,8 @@ added: v7.6.0 --> Activate inspector on `host:port` and break at start of user script. -Default `host:port` is `127.0.0.1:9229`. +Default `host:port` is `127.0.0.1:9229`. If port `0` is specified, +a random available port will be used. See [V8 Inspector integration for Node.js][] for further explanation on Node.js debugger. @@ -1495,7 +1479,8 @@ added: v7.6.0 Set the `host:port` to be used when the inspector is activated. Useful when activating the inspector by sending the `SIGUSR1` signal. -Default host is `127.0.0.1`. +Default host is `127.0.0.1`. If port `0` is specified, +a random available port will be used. See the [security warning][] below regarding the `host` parameter usage. @@ -1514,7 +1499,8 @@ added: v22.2.0 --> Activate inspector on `host:port` and wait for debugger to be attached. -Default `host:port` is `127.0.0.1:9229`. +Default `host:port` is `127.0.0.1:9229`. If port `0` is specified, +a random available port will be used. See [V8 Inspector integration for Node.js][] for further explanation on Node.js debugger. @@ -2068,7 +2054,7 @@ changes: > Stability: 1.2 - Release candidate This runs a specified command from a package.json's `"scripts"` object. -If no `"command"` is provided, it will list the available scripts. +If a missing `"command"` is provided, it will list the available scripts. `--run` will traverse up to the root directory and finds a `package.json` file to run the command from. @@ -2208,6 +2194,40 @@ added: The maximum number of test files that the test runner CLI will execute concurrently. The default value is `os.availableParallelism() - 1`. +### `--test-coverage-exclude` + + + +> Stability: 1 - Experimental + +Excludes specific files from code coverage using a glob pattern, which can match +both absolute and relative file paths. + +This option may be specified multiple times to exclude multiple glob patterns. + +If both `--test-coverage-exclude` and `--test-coverage-include` are provided, +files must meet **both** criteria to be included in the coverage report. + +### `--test-coverage-include` + + + +> Stability: 1 - Experimental + +Includes specific files in code coverage using a glob pattern, which can match +both absolute and relative file paths. + +This option may be specified multiple times to include multiple glob patterns. + +If both `--test-coverage-exclude` and `--test-coverage-include` are provided, +files must meet **both** criteria to be included in the coverage report. + ### `--test-force-exit` + +> Stability: 1 - Experimental + +* Returns: {boolean} `true` if any of the individual channels has a subscriber, + `false` if not. + +This is a helper method available on a [`TracingChannel`][] instance to check if +any of the [TracingChannel Channels][] have subscribers. A `true` is returned if +any of them have at least one subscriber, a `false` is returned otherwise. + +```mjs +import diagnostics_channel from 'node:diagnostics_channel'; + +const channels = diagnostics_channel.tracingChannel('my-channel'); + +if (channels.hasSubscribers) { + // Do something +} +``` + +```cjs +const diagnostics_channel = require('node:diagnostics_channel'); + +const channels = diagnostics_channel.tracingChannel('my-channel'); + +if (channels.hasSubscribers) { + // Do something +} +``` + ### TracingChannel Channels A TracingChannel is a collection of several diagnostics\_channels representing @@ -1092,6 +1129,13 @@ independently. Emitted when client starts a request. +`http.client.request.error` + +* `request` {http.ClientRequest} +* `error` {Error} + +Emitted when an error occurs during a client request. + `http.client.response.finish` * `request` {http.ClientRequest} diff --git a/doc/api/errors.md b/doc/api/errors.md index bf387569492dc3..4a577595ca41d1 100644 --- a/doc/api/errors.md +++ b/doc/api/errors.md @@ -3567,23 +3567,6 @@ removed: v10.0.0 Used by the `Node-API` when `Constructor.prototype` is not an object. - - -### `ERR_NETWORK_IMPORT_BAD_RESPONSE` - -> Stability: 1 - Experimental - -Response was received but was invalid when importing a module over the network. - - - -### `ERR_NETWORK_IMPORT_DISALLOWED` - -> Stability: 1 - Experimental - -A network module attempted to load another module that it is not allowed to -load. Likely this restriction is for security reasons. - ### `ERR_NO_LONGER_SUPPORTED` @@ -4016,6 +3999,16 @@ The public key in the certificate SubjectPublicKeyInfo could not be read. An error occurred trying to allocate memory. This should never happen. + + +#### `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING` + + + +Type stripping is not supported for files descendent of a `node_modules` directory. + [ES Module]: esm.md [ICU]: intl.md#internationalization-support [JSON Web Key Elliptic Curve Registry]: https://www.iana.org/assignments/jose/jose.xhtml#web-key-elliptic-curve diff --git a/doc/api/esm.md b/doc/api/esm.md index da5f6bf5a09044..ec84f154b7d799 100644 --- a/doc/api/esm.md +++ b/doc/api/esm.md @@ -697,71 +697,6 @@ spawn(execPath, [ }); ``` -## HTTPS and HTTP imports - -> Stability: 1 - Experimental - -Importing network based modules using `https:` and `http:` is supported under -the `--experimental-network-imports` flag. This allows web browser-like imports -to work in Node.js with a few differences due to application stability and -security concerns that are different when running in a privileged environment -instead of a browser sandbox. - -### Imports are limited to HTTP/1 - -Automatic protocol negotiation for HTTP/2 and HTTP/3 is not yet supported. - -### HTTP is limited to loopback addresses - -`http:` is vulnerable to man-in-the-middle attacks and is not allowed to be -used for addresses outside of the IPv4 address `127.0.0.0/8` (`127.0.0.1` to -`127.255.255.255`) and the IPv6 address `::1`. Support for `http:` is intended -to be used for local development. - -### Authentication is never sent to the destination server. - -`Authorization`, `Cookie`, and `Proxy-Authorization` headers are not sent to the -server. Avoid including user info in parts of imported URLs. A security model -for safely using these on the server is being worked on. - -### CORS is never checked on the destination server - -CORS is designed to allow a server to limit the consumers of an API to a -specific set of hosts. This is not supported as it does not make sense for a -server-based implementation. - -### Cannot load non-network dependencies - -These modules cannot access other modules that are not over `http:` or `https:`. -To still access local modules while avoiding the security concern, pass in -references to the local dependencies: - -```mjs -// file.mjs -import worker_threads from 'node:worker_threads'; -import { configure, resize } from 'https://example.com/imagelib.mjs'; -configure({ worker_threads }); -``` - -```mjs -// https://example.com/imagelib.mjs -let worker_threads; -export function configure(opts) { - worker_threads = opts.worker_threads; -} -export function resize(img, size) { - // Perform resizing in worker_thread to avoid main thread blocking -} -``` - -### Network-based loading is not enabled by default - -For now, the `--experimental-network-imports` flag is required to enable loading -resources over `http:` or `https:`. In the future, a different mechanism will be -used to enforce this. Opt-in is required to prevent transitive dependencies -inadvertently using potentially mutable state that could affect reliability -of Node.js applications. - ## Loaders @@ -804,8 +739,7 @@ does not determine whether the resolved URL protocol can be loaded, or whether the file extensions are permitted, instead these validations are applied by Node.js during the load phase (for example, if it was asked to load a URL that has a protocol that is -not `file:`, `data:`, `node:`, or if `--experimental-network-imports` -is enabled, `https:`). +not `file:`, `data:` or `node:`. The algorithm also tries to determine the format of the file based on the extension (see `ESM_FILE_FORMAT` algorithm below). If it does diff --git a/doc/api/index.md b/doc/api/index.md index 51915a78d90de4..0f3d4c8c4fec35 100644 --- a/doc/api/index.md +++ b/doc/api/index.md @@ -41,6 +41,7 @@ * [Modules: ECMAScript modules](esm.md) * [Modules: `node:module` API](module.md) * [Modules: Packages](packages.md) +* [Modules: TypeScript](typescript.md) * [Net](net.md) * [OS](os.md) * [Path](path.md) diff --git a/doc/api/inspector.md b/doc/api/inspector.md index 014581e7dc9c56..6886cc6a7fe467 100644 --- a/doc/api/inspector.md +++ b/doc/api/inspector.md @@ -488,6 +488,75 @@ Blocks until a client (existing or connected later) has sent An exception will be thrown if there is no active inspector. +## Integration with DevTools + +The `node:inspector` module provides an API for integrating with devtools that support Chrome DevTools Protocol. +DevTools frontends connected to a running Node.js instance can capture protocol events emitted from the instance +and display them accordingly to facilitate debugging. +The following methods broadcast a protocol event to all connected frontends. +The `params` passed to the methods can be optional, depending on the protocol. + +```js +// The `Network.requestWillBeSent` event will be fired. +inspector.Network.requestWillBeSent({ + requestId: 'request-id-1', + timestamp: Date.now() / 1000, + wallTime: Date.now(), + request: { + url: 'https://nodejs.org/en', + method: 'GET', + } +}); +``` + +### `inspector.Network.requestWillBeSent([params])` + + + +> Stability: 1 - Experimental + +* `params` {Object} + +This feature is only available with the `--experimental-network-inspection` flag enabled. + +Broadcasts the `Network.requestWillBeSent` event to connected frontends. This event indicates that +the application is about to send an HTTP request. + +### `inspector.Network.responseReceived([params])` + + + +> Stability: 1 - Experimental + +* `params` {Object} + +This feature is only available with the `--experimental-network-inspection` flag enabled. + +Broadcasts the `Network.responseReceived` event to connected frontends. This event indicates that +HTTP response is available. + +### `inspector.Network.loadingFinished([params])` + + + +> Stability: 1 - Experimental + +* `params` {Object} + +This feature is only available with the `--experimental-network-inspection` flag enabled. + +Broadcasts the `Network.loadingFinished` event to connected frontends. This event indicates that +HTTP request has finished loading. + ## Support of breakpoints The Chrome DevTools Protocol [`Debugger` domain][] allows an diff --git a/doc/api/module.md b/doc/api/module.md index 730776d984c562..503823d4ad7639 100644 --- a/doc/api/module.md +++ b/doc/api/module.md @@ -28,6 +28,8 @@ added: A list of the names of all modules provided by Node.js. Can be used to verify if a module is maintained by a third party or not. +Note: the list doesn't contain [prefix-only modules][] like `node:test`. + `module` in this context isn't the same object that's provided by the [module wrapper][]. To access it, require the `Module` module: @@ -715,7 +717,7 @@ behaviors. #### Import from HTTPS In current Node.js, specifiers starting with `https://` are experimental (see -[HTTPS and HTTP imports][]). +\[HTTPS and HTTP imports]\[]). The hook below registers hooks to enable rudimentary support for such specifiers. While this may seem like a significant improvement to Node.js core @@ -1052,7 +1054,6 @@ returned object contains the following keys: [Conditional exports]: packages.md#conditional-exports [Customization hooks]: #customization-hooks [ES Modules]: esm.md -[HTTPS and HTTP imports]: esm.md#https-and-http-imports [Source map v3 format]: https://sourcemaps.info/spec.html#h.mofvlxcwqzej [`"exports"`]: packages.md#exports [`--enable-source-maps`]: cli.md#--enable-source-maps @@ -1071,6 +1072,7 @@ returned object contains the following keys: [hooks]: #customization-hooks [load hook]: #loadurl-context-nextload [module wrapper]: modules.md#the-module-wrapper +[prefix-only modules]: modules.md#built-in-modules-with-mandatory-node-prefix [realm]: https://tc39.es/ecma262/#realm [source map include directives]: https://sourcemaps.info/spec.html#h.lmz475t4mvbx [transferrable objects]: worker_threads.md#portpostmessagevalue-transferlist diff --git a/doc/api/n-api.md b/doc/api/n-api.md index a9387733eb7c66..0727ca74d2f986 100644 --- a/doc/api/n-api.md +++ b/doc/api/n-api.md @@ -477,7 +477,7 @@ napiVersion: 6 --> ```c -napi_status napi_set_instance_data(node_api_nogc_env env, +napi_status napi_set_instance_data(node_api_basic_env env, void* data, napi_finalize finalize_cb, void* finalize_hint); @@ -509,7 +509,7 @@ napiVersion: 6 --> ```c -napi_status napi_get_instance_data(node_api_nogc_env env, +napi_status napi_get_instance_data(node_api_basic_env env, void** data); ``` @@ -611,16 +611,16 @@ when an instance of a native addon is unloaded. Notification of this event is delivered through the callbacks given to [`napi_add_env_cleanup_hook`][] and [`napi_set_instance_data`][]. -### `node_api_nogc_env` +### `node_api_basic_env` > Stability: 1 - Experimental This variant of `napi_env` is passed to synchronous finalizers -([`node_api_nogc_finalize`][]). There is a subset of Node-APIs which accept -a parameter of type `node_api_nogc_env` as their first argument. These APIs do +([`node_api_basic_finalize`][]). There is a subset of Node-APIs which accept +a parameter of type `node_api_basic_env` as their first argument. These APIs do not access the state of the JavaScript engine and are thus safe to call from synchronous finalizers. Passing a parameter of type `napi_env` to these APIs is -allowed, however, passing a parameter of type `node_api_nogc_env` to APIs that +allowed, however, passing a parameter of type `node_api_basic_env` to APIs that access the JavaScript engine state is not allowed. Attempting to do so without a cast will produce a compiler warning or an error when add-ons are compiled with flags which cause them to emit warnings and/or errors when incorrect @@ -791,7 +791,7 @@ typedef napi_value (*napi_callback)(napi_env, napi_callback_info); Unless for reasons discussed in [Object Lifetime Management][], creating a handle and/or callback scope inside a `napi_callback` is not necessary. -#### `node_api_nogc_finalize` +#### `node_api_basic_finalize` ```c -NODE_EXTERN napi_status napi_add_env_cleanup_hook(node_api_nogc_env env, +NODE_EXTERN napi_status napi_add_env_cleanup_hook(node_api_basic_env env, napi_cleanup_hook fun, void* arg); ``` @@ -1915,7 +1915,7 @@ napiVersion: 3 --> ```c -NAPI_EXTERN napi_status napi_remove_env_cleanup_hook(node_api_nogc_env env, +NAPI_EXTERN napi_status napi_remove_env_cleanup_hook(node_api_basic_env env, void (*fun)(void* arg), void* arg); ``` @@ -1944,7 +1944,7 @@ changes: ```c NAPI_EXTERN napi_status napi_add_async_cleanup_hook( - node_api_nogc_env env, + node_api_basic_env env, napi_async_cleanup_hook hook, void* arg, napi_async_cleanup_hook_handle* remove_handle); @@ -5533,7 +5533,7 @@ napiVersion: 5 napi_status napi_add_finalizer(napi_env env, napi_value js_object, void* finalize_data, - node_api_nogc_finalize finalize_cb, + node_api_basic_finalize finalize_cb, void* finalize_hint, napi_ref* result); ``` @@ -5574,7 +5574,7 @@ added: > Stability: 1 - Experimental ```c -napi_status node_api_post_finalizer(node_api_nogc_env env, +napi_status node_api_post_finalizer(node_api_basic_env env, napi_finalize finalize_cb, void* finalize_data, void* finalize_hint); @@ -5644,7 +5644,7 @@ Once created the async worker can be queued for execution using the [`napi_queue_async_work`][] function: ```c -napi_status napi_queue_async_work(node_api_nogc_env env, +napi_status napi_queue_async_work(node_api_basic_env env, napi_async_work work); ``` @@ -5736,7 +5736,7 @@ napiVersion: 1 --> ```c -napi_status napi_queue_async_work(node_api_nogc_env env, +napi_status napi_queue_async_work(node_api_basic_env env, napi_async_work work); ``` @@ -5757,7 +5757,7 @@ napiVersion: 1 --> ```c -napi_status napi_cancel_async_work(node_api_nogc_env env, +napi_status napi_cancel_async_work(node_api_basic_env env, napi_async_work work); ``` @@ -5961,7 +5961,7 @@ typedef struct { const char* release; } napi_node_version; -napi_status napi_get_node_version(node_api_nogc_env env, +napi_status napi_get_node_version(node_api_basic_env env, const napi_node_version** version); ``` @@ -5984,7 +5984,7 @@ napiVersion: 1 --> ```c -napi_status napi_get_version(node_api_nogc_env env, +napi_status napi_get_version(node_api_basic_env env, uint32_t* result); ``` @@ -6017,7 +6017,7 @@ napiVersion: 1 --> ```c -NAPI_EXTERN napi_status napi_adjust_external_memory(node_api_nogc_env env, +NAPI_EXTERN napi_status napi_adjust_external_memory(node_api_basic_env env, int64_t change_in_bytes, int64_t* result); ``` @@ -6234,7 +6234,7 @@ napiVersion: 2 --> ```c -NAPI_EXTERN napi_status napi_get_uv_event_loop(node_api_nogc_env env, +NAPI_EXTERN napi_status napi_get_uv_event_loop(node_api_basic_env env, struct uv_loop_s** loop); ``` @@ -6554,7 +6554,7 @@ napiVersion: 4 ```c NAPI_EXTERN napi_status -napi_ref_threadsafe_function(node_api_nogc_env env, napi_threadsafe_function func); +napi_ref_threadsafe_function(node_api_basic_env env, napi_threadsafe_function func); ``` * `[in] env`: The environment that the API is invoked under. @@ -6580,7 +6580,7 @@ napiVersion: 4 ```c NAPI_EXTERN napi_status -napi_unref_threadsafe_function(node_api_nogc_env env, napi_threadsafe_function func); +napi_unref_threadsafe_function(node_api_basic_env env, napi_threadsafe_function func); ``` * `[in] env`: The environment that the API is invoked under. @@ -6606,7 +6606,7 @@ napiVersion: 9 ```c NAPI_EXTERN napi_status -node_api_get_module_file_name(node_api_nogc_env env, const char** result); +node_api_get_module_file_name(node_api_basic_env env, const char** result); ``` @@ -6731,10 +6731,10 @@ the add-on's file name during loading. [`napi_wrap`]: #napi_wrap [`node-addon-api`]: https://github.com/nodejs/node-addon-api [`node_api.h`]: https://github.com/nodejs/node/blob/HEAD/src/node_api.h +[`node_api_basic_finalize`]: #node_api_basic_finalize [`node_api_create_external_string_latin1`]: #node_api_create_external_string_latin1 [`node_api_create_external_string_utf16`]: #node_api_create_external_string_utf16 [`node_api_create_syntax_error`]: #node_api_create_syntax_error -[`node_api_nogc_finalize`]: #node_api_nogc_finalize [`node_api_post_finalizer`]: #node_api_post_finalizer [`node_api_throw_syntax_error`]: #node_api_throw_syntax_error [`process.release`]: process.md#processrelease diff --git a/doc/api/sqlite.md b/doc/api/sqlite.md index 1b58529500d47b..ac17ecca640d21 100644 --- a/doc/api/sqlite.md +++ b/doc/api/sqlite.md @@ -6,7 +6,8 @@ added: v22.5.0 --> -> Stability: 1.1 - Active development +> Stability: 1.1 - Active development. Enable this API with the +> [`--experimental-sqlite`][] CLI flag. @@ -314,6 +315,7 @@ exception. | `BLOB` | `Uint8Array` | [SQL injection]: https://en.wikipedia.org/wiki/SQL_injection +[`--experimental-sqlite`]: cli.md#--experimental-sqlite [`sqlite3_changes64()`]: https://www.sqlite.org/c3ref/changes.html [`sqlite3_close_v2()`]: https://www.sqlite.org/c3ref/close.html [`sqlite3_exec()`]: https://www.sqlite.org/c3ref/exec.html diff --git a/doc/api/stream.md b/doc/api/stream.md index c189df15c42957..2d21c2b837f1c1 100644 --- a/doc/api/stream.md +++ b/doc/api/stream.md @@ -45,8 +45,11 @@ There are four fundamental stream types within Node.js: is written and read (for example, [`zlib.createDeflate()`][]). Additionally, this module includes the utility functions -[`stream.pipeline()`][], [`stream.finished()`][], [`stream.Readable.from()`][] -and [`stream.addAbortSignal()`][]. +[`stream.duplexPair()`][], +[`stream.pipeline()`][], +[`stream.finished()`][] +[`stream.Readable.from()`][], and +[`stream.addAbortSignal()`][]. ### Streams Promises API @@ -2675,6 +2678,30 @@ unless `emitClose` is set in false. Once `destroy()` has been called, any further calls will be a no-op and no further errors except from `_destroy()` may be emitted as `'error'`. +#### `stream.duplexPair([options])` + + + +* `options` {Object} A value to pass to both [`Duplex`][] constructors, + to set options such as buffering. +* Returns: {Array} of two [`Duplex`][] instances. + +The utility function `duplexPair` returns an Array with two items, +each being a `Duplex` stream connected to the other side: + +```js +const [ sideA, sideB ] = duplexPair(); +``` + +Whatever is written to one stream is made readable on the other. It provides +behavior analogous to a network connection, where the data written by the client +becomes readable by the server, and vice-versa. + +The Duplex streams are symmetrical; one or the other may be used without any +difference in behavior. + ### `stream.finished(stream[, options], callback)` + +The absolute path of the test file that created the current test. If a test file +imports additional modules that generate tests, the imported tests will return +the path of the root test file. + ### `context.fullName` + +The absolute path of the test file that created the current suite. If a test +file imports additional modules that generate suites, the imported suites will +return the path of the root test file. + ### `context.name` + +* `fd` {number} A file descriptor associated with a TTY. +* `options` {Object} Options passed to parent `net.Socket`, + see `options` of [`net.Socket` constructor][]. +* Returns {tty.ReadStream} + +Creates a `ReadStream` for `fd` associated with a TTY. + +### `new tty.WriteStream(fd)` + + + +* `fd` {number} A file descriptor associated with a TTY. +* Returns {tty.WriteStream} + +Creates a `WriteStream` for `fd` associated with a TTY. + ### Event: `'resize'` + +> Stability: 1.0 - Early development + +The flag [`--experimental-strip-types`][] enables Node.js to run TypeScript +files that contain only type annotations. Such files contain no TypeScript +features that require transformation, such as enums or namespaces. Node.js will +replace inline type annotations with whitespace, and no type checking is +performed. TypeScript features that depend on settings within `tsconfig.json`, +such as paths or converting newer JavaScript syntax to older standards, are +intentionally unsupported. To get fuller TypeScript support, including support +for enums and namespaces and paths, see [Full TypeScript support][]. + +The type stripping feature is designed to be lightweight. +By intentionally not supporting syntaxes that require JavaScript code +generation, and by replacing inline types with whitespace, Node.js can run +TypeScript code without the need for source maps. + +### Determining module system + +Node.js supports both [CommonJS][] and [ES Modules][] syntax in TypeScript +files. Node.js will not convert from one module system to another; if you want +your code to run as an ES module, you must use `import` and `export` syntax, and +if you want your code to run as CommonJS you must use `require` and +`module.exports`. + +* `.ts` files will have their module system determined [the same way as `.js` + files.][] To use `import` and `export` syntax, add `"type": "module"` to the + nearest parent `package.json`. +* `.mts` files will always be run as ES modules, similar to `.mjs` files. +* `.cts` files will always be run as CommonJS modules, similar to `.cjs` files. +* `.tsx` files are unsupported. + +As in JavaScript files, [file extensions are mandatory][] in `import` statements +and `import()` expressions: `import './file.ts'`, not `import './file'`. Because +of backward compatibility, file extensions are also mandatory in `require()` +calls: `require('./file.ts')`, not `require('./file')`, similar to how the +`.cjs` extension is mandatory in `require` calls in CommonJS files. + +The `tsconfig.json` option `allowImportingTsExtensions` will allow the +TypeScript compiler `tsc` to type-check files with `import` specifiers that +include the `.ts` extension. + +### Unsupported TypeScript features + +Since Node.js is only removing inline types, any TypeScript features that +involve _replacing_ TypeScript syntax with new JavaScript syntax will error. +This is by design. To run TypeScript with such features, see +[Full TypeScript support][]. + +The most prominent unsupported features that require transformation are: + +* `Enum` +* `experimentalDecorators` +* `namespaces` +* parameter properties + +In addition, Node.js does not read `tsconfig.json` files and does not support +features that depend on settings within `tsconfig.json`, such as paths or +converting newer JavaScript syntax into older standards. + +### Importing types without `type` keyword + +Due to the nature of type stripping, the `type` keyword is necessary to +correctly strip type imports. Without the `type` keyword, Node.js will treat the +import as a value import, which will result in a runtime error. The tsconfig +option [`verbatimModuleSyntax`][] can be used to match this behavior. + +This example will work correctly: + +```ts +import type { Type1, Type2 } from './module.ts'; +import { fn, type FnParams } from './fn.ts'; +``` + +This will result in a runtime error: + +```ts +import { Type1, Type2 } from './module.ts'; +import { fn, FnParams } from './fn.ts'; +``` + +### Non-file forms of input + +Type stripping can be enabled for `--eval`. The module system +will be determined by `--input-type`, as it is for JavaScript. + +TypeScript syntax is unsupported in the REPL, STDIN input, `--print`, `--check`, and +`inspect`. + +### Source maps + +Since inline types are replaced by whitespace, source maps are unnecessary for +correct line numbers in stack traces; and Node.js does not generate them. For +source maps support, see [Full TypeScript support][]. + +### Type stripping in dependencies + +To discourage package authors from publishing packages written in TypeScript, +Node.js will by default refuse to handle TypeScript files inside folders under +a `node_modules` path. + +[CommonJS]: modules.md +[ES Modules]: esm.md +[Full TypeScript support]: #full-typescript-support +[`--experimental-strip-types`]: cli.md#--experimental-strip-types +[`tsx`]: https://tsx.is/ +[`verbatimModuleSyntax`]: https://www.typescriptlang.org/tsconfig/#verbatimModuleSyntax +[file extensions are mandatory]: esm.md#mandatory-file-extensions +[full support]: #full-typescript-support +[the same way as `.js` files.]: packages.md#determining-module-system +[type stripping]: #type-stripping diff --git a/doc/api/wasi.md b/doc/api/wasi.md index 8301b565f82a10..9b67d9a942b60a 100644 --- a/doc/api/wasi.md +++ b/doc/api/wasi.md @@ -17,7 +17,7 @@ operating system via a collection of POSIX-like functions. ```mjs import { readFile } from 'node:fs/promises'; -import { WASI } from 'wasi'; +import { WASI } from 'node:wasi'; import { argv, env } from 'node:process'; const wasi = new WASI({ @@ -40,7 +40,7 @@ wasi.start(instance); ```cjs 'use strict'; const { readFile } = require('node:fs/promises'); -const { WASI } = require('wasi'); +const { WASI } = require('node:wasi'); const { argv, env } = require('node:process'); const { join } = require('node:path'); diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md index 35300b883599e5..f15c9f49c37ed0 100644 --- a/doc/api/worker_threads.md +++ b/doc/api/worker_threads.md @@ -1455,7 +1455,7 @@ Node.js event loop. import { Worker, isMainThread, -} from 'worker_threads'; +} from 'node:worker_threads'; if (isMainThread) { new Worker(new URL(import.meta.url)); diff --git a/doc/api_assets/README.md b/doc/api_assets/README.md index e2c1d90cd0953f..b5d55c09b85169 100644 --- a/doc/api_assets/README.md +++ b/doc/api_assets/README.md @@ -1,13 +1,7 @@ -# API Reference Document Assets +# API documentation assets -## api.js - -The main script for API reference documents. - -## hljs.css - -The syntax theme for code snippets in API reference documents. - -## style.css - -The main stylesheet for API reference documents. +* [`api.js`](./api.js): This file contains all the JavaScript used throughout the documentation. +* [`hljs.css`](./hljs.css): This CSS file is used for syntax highlighting styles in code blocks. +* [`js-flavor-cjs.svg`](./js-flavor-cjs.svg): This SVG image represents the toggle between ESM and CJS (_CJS_) +* [`js-flavor-esm.svg`](./js-flavor-esm.svg): This SVG image represents the toggle between ESM and CJS (_ESM_) +* [`style.css`](./style.css): This CSS file contains the styling rules for the overall appearance of the API documentation. diff --git a/doc/api_assets/style.css b/doc/api_assets/style.css index 3921f05b0ca965..28a284e3b975b8 100644 --- a/doc/api_assets/style.css +++ b/doc/api_assets/style.css @@ -60,12 +60,6 @@ } /*--------------------- Layout and Typography ----------------------------*/ -@media (prefers-reduced-motion: no-preference) { - html { - scroll-behavior: smooth; - } -} - html { font-size: 1rem; overflow-wrap: break-word; diff --git a/doc/changelogs/CHANGELOG_V22.md b/doc/changelogs/CHANGELOG_V22.md index 6fffc5950d6131..d705ef199d6514 100644 --- a/doc/changelogs/CHANGELOG_V22.md +++ b/doc/changelogs/CHANGELOG_V22.md @@ -8,6 +8,7 @@ +22.6.0
22.5.1
22.5.0
22.4.1
@@ -44,6 +45,177 @@ * [io.js](CHANGELOG_IOJS.md) * [Archive](CHANGELOG_ARCHIVE.md) + + +## 2024-08-06, Version 22.6.0 (Current), @RafaelGSS + +### Experimental TypeScript support via strip types + +Node.js introduces the `--experimental-strip-types` flag for initial TypeScript support. +This feature strips type annotations from .ts files, allowing them to run +without transforming TypeScript-specific syntax. Current limitations include: + +* Supports only inline type annotations, not features like `enums` or `namespaces`. +* Requires explicit file extensions in import and require statements. +* Enforces the use of the type keyword for type imports to avoid runtime errors. +* Disabled for TypeScript in _node\_modules_ by default. + +Thanks [Marco Ippolito](https://github.com/marco-ippolito) for working on this. + +### Experimental Network Inspection Support in Node.js + +This update introduces the initial support for network inspection in Node.js. +Currently, this is an experimental feature, so you need to enable it using the `--experimental-network-inspection` flag. +With this feature enabled, you can inspect network activities occurring within a JavaScript application. + +To use network inspection, start your Node.js application with the following command: + +```console +$ node --inspect-wait --experimental-network-inspection index.js +``` + +Please note that the network inspection capabilities are in active development. +We are actively working on enhancing this feature and will continue to expand its functionality in future updates. + +* Network inspection is limited to the `http` and `https` modules only. +* The Network tab in Chrome DevTools will not be available until the + [feature request on the Chrome DevTools side](https://issues.chromium.org/issues/353924015) is addressed. + +Thanks [Kohei Ueno](https://github.com/cola119) for working on this. + +### Other Notable Changes + +* \[[`15a94e67b1`](https://github.com/nodejs/node/commit/15a94e67b1)] - **lib,src**: drop --experimental-network-imports (Rafael Gonzaga) [#53822](https://github.com/nodejs/node/pull/53822) +* \[[`68e444d2d8`](https://github.com/nodejs/node/commit/68e444d2d8)] - **(SEMVER-MINOR)** **http**: add diagnostics channel `http.client.request.error` (Kohei Ueno) [#54054](https://github.com/nodejs/node/pull/54054) +* \[[`2d982d3dee`](https://github.com/nodejs/node/commit/2d982d3dee)] - **(SEMVER-MINOR)** **deps**: V8: backport 7857eb34db42 (Stephen Belanger) [#53997](https://github.com/nodejs/node/pull/53997) +* \[[`15816bd0dd`](https://github.com/nodejs/node/commit/15816bd0dd)] - **(SEMVER-MINOR)** **stream**: expose DuplexPair API (Austin Wright) [#34111](https://github.com/nodejs/node/pull/34111) +* \[[`893c864542`](https://github.com/nodejs/node/commit/893c864542)] - **(SEMVER-MINOR)** **test\_runner**: fix support watch with run(), add globPatterns option (Matteo Collina) [#53866](https://github.com/nodejs/node/pull/53866) +* \[[`048d421ad1`](https://github.com/nodejs/node/commit/048d421ad1)] - **meta**: add jake to collaborators (jakecastelli) [#54004](https://github.com/nodejs/node/pull/54004) +* \[[`6ad6e01bf3`](https://github.com/nodejs/node/commit/6ad6e01bf3)] - **(SEMVER-MINOR)** **test\_runner**: refactor snapshots to get file from context (Colin Ihrig) [#53853](https://github.com/nodejs/node/pull/53853) +* \[[`698e44f8e7`](https://github.com/nodejs/node/commit/698e44f8e7)] - **(SEMVER-MINOR)** **test\_runner**: add context.filePath (Colin Ihrig) [#53853](https://github.com/nodejs/node/pull/53853) + +### Commits + +* \[[`063f46dc2a`](https://github.com/nodejs/node/commit/063f46dc2a)] - **assert**: use isError instead of instanceof in innerOk (Pietro Marchini) [#53980](https://github.com/nodejs/node/pull/53980) +* \[[`10bea42f81`](https://github.com/nodejs/node/commit/10bea42f81)] - **build**: update gcovr to 7.2 and codecov config (Benjamin E. Coe) [#54019](https://github.com/nodejs/node/pull/54019) +* \[[`7c417c6cf4`](https://github.com/nodejs/node/commit/7c417c6cf4)] - **build**: avoid compiling with VS v17.10 (Hüseyin Açacak) [#53863](https://github.com/nodejs/node/pull/53863) +* \[[`ee97c045b4`](https://github.com/nodejs/node/commit/ee97c045b4)] - **build**: ensure v8\_pointer\_compression\_sandbox is enabled on 64bit (Shelley Vohr) [#53884](https://github.com/nodejs/node/pull/53884) +* \[[`bfbed0afd5`](https://github.com/nodejs/node/commit/bfbed0afd5)] - **build**: fix conflict gyp configs (Chengzhong Wu) [#53605](https://github.com/nodejs/node/pull/53605) +* \[[`0f1fe63e32`](https://github.com/nodejs/node/commit/0f1fe63e32)] - **build**: trigger coverage ci when updating codecov (Yagiz Nizipli) [#53929](https://github.com/nodejs/node/pull/53929) +* \[[`ad62b945f0`](https://github.com/nodejs/node/commit/ad62b945f0)] - **build**: update codecov coverage build count (Yagiz Nizipli) [#53929](https://github.com/nodejs/node/pull/53929) +* \[[`3c40868fd3`](https://github.com/nodejs/node/commit/3c40868fd3)] - **build**: disable test-asan workflow (Michaël Zasso) [#53844](https://github.com/nodejs/node/pull/53844) +* \[[`2a62d6ca57`](https://github.com/nodejs/node/commit/2a62d6ca57)] - **build, tools**: drop leading `/` from `r2dir` (Richard Lau) [#53951](https://github.com/nodejs/node/pull/53951) +* \[[`9c7b009f47`](https://github.com/nodejs/node/commit/9c7b009f47)] - **build,tools**: simplify upload of shasum signatures (Michaël Zasso) [#53892](https://github.com/nodejs/node/pull/53892) +* \[[`057bd44f9f`](https://github.com/nodejs/node/commit/057bd44f9f)] - **child\_process**: fix incomplete prototype pollution hardening (Liran Tal) [#53781](https://github.com/nodejs/node/pull/53781) +* \[[`66f7c595c7`](https://github.com/nodejs/node/commit/66f7c595c7)] - **cli**: document `--inspect` port `0` behavior (Aviv Keller) [#53782](https://github.com/nodejs/node/pull/53782) +* \[[`fad3e74b47`](https://github.com/nodejs/node/commit/fad3e74b47)] - **console**: fix issues with frozen intrinsics (Vinicius Lourenço) [#54070](https://github.com/nodejs/node/pull/54070) +* \[[`e685ecd7ae`](https://github.com/nodejs/node/commit/e685ecd7ae)] - **deps**: update corepack to 0.29.3 (Node.js GitHub Bot) [#54072](https://github.com/nodejs/node/pull/54072) +* \[[`e5f7250e6d`](https://github.com/nodejs/node/commit/e5f7250e6d)] - **deps**: update amaro to 0.0.6 (Node.js GitHub Bot) [#54199](https://github.com/nodejs/node/pull/54199) +* \[[`2c1e9082e8`](https://github.com/nodejs/node/commit/2c1e9082e8)] - **deps**: update amaro to 0.0.5 (Node.js GitHub Bot) [#54199](https://github.com/nodejs/node/pull/54199) +* \[[`2d982d3dee`](https://github.com/nodejs/node/commit/2d982d3dee)] - **(SEMVER-MINOR)** **deps**: V8: backport 7857eb34db42 (Stephen Belanger) [#53997](https://github.com/nodejs/node/pull/53997) +* \[[`1061898462`](https://github.com/nodejs/node/commit/1061898462)] - **deps**: update c-ares to v1.32.3 (Node.js GitHub Bot) [#54020](https://github.com/nodejs/node/pull/54020) +* \[[`f4a7ac5e18`](https://github.com/nodejs/node/commit/f4a7ac5e18)] - **deps**: V8: cherry-pick 35888fee7bba (Joyee Cheung) [#53728](https://github.com/nodejs/node/pull/53728) +* \[[`1176310226`](https://github.com/nodejs/node/commit/1176310226)] - **deps**: add gn build files for ncrypto (Cheng) [#53940](https://github.com/nodejs/node/pull/53940) +* \[[`7a1d5a4f84`](https://github.com/nodejs/node/commit/7a1d5a4f84)] - **deps**: update c-ares to v1.32.2 (Node.js GitHub Bot) [#53865](https://github.com/nodejs/node/pull/53865) +* \[[`66f6a2aec9`](https://github.com/nodejs/node/commit/66f6a2aec9)] - **deps**: V8: cherry-pick 9812cb486e2b (Michaël Zasso) [#53966](https://github.com/nodejs/node/pull/53966) +* \[[`8e66a18ef0`](https://github.com/nodejs/node/commit/8e66a18ef0)] - **deps**: start working on ncrypto dep (James M Snell) [#53803](https://github.com/nodejs/node/pull/53803) +* \[[`c114082b12`](https://github.com/nodejs/node/commit/c114082b12)] - **deps**: fix include\_dirs of nbytes (Cheng) [#53862](https://github.com/nodejs/node/pull/53862) +* \[[`b7315281be`](https://github.com/nodejs/node/commit/b7315281be)] - **doc**: move numCPUs require to top of file in cluster CJS example (Alfredo González) [#53932](https://github.com/nodejs/node/pull/53932) +* \[[`8e7c30c2a4`](https://github.com/nodejs/node/commit/8e7c30c2a4)] - **doc**: update security-release process to automated one (Rafael Gonzaga) [#53877](https://github.com/nodejs/node/pull/53877) +* \[[`52a4206be2`](https://github.com/nodejs/node/commit/52a4206be2)] - **doc**: fix typo in technical-priorities.md (YoonSoo\_Shin) [#54094](https://github.com/nodejs/node/pull/54094) +* \[[`30e18a04a3`](https://github.com/nodejs/node/commit/30e18a04a3)] - **doc**: fix typo in diagnostic tooling support tiers document (Taejin Kim) [#54058](https://github.com/nodejs/node/pull/54058) +* \[[`58aebfd31e`](https://github.com/nodejs/node/commit/58aebfd31e)] - **doc**: move GeoffreyBooth to TSC regular member (Geoffrey Booth) [#54047](https://github.com/nodejs/node/pull/54047) +* \[[`c1634c7213`](https://github.com/nodejs/node/commit/c1634c7213)] - **doc**: correct typescript stdin support (Marco Ippolito) [#54036](https://github.com/nodejs/node/pull/54036) +* \[[`64812d5c22`](https://github.com/nodejs/node/commit/64812d5c22)] - **doc**: fix typo in recognizing-contributors (Marco Ippolito) [#53990](https://github.com/nodejs/node/pull/53990) +* \[[`6b35994b6f`](https://github.com/nodejs/node/commit/6b35994b6f)] - **doc**: fix documentation for `--run` (Aviv Keller) [#53976](https://github.com/nodejs/node/pull/53976) +* \[[`04d203a233`](https://github.com/nodejs/node/commit/04d203a233)] - **doc**: update boxstarter README (Aviv Keller) [#53785](https://github.com/nodejs/node/pull/53785) +* \[[`86fa46db1c`](https://github.com/nodejs/node/commit/86fa46db1c)] - **doc**: add info about prefix-only modules to `module.builtinModules` (Grigory) [#53954](https://github.com/nodejs/node/pull/53954) +* \[[`defdc3c568`](https://github.com/nodejs/node/commit/defdc3c568)] - **doc**: remove `scroll-behavior: smooth;` (Cloyd Lau) [#53942](https://github.com/nodejs/node/pull/53942) +* \[[`e907236dd9`](https://github.com/nodejs/node/commit/e907236dd9)] - **doc**: move --test-coverage-{ex,in}clude to proper location (Colin Ihrig) [#53926](https://github.com/nodejs/node/pull/53926) +* \[[`8bf9960b98`](https://github.com/nodejs/node/commit/8bf9960b98)] - **doc**: add `--experimental-sqlite` note (Aviv Keller) [#53907](https://github.com/nodejs/node/pull/53907) +* \[[`d7615004d8`](https://github.com/nodejs/node/commit/d7615004d8)] - **doc**: update `api_assets` README for new files (Aviv Keller) [#53676](https://github.com/nodejs/node/pull/53676) +* \[[`63cf715aa0`](https://github.com/nodejs/node/commit/63cf715aa0)] - **doc**: add MattiasBuelens to collaborators (Mattias Buelens) [#53895](https://github.com/nodejs/node/pull/53895) +* \[[`5b8dd78112`](https://github.com/nodejs/node/commit/5b8dd78112)] - **doc**: fix release date for 22.5.0 (Antoine du Hamel) [#53889](https://github.com/nodejs/node/pull/53889) +* \[[`dd2c0f349a`](https://github.com/nodejs/node/commit/dd2c0f349a)] - **doc**: fix casing of GitHub handle for two collaborators (Antoine du Hamel) [#53857](https://github.com/nodejs/node/pull/53857) +* \[[`b47c2308e1`](https://github.com/nodejs/node/commit/b47c2308e1)] - **doc**: update release-post nodejs.org script (Rafael Gonzaga) [#53762](https://github.com/nodejs/node/pull/53762) +* \[[`88539527d5`](https://github.com/nodejs/node/commit/88539527d5)] - **doc, test**: tracing channel hasSubscribers getter (Thomas Hunter II) [#52908](https://github.com/nodejs/node/pull/52908) +* \[[`44a08f75b0`](https://github.com/nodejs/node/commit/44a08f75b0)] - **doc,tools**: enforce use of `node:` prefix (Antoine du Hamel) [#53950](https://github.com/nodejs/node/pull/53950) +* \[[`87bab76df2`](https://github.com/nodejs/node/commit/87bab76df2)] - **doc,tty**: add documentation for ReadStream and WriteStream (jakecastelli) [#53567](https://github.com/nodejs/node/pull/53567) +* \[[`dcca9ba560`](https://github.com/nodejs/node/commit/dcca9ba560)] - **esm**: refactor `get_format` (Antoine du Hamel) [#53872](https://github.com/nodejs/node/pull/53872) +* \[[`5e03c17aae`](https://github.com/nodejs/node/commit/5e03c17aae)] - **fs**: optimize `fs.cpSync` js calls (Yagiz Nizipli) [#53614](https://github.com/nodejs/node/pull/53614) +* \[[`e0054ee0a7`](https://github.com/nodejs/node/commit/e0054ee0a7)] - **fs**: ensure consistency for mkdtemp in both fs and fs/promises (YieldRay) [#53776](https://github.com/nodejs/node/pull/53776) +* \[[`8086337ea9`](https://github.com/nodejs/node/commit/8086337ea9)] - **fs**: remove unnecessary option argument validation (Jonas) [#53861](https://github.com/nodejs/node/pull/53861) +* \[[`b377b93a3f`](https://github.com/nodejs/node/commit/b377b93a3f)] - **fs**: correctly pass dirent to exclude `withFileTypes` (RedYetiDev) [#53823](https://github.com/nodejs/node/pull/53823) +* \[[`68e444d2d8`](https://github.com/nodejs/node/commit/68e444d2d8)] - **(SEMVER-MINOR)** **http**: add diagnostics channel `http.client.request.error` (Kohei Ueno) [#54054](https://github.com/nodejs/node/pull/54054) +* \[[`de1fbc292f`](https://github.com/nodejs/node/commit/de1fbc292f)] - **(SEMVER-MINOR)** **inspector**: add initial support for network inspection (Kohei Ueno) [#53593](https://github.com/nodejs/node/pull/53593) +* \[[`744df0be24`](https://github.com/nodejs/node/commit/744df0be24)] - **lib**: support dynamic trace events on debugWithTimer (Vinicius Lourenço) [#53913](https://github.com/nodejs/node/pull/53913) +* \[[`546dab29c1`](https://github.com/nodejs/node/commit/546dab29c1)] - **lib**: optimize copyError with ObjectAssign in primordials (HEESEUNG) [#53999](https://github.com/nodejs/node/pull/53999) +* \[[`494df9835a`](https://github.com/nodejs/node/commit/494df9835a)] - **lib**: improve cluster/primary code (Ehsan Khakifirooz) [#53756](https://github.com/nodejs/node/pull/53756) +* \[[`03f353293b`](https://github.com/nodejs/node/commit/03f353293b)] - **lib**: improve error message when index not found on cjs (Vinicius Lourenço) [#53859](https://github.com/nodejs/node/pull/53859) +* \[[`d8375d6236`](https://github.com/nodejs/node/commit/d8375d6236)] - **lib**: decorate async stack trace in source maps (Chengzhong Wu) [#53860](https://github.com/nodejs/node/pull/53860) +* \[[`15a94e67b1`](https://github.com/nodejs/node/commit/15a94e67b1)] - **lib,src**: drop --experimental-network-imports (Rafael Gonzaga) [#53822](https://github.com/nodejs/node/pull/53822) +* \[[`a6eedc401d`](https://github.com/nodejs/node/commit/a6eedc401d)] - **meta**: add `sqlite` to js subsystems (Alex Yang) [#53911](https://github.com/nodejs/node/pull/53911) +* \[[`21098856de`](https://github.com/nodejs/node/commit/21098856de)] - **meta**: move tsc member to emeritus (Michael Dawson) [#54029](https://github.com/nodejs/node/pull/54029) +* \[[`048d421ad1`](https://github.com/nodejs/node/commit/048d421ad1)] - **meta**: add jake to collaborators (jakecastelli) [#54004](https://github.com/nodejs/node/pull/54004) +* \[[`20a8c96c41`](https://github.com/nodejs/node/commit/20a8c96c41)] - **meta**: remove license for hljs (Aviv Keller) [#53970](https://github.com/nodejs/node/pull/53970) +* \[[`2fd4ac4859`](https://github.com/nodejs/node/commit/2fd4ac4859)] - **meta**: make more bug-report information required (Aviv Keller) [#53718](https://github.com/nodejs/node/pull/53718) +* \[[`b312ec0b0c`](https://github.com/nodejs/node/commit/b312ec0b0c)] - **meta**: reword linter messages (Aviv Keller) [#53949](https://github.com/nodejs/node/pull/53949) +* \[[`d2526126a9`](https://github.com/nodejs/node/commit/d2526126a9)] - **meta**: store actions secrets in environment (Aviv Keller) [#53930](https://github.com/nodejs/node/pull/53930) +* \[[`1688f00dce`](https://github.com/nodejs/node/commit/1688f00dce)] - **meta**: move anonrig to tsc voting members (Yagiz Nizipli) [#53888](https://github.com/nodejs/node/pull/53888) +* \[[`c20e8418de`](https://github.com/nodejs/node/commit/c20e8418de)] - **module**: fix strip-types interaction with detect-module (Marco Ippolito) [#54164](https://github.com/nodejs/node/pull/54164) +* \[[`ab1f0b415f`](https://github.com/nodejs/node/commit/ab1f0b415f)] - **module**: fix extensionless typescript in cjs loader (Marco Ippolito) [#54062](https://github.com/nodejs/node/pull/54062) +* \[[`92439fc160`](https://github.com/nodejs/node/commit/92439fc160)] - **(SEMVER-MINOR)** **module**: add --experimental-strip-types (Marco Ippolito) [#53725](https://github.com/nodejs/node/pull/53725) +* \[[`f755d31bec`](https://github.com/nodejs/node/commit/f755d31bec)] - **node-api**: add property keys benchmark (Chengzhong Wu) [#54012](https://github.com/nodejs/node/pull/54012) +* \[[`7382eefae5`](https://github.com/nodejs/node/commit/7382eefae5)] - **node-api**: rename nogc to basic (Gabriel Schulhof) [#53830](https://github.com/nodejs/node/pull/53830) +* \[[`2c4470625b`](https://github.com/nodejs/node/commit/2c4470625b)] - **process**: unify experimental warning messages (Aviv Keller) [#53704](https://github.com/nodejs/node/pull/53704) +* \[[`98a7ad2e0d`](https://github.com/nodejs/node/commit/98a7ad2e0d)] - **src**: expose LookupAndCompile with parameters (Shelley Vohr) [#53886](https://github.com/nodejs/node/pull/53886) +* \[[`dd3c66be0a`](https://github.com/nodejs/node/commit/dd3c66be0a)] - **src**: simplify AESCipherTraits::AdditionalConfig (Tobias Nießen) [#53890](https://github.com/nodejs/node/pull/53890) +* \[[`ee82f224ff`](https://github.com/nodejs/node/commit/ee82f224ff)] - **src**: remove redundant RsaPointer (use RSAPointer) (James M Snell) [#54003](https://github.com/nodejs/node/pull/54003) +* \[[`2d77bd2929`](https://github.com/nodejs/node/commit/2d77bd2929)] - **src**: fix -Wshadow warning (Shelley Vohr) [#53885](https://github.com/nodejs/node/pull/53885) +* \[[`bd4a9ffe8c`](https://github.com/nodejs/node/commit/bd4a9ffe8c)] - **src**: start using ncrypto for CSPRNG calls (James M Snell) [#53984](https://github.com/nodejs/node/pull/53984) +* \[[`3fdcf7a47d`](https://github.com/nodejs/node/commit/3fdcf7a47d)] - **src**: return `undefined` if no rows are returned in SQLite (Deokjin Kim) [#53981](https://github.com/nodejs/node/pull/53981) +* \[[`ca6854443d`](https://github.com/nodejs/node/commit/ca6854443d)] - **src**: fix slice of slice of file-backed Blob (Josh Lee) [#53972](https://github.com/nodejs/node/pull/53972) +* \[[`c457f9ed5a`](https://github.com/nodejs/node/commit/c457f9ed5a)] - **src**: cache invariant code motion (Rafael Gonzaga) [#53879](https://github.com/nodejs/node/pull/53879) +* \[[`fd0da6c2cf`](https://github.com/nodejs/node/commit/fd0da6c2cf)] - **src**: avoid strcmp in ImportJWKAsymmetricKey (Tobias Nießen) [#53813](https://github.com/nodejs/node/pull/53813) +* \[[`fbf74bcf99`](https://github.com/nodejs/node/commit/fbf74bcf99)] - **src**: switch from ToLocalChecked to ToLocal in node\_webstorage (James M Snell) [#53959](https://github.com/nodejs/node/pull/53959) +* \[[`04bb6778e5`](https://github.com/nodejs/node/commit/04bb6778e5)] - **src**: move `ToNamespacedPath` call of webstorage (Yagiz Nizipli) [#53875](https://github.com/nodejs/node/pull/53875) +* \[[`9ffaf763e9`](https://github.com/nodejs/node/commit/9ffaf763e9)] - **src**: use Maybe\ in SecureContext (Tobias Nießen) [#53883](https://github.com/nodejs/node/pull/53883) +* \[[`a94c3ae06f`](https://github.com/nodejs/node/commit/a94c3ae06f)] - **src**: replace ToLocalChecked uses with ToLocal in node-file (James M Snell) [#53869](https://github.com/nodejs/node/pull/53869) +* \[[`55461be05f`](https://github.com/nodejs/node/commit/55461be05f)] - **src**: refactor webstorage implementation (Yagiz Nizipli) [#53876](https://github.com/nodejs/node/pull/53876) +* \[[`c53cf449a6`](https://github.com/nodejs/node/commit/c53cf449a6)] - **src**: fix env-file flag to ignore spaces before quotes (Mohit Malhotra) [#53786](https://github.com/nodejs/node/pull/53786) +* \[[`bac3a485f6`](https://github.com/nodejs/node/commit/bac3a485f6)] - **src**: fix potential segmentation fault in SQLite (Tobias Nießen) [#53850](https://github.com/nodejs/node/pull/53850) +* \[[`df5083e5f9`](https://github.com/nodejs/node/commit/df5083e5f9)] - **src,lib**: expose getCategoryEnabledBuffer to use on node.http (Vinicius Lourenço) [#53602](https://github.com/nodejs/node/pull/53602) +* \[[`8664b9ad60`](https://github.com/nodejs/node/commit/8664b9ad60)] - **src,test**: disallow unsafe integer coercion in SQLite (Tobias Nießen) [#53851](https://github.com/nodejs/node/pull/53851) +* \[[`15816bd0dd`](https://github.com/nodejs/node/commit/15816bd0dd)] - **(SEMVER-MINOR)** **stream**: expose DuplexPair API (Austin Wright) [#34111](https://github.com/nodejs/node/pull/34111) +* \[[`718f6bc78c`](https://github.com/nodejs/node/commit/718f6bc78c)] - **test**: do not swallow uncaughtException errors in exit code tests (Meghan Denny) [#54039](https://github.com/nodejs/node/pull/54039) +* \[[`c6656c9251`](https://github.com/nodejs/node/commit/c6656c9251)] - **test**: move shared module to `test/common` (Rich Trott) [#54042](https://github.com/nodejs/node/pull/54042) +* \[[`e471e32d46`](https://github.com/nodejs/node/commit/e471e32d46)] - **test**: skip sea tests with more accurate available disk space estimation (Chengzhong Wu) [#53996](https://github.com/nodejs/node/pull/53996) +* \[[`61971ec929`](https://github.com/nodejs/node/commit/61971ec929)] - **test**: remove unnecessary console log (KAYYY) [#53812](https://github.com/nodejs/node/pull/53812) +* \[[`1344bd2d6f`](https://github.com/nodejs/node/commit/1344bd2d6f)] - **test**: add comments and rename test for timer robustness (Rich Trott) [#54008](https://github.com/nodejs/node/pull/54008) +* \[[`da3573409c`](https://github.com/nodejs/node/commit/da3573409c)] - **test**: add test for one arg timers to increase coverage (Carlos Espa) [#54007](https://github.com/nodejs/node/pull/54007) +* \[[`fc67abd97e`](https://github.com/nodejs/node/commit/fc67abd97e)] - **test**: mark 'test/parallel/test-sqlite.js' as flaky (Colin Ihrig) [#54031](https://github.com/nodejs/node/pull/54031) +* \[[`aa0ac3b57c`](https://github.com/nodejs/node/commit/aa0ac3b57c)] - **test**: mark test-pipe-file-to-http as flaky (jakecastelli) [#53751](https://github.com/nodejs/node/pull/53751) +* \[[`52bc8ec360`](https://github.com/nodejs/node/commit/52bc8ec360)] - **test**: compare paths on Windows without considering case (Early Riser) [#53993](https://github.com/nodejs/node/pull/53993) +* \[[`7e8a609579`](https://github.com/nodejs/node/commit/7e8a609579)] - **test**: skip sea tests in large debug builds (Chengzhong Wu) [#53918](https://github.com/nodejs/node/pull/53918) +* \[[`30a94ca0c4`](https://github.com/nodejs/node/commit/30a94ca0c4)] - **test**: skip --title check on IBM i (Abdirahim Musse) [#53952](https://github.com/nodejs/node/pull/53952) +* \[[`5cea7ed706`](https://github.com/nodejs/node/commit/5cea7ed706)] - **test**: reduce flakiness of `test-assert-esm-cjs-message-verify` (Antoine du Hamel) [#53967](https://github.com/nodejs/node/pull/53967) +* \[[`58cb0dd8a6`](https://github.com/nodejs/node/commit/58cb0dd8a6)] - **test**: use `PYTHON` executable from env in `assertSnapshot` (Antoine du Hamel) [#53938](https://github.com/nodejs/node/pull/53938) +* \[[`c247582591`](https://github.com/nodejs/node/commit/c247582591)] - **test**: deflake test-blob-file-backed (Luigi Pinca) [#53920](https://github.com/nodejs/node/pull/53920) +* \[[`3999021653`](https://github.com/nodejs/node/commit/3999021653)] - **test\_runner**: switched to internal readline interface (Emil Tayeb) [#54000](https://github.com/nodejs/node/pull/54000) +* \[[`3fb97a90ee`](https://github.com/nodejs/node/commit/3fb97a90ee)] - **test\_runner**: remove redundant bootstrap boolean (Colin Ihrig) [#54013](https://github.com/nodejs/node/pull/54013) +* \[[`edd80e2bdc`](https://github.com/nodejs/node/commit/edd80e2bdc)] - **test\_runner**: do not throw on mocked clearTimeout() (Aksinya Bykova) [#54005](https://github.com/nodejs/node/pull/54005) +* \[[`893c864542`](https://github.com/nodejs/node/commit/893c864542)] - **(SEMVER-MINOR)** **test\_runner**: fix support watch with run(), add globPatterns option (Matteo Collina) [#53866](https://github.com/nodejs/node/pull/53866) +* \[[`4887213f2e`](https://github.com/nodejs/node/commit/4887213f2e)] - **test\_runner**: added colors to dot reporter (Giovanni) [#53450](https://github.com/nodejs/node/pull/53450) +* \[[`c4848c53e6`](https://github.com/nodejs/node/commit/c4848c53e6)] - **test\_runner**: cleanup global event listeners after run (Eddie Abbondanzio) [#53878](https://github.com/nodejs/node/pull/53878) +* \[[`876e7b3226`](https://github.com/nodejs/node/commit/876e7b3226)] - **test\_runner**: refactor coverage to pass in config options (Colin Ihrig) [#53931](https://github.com/nodejs/node/pull/53931) +* \[[`f45edb4b5e`](https://github.com/nodejs/node/commit/f45edb4b5e)] - **test\_runner**: refactor and simplify internals (Colin Ihrig) [#53921](https://github.com/nodejs/node/pull/53921) +* \[[`6ad6e01bf3`](https://github.com/nodejs/node/commit/6ad6e01bf3)] - **(SEMVER-MINOR)** **test\_runner**: refactor snapshots to get file from context (Colin Ihrig) [#53853](https://github.com/nodejs/node/pull/53853) +* \[[`698e44f8e7`](https://github.com/nodejs/node/commit/698e44f8e7)] - **(SEMVER-MINOR)** **test\_runner**: add context.filePath (Colin Ihrig) [#53853](https://github.com/nodejs/node/pull/53853) +* \[[`97da7ca11b`](https://github.com/nodejs/node/commit/97da7ca11b)] - **test\_runner**: consolidate option parsing (Colin Ihrig) [#53849](https://github.com/nodejs/node/pull/53849) +* \[[`43afcbf9dd`](https://github.com/nodejs/node/commit/43afcbf9dd)] - **tools**: fix `SLACK_TITLE` in invalid commit workflow (Antoine du Hamel) [#53912](https://github.com/nodejs/node/pull/53912) +* \[[`eed0963391`](https://github.com/nodejs/node/commit/eed0963391)] - **typings**: apply lint (1ilsang) [#54065](https://github.com/nodejs/node/pull/54065) +* \[[`e8ea49b256`](https://github.com/nodejs/node/commit/e8ea49b256)] - **typings**: fix typo on quic onSessionDatagram (1ilsang) [#54064](https://github.com/nodejs/node/pull/54064) + ## 2024-07-19, Version 22.5.1 (Current), @richardlau @@ -62,7 +234,7 @@ This release fixes a regression introduced in Node.js 22.5.0. The problem is kno -## 2024-07-16, Version 22.5.0 (Current), @RafaelGSS prepared by @aduh95 +## 2024-07-17, Version 22.5.0 (Current), @RafaelGSS prepared by @aduh95 ### Notable Changes diff --git a/doc/contributing/diagnostic-tooling-support-tiers.md b/doc/contributing/diagnostic-tooling-support-tiers.md index 3a3d5298d75710..f92a5242b7b85b 100644 --- a/doc/contributing/diagnostic-tooling-support-tiers.md +++ b/doc/contributing/diagnostic-tooling-support-tiers.md @@ -26,7 +26,7 @@ the following tiers. organization or website; * The tool must be working on all supported platforms; * The tool must only be using APIs exposed by Node.js as opposed to - its dependencies; and + its dependencies; * The tool must be open source. * Tier 2 - Must be working (CI tests passing) for all diff --git a/doc/contributing/maintaining/maintaining-dependencies.md b/doc/contributing/maintaining/maintaining-dependencies.md index d1bfc7dcaf6755..14a6004e382278 100644 --- a/doc/contributing/maintaining/maintaining-dependencies.md +++ b/doc/contributing/maintaining/maintaining-dependencies.md @@ -10,6 +10,7 @@ This a list of all the dependencies: * [acorn][] * [ada][] +* [amaro][] * [base64][] * [brotli][] * [c-ares][] @@ -168,6 +169,11 @@ an abstract syntax tree walker for the ESTree format. The [ada](https://github.com/ada-url/ada) dependency is a fast and spec-compliant URL parser written in C++. +### amaro + +The [amaro](https://www.npmjs.com/package/amaro) dependency is a wrapper around the +WebAssembly version of the SWC JavaScript/TypeScript parser. + ### brotli The [brotli](https://github.com/google/brotli) dependency is @@ -336,6 +342,7 @@ performance improvements not currently available in standard zlib. [acorn]: #acorn [ada]: #ada +[amaro]: #amaro [base64]: #base64 [brotli]: #brotli [c-ares]: #c-ares diff --git a/doc/contributing/reconizing-contributors.md b/doc/contributing/recognizing-contributors.md similarity index 100% rename from doc/contributing/reconizing-contributors.md rename to doc/contributing/recognizing-contributors.md diff --git a/doc/contributing/releases.md b/doc/contributing/releases.md index 71ae6dcb265ec6..b1116de86f8599 100644 --- a/doc/contributing/releases.md +++ b/doc/contributing/releases.md @@ -1004,7 +1004,7 @@ release. However, the blog post is not yet fully automatic. Create a new blog post by running the [nodejs.org release-post.js script][]: ```bash -node ./scripts/release-post/index.mjs x.y.z +node ./apps/site/scripts/release-post/index.mjs x.y.z ``` This script will use the promoted builds and changelog to generate the post. Run diff --git a/doc/contributing/security-release-process.md b/doc/contributing/security-release-process.md index aca702e7615c49..62c788f1746556 100644 --- a/doc/contributing/security-release-process.md +++ b/doc/contributing/security-release-process.md @@ -43,191 +43,136 @@ The current security stewards are documented in the main Node.js ## Planning -* [ ] Open an [issue](https://github.com/nodejs-private/node-private) titled - `Next Security Release`, and put this checklist in the description. - -* [ ] Get agreement on the list of vulnerabilities to be addressed: - * _**H1 REPORT LINK**_: _**DESCRIPTION**_ (_**CVE or H1 CVE request link**_) - * v10.x, v12.x: _**LINK to PR URL**_ - * ... - -* [ ] PR release announcements in [private](https://github.com/nodejs-private/nodejs.org-private): - * (Use previous PRs as templates. Don't forget to update the site banner and - the date in the slug so that it will move to the top of the blog list.) - * (Consider using a [Vulnerability Score System](https://www.first.org/cvss/calculator/3.1) - to identify severity of each report) - * Share the patch with the reporter when applicable. - It will increase the fix accuracy. - * [ ] pre-release: _**LINK TO PR**_ - * [ ] post-release: _**LINK TO PR**_ - * List vulnerabilities in order of descending severity - * Use the "summary" feature in HackerOne to sync post-release content - and CVE requests. Example [2038134](https://hackerone.com/bugs?subject=nodejs\&report_id=2038134) - * Ask the HackerOne reporter if they would like to be credited on the - security release blog page: - ```text - Thank you to for reporting this vulnerability. - ``` - -* [ ] Get agreement on the planned date for the release: _**RELEASE DATE**_ - -* [ ] Get release team volunteers for all affected lines: - * v12.x: _**NAME of RELEASER(S)**_ - * ... other lines, if multiple releasers +* [ ] 1\. **Generating Next Security Release PR** + * Run `git node security --start` inside [security-release][] repository. + * This command generates a new `vulnerabilities.json` file with HackerOne + reports chosen to be released in the `security-release/next-security-release` + folder. + * It also creates the pull request used to manage the security release. + +* [ ] 2\. **Review of Reports:** + * Reports can be added or removed using the following commands: + * Use the "summary" feature in HackerOne. Example [2038134](https://hackerone.com/reports/2038134) + * `git node security --add-report=report_id` + * `git node security --remove-report=report_id` + +* [ ] 3\. **Assigning Severity and Writing Team Summary:** + * [ ] Assign a severity and write a team summary on HackerOne for the reports + chosen in the `vulnerabilities.json`. + * Run `git node security --sync` to update severity and summary in + `vulnerabilities.json`. + +* [ ] 4\. **Requesting CVEs:** + * Request CVEs for the reports with `git node security --request-cve`. + * Make sure to have a green CI before requesting a CVE. + +* [ ] 5\. **Choosing or Updating Release Date:** + * Get agreement on the planned date for the release. + * [ ] Use `git node security --update-date=YYYY/MM/DD` to choose or update the + release date. + * This allows flexibility in postponing the release if needed. + +* [ ] 6\. **Get release volunteers:** + * Get volunteers for the upcoming security release on the affected release + lines. + +* [ ] 7\. **Preparing Pre and Post Release Blog Posts:** + * [ ] Create a pre-release blog post using `git node security --pre-release`. + * [ ] Create a post-release blog post using `git node security --post-release`. ## Announcement (one week in advance of the planned release) -* [ ] Check that all vulnerabilities are ready for release integration: - * PRs against all affected release lines or cherry-pick clean - * PRs with breaking changes have a - [--security-revert](#Adding-a-security-revert-option) option if possible. - * Approved - * (optional) Approved by the reporter - * Build and send the binary to the reporter according to its architecture - and ask for a review. This step is important to avoid insufficient fixes - between Security Releases. - * Pass `make test` - * Have CVEs - * Use the "summary" feature in HackerOne to create a description for the - CVE and the post release announcement. - Example [2038134](https://hackerone.com/bugs?subject=nodejs\&report_id=2038134) - * Make sure that dependent libraries have CVEs for their issues. We should - only create CVEs for vulnerabilities in Node.js itself. This is to avoid - having duplicate CVEs for the same vulnerability. - * Described in the pre/post announcements - -* [ ] Pre-release announcement to nodejs.org blog: _**LINK TO BLOG**_ - (Re-PR the pre-approved branch from nodejs-private/nodejs.org-private to - nodejs/nodejs.org) - - If the security release will only contain an OpenSSL update consider - adding the following to the pre-release announcement: - - ```text - Since this security release will only include updates for OpenSSL, if you're using - a Node.js version which is part of a distribution which uses a system - installed OpenSSL, this Node.js security update might not concern you. You may - instead need to update your system OpenSSL libraries, please check the - security announcements for the distribution. - ``` - -* [ ] Pre-release announcement [email][]: _**LINK TO EMAIL**_ - * Subject: `Node.js security updates for all active release lines, Month Year` - * Body: - ```text - The Node.js project will release new versions of all supported release lines on or shortly after Day of week, Month Day of Month, Year - For more information see: https://nodejs.org/en/blog/vulnerability/month-year-security-releases/ - ``` - (Get access from existing manager: Matteo Collina, Rodd Vagg, Michael Dawson, - Bryan English) - -* [ ] CC `oss-security@lists.openwall.com` on pre-release - -The google groups UI does not support adding a CC, until we figure -out a better way, forward the email you receive to -`oss-security@lists.openwall.com` as a CC. - -* [ ] Post in the [nodejs-social channel][] - in the OpenJS slack asking for amplification of the blog post. - - ```text - Security release pre-alert: - - We will release new versions of release lines on or shortly - after Day Month Date, Year in order to address: - - - # high severity issues - - # moderate severity issues - - https://nodejs.org/en/blog/vulnerability/month-year-security-releases/ - ``` - - We specifically ask that collaborators other than the releasers and security - steward working on the security release do not tweet or publicise the release - until the tweet from the Node.js twitter handle goes out. We have often - seen tweets sent out before the release and associated announcements are - complete which may confuse those waiting for the release and also takes - away from the work the releasers have put into shipping the releases. - -* [ ] Request releaser(s) to start integrating the PRs to be released. - -* [ ] Notify [docker-node][] of upcoming security release date: _**LINK**_ - ```text - Heads up of Node.js security releases Day Month Year - - As per the Node.js security release process this is the FYI that there is going to be a security release Day Month Year - ``` - -* [ ] Notify build-wg of upcoming security release date by opening an issue - in [nodejs/build][] to request WG members are available to fix any CI issues. - ```text - Heads up of Node.js security releases Day Month Year - - As per security release process this is a heads up that there will be security releases Day Month Year and we'll need people from build to lock/unlock ci and to support and build issues we see. - ``` +* [ ] 1\. **Publish Pre-Release Blog Post:** + * Publish the pre-release blog post on the `nodejs/nodejs.org` repository. + +* [ ] 2\. **Send Pre-Release Announcement:** + * Notify the community about the upcoming security release: + + * [ ] `git node security --notify-pre-release` + Except for those noted in the list below, this will create automatically the + issues and emails needed for the notifications. + * [docker-node](https://github.com/nodejs/docker-node/issues) + * [build-wg](https://github.com/nodejs/build/issues) + * [ ] (Not yet automatic - do this manually) [Google Groups](https://groups.google.com/g/nodejs-sec) + * Email: notify + * [ ] (Not yet automatic - do this manually) Post in the nodejs-social channel + in the OpenJS slack asking for amplification of the blog post. + + ```text + Security release pre-alert: + + We will release new versions of release lines on or shortly + after Day Month Date, Year in order to address: + + * # high severity issues + * # moderate severity issues + + https://nodejs.org/en/blog/vulnerability/month-year-security-releases/ + ``` + + We specifically ask that collaborators other than the releasers and security + steward working on the security release do not tweet or publicize the release + until the tweet from Node.js goes out. We have often + seen tweets sent out before the release is + complete, which may confuse those waiting for the release and take + away from the work the releasers have put into shipping the release. + +If the security release will only contain an OpenSSL update, consider +adding the following to the pre-release announcement: + +```text +Since this security release will only include updates for OpenSSL, if you're using +a Node.js version which is part of a distribution that uses a system +installed OpenSSL, this Node.js security update may not concern you, instead, +you may need to update your system OpenSSL libraries. Please check the +security announcements for more information. +``` ## Release day -* [ ] [Lock CI](https://github.com/nodejs/build/blob/HEAD/doc/jenkins-guide.md#before-the-release) - -* [ ] The releaser(s) run the release process to completion. - -* [ ] [Unlock CI](https://github.com/nodejs/build/blob/HEAD/doc/jenkins-guide.md#after-the-release) - -* [ ] Post-release announcement to Nodejs.org blog: _**LINK TO BLOG POST**_ - * (Re-PR the pre-approved branch from nodejs-private/nodejs.org-private to - nodejs/nodejs.org) - -* [ ] Post-release announcement in reply [email][]: _**LINK TO EMAIL**_ - * CC: `oss-security@lists.openwall.com` - * Subject: `Node.js security updates for all active release lines, Month Year` - * Body: - ```text - The Node.js project has now released new versions of all supported release lines. - For more information see: https://nodejs.org/en/blog/vulnerability/month-year-security-releases/ - ``` - -* [ ] Post in the [nodejs-social channel][] - in the OpenJS slack asking for amplification of the blog post. - ```text - Security release: - - New security releases are now available for versions of Node.js. - - https://nodejs.org/en/blog/vulnerability/month-year-security-releases/ - ``` - -* [ ] Comment in [docker-node][] issue that release is ready for integration. - The docker-node team will build and release docker image updates. - -* [ ] For every H1 report resolved: - * Close as Resolved - * Request Disclosure - * Request publication of [H1 CVE requests][] - * (Check that the "Version Fixed" field in the CVE is correct, and provide - links to the release blogs in the "Public Reference" section) - * In case the reporter doesn't accept the disclosure follow this process: - * Remove the original report reference within the reference text box and +* [ ] 1\. **Lock down the CI:** + * Lock down the CI to prevent public access to the CI machines, ping a member of `@nodejs/jenkins-admins`. + +* [ ] 2\. **Release:** + * Verify the CI is green on all release proposals (test-V8, CITGM, etc). + * Follow the [release process](https://github.com/nodejs/node/blob/main/doc/contributing/releases.md). + +* [ ] 3\. **Unlock the CI:** + * Unlock the CI to allow public access to the CI machines, ping a member of `@nodejs/jenkins-admins`. + +* [ ] 4\. **Publish Post-Release Blog Post:** + * Publish the post-release blog post on the `nodejs/nodejs.org` repository. + +* [ ] 5\. **Notify the community:** + * Notify the community that the security release has gone out: + * [ ] Slack: `#nodejs-social` + * [ ] [docker-node](https://github.com/nodejs/docker-node/issues) + * [ ] [build-wg](https://github.com/nodejs/build/issues) + * [ ] Email: notify [Google Groups](https://groups.google.com/g/nodejs-sec) + * Forward to + +## Post-Release + +* [ ] 1\. **Merge the Next Security Release PR:** + * This involves moving the `vulnerabilities.json` file from + `security-release/next-security-release` to the `security-release/YYYY-MM-DD` + folder and merging the PR. + +* [ ] 2\. **Cleanup:** + * [ ] Close PRs and backports. + * [ ] Close HackerOne reports: + * Close Resolved + * Request Disclosure + * Request publication of H1 CVE requests + * In case the reporter doesn't accept the disclosure follow this process: + Remove the original report reference within the reference text box and insert the public URL you would like to be attached to this CVE. - * Then uncheck the Public Disclosure on HackerOne box at the bottom of the + Then uncheck the Public Disclosure on HackerOne box at the bottom of the page. ![screenshot of HackerOne CVE form](https://github.com/nodejs/node/assets/26234614/e22e4f33-7948-4dd2-952e-2f9166f5568d) - -* [ ] PR machine-readable JSON descriptions of the vulnerabilities to the - [core](https://github.com/nodejs/security-wg/tree/HEAD/vuln/core) - vulnerability DB. _**LINK TO PR**_ - * For each vulnerability add a `#.json` file, one can copy an existing - [json](https://github.com/nodejs/security-wg/blob/0d82062d917cb9ddab88f910559469b2b13812bf/vuln/core/78.json) - file, and increment the latest created file number and use that as the name - of the new file to be added. For example, `79.json`. - -* [ ] Close this issue - -* [ ] Make sure the PRs for the vulnerabilities are closed. - -* [ ] PR in that you stewarded the release in - [Security release stewards](https://github.com/nodejs/node/blob/HEAD/doc/contributing/security-release-process.md#security-release-stewards). - If necessary add the next rotation of the steward rotation. + * [ ] PR machine-readable JSON descriptions of the vulnerabilities to the [core](https://github.com/nodejs/security-wg/tree/HEAD/vuln/core) + vulnerability DB. + * [ ] Add yourself as a steward in the [Security Release Stewards](https://github.com/nodejs/node/blob/HEAD/doc/contributing/security-release-process.md#security-release-stewards) ## Adding a security revert option @@ -298,8 +243,4 @@ The steps to correct CVE information are: * Include all the details that need updating within the form * Submit the request -[H1 CVE requests]: https://hackerone.com/nodejs/cve_requests -[docker-node]: https://github.com/nodejs/docker-node/issues -[email]: https://groups.google.com/forum/#!forum/nodejs-sec -[nodejs-social channel]: https://openjs-foundation.slack.com/archives/C0142A39BNE -[nodejs/build]: https://github.com/nodejs/build/issues +[security-release]: https://github.com/nodejs-private/security-release diff --git a/doc/contributing/technical-priorities.md b/doc/contributing/technical-priorities.md index a11ae0e556987f..9e566f12ae6750 100644 --- a/doc/contributing/technical-priorities.md +++ b/doc/contributing/technical-priorities.md @@ -130,7 +130,7 @@ the expansion of where/when Node.js is used in building solutions. ## Serverless Serverless is a cloud computing model where the cloud provider manages the -underlyinginfrastructure and automatically allocates resources as +underlying infrastructure and automatically allocates resources as needed. Developers only need to focus on writing code for specific functions, which are executed as individual units of work in response to events. Node.js is one of the main technology used by developers in diff --git a/doc/eslint.config_partial.mjs b/doc/eslint.config_partial.mjs index add5ab3d8d6ff0..edcc72930875b0 100644 --- a/doc/eslint.config_partial.mjs +++ b/doc/eslint.config_partial.mjs @@ -1,4 +1,9 @@ -import { requireEslintTool } from '../tools/eslint/eslint.config_utils.mjs'; +import { + noRestrictedSyntaxCommonAll, + noRestrictedSyntaxCommonLib, + requireEslintTool, +} from '../tools/eslint/eslint.config_utils.mjs'; +import { builtinModules as builtin } from 'node:module'; const globals = requireEslintTool('globals'); @@ -8,6 +13,15 @@ export default [ rules: { // Ease some restrictions in doc examples. 'no-restricted-properties': 'off', + 'no-restricted-syntax': [ + 'error', + ...noRestrictedSyntaxCommonAll, + ...noRestrictedSyntaxCommonLib, + { + selector: `CallExpression[callee.name="require"][arguments.0.type="Literal"]:matches(${builtin.map((name) => `[arguments.0.value="${name}"]`).join(',')}),ImportDeclaration:matches(${builtin.map((name) => `[source.value="${name}"]`).join(',')})`, + message: 'Use `node:` prefix.', + }, + ], 'no-undef': 'off', 'no-unused-expressions': 'off', 'no-unused-vars': 'off', diff --git a/doc/node.1 b/doc/node.1 index 389c11513d898d..f943f5cf7c93bc 100644 --- a/doc/node.1 +++ b/doc/node.1 @@ -173,9 +173,6 @@ Specify the .Ar module to use as a custom module loader. . -.It Fl -experimental-network-imports -Enable experimental support for loading modules using `import` over `https:`. -. .It Fl -experimental-permission Enable the experimental permission model. . @@ -194,6 +191,9 @@ Enable module mocking in the test runner. .It Fl -experimental-test-snapshots Enable snapshot testing in the test runner. . +.It Fl -experimental-strip-types +Enable experimental type-stripping for TypeScript files. +. .It Fl -experimental-eventsource Enable experimental support for the EventSource Web API. . diff --git a/eslint.config.mjs b/eslint.config.mjs index b9cce86efb4b3f..67d21b540f945a 100644 --- a/eslint.config.mjs +++ b/eslint.config.mjs @@ -346,31 +346,31 @@ export default [ 'error', { name: '__filename', - message: 'Use import.meta.url instead', + message: 'Use import.meta.url instead.', }, { name: '__dirname', - message: 'Not available in ESM', + message: 'Not available in ESM.', }, { name: 'exports', - message: 'Not available in ESM', + message: 'Not available in ESM.', }, { name: 'module', - message: 'Not available in ESM', + message: 'Not available in ESM.', }, { name: 'require', - message: 'Use import instead', + message: 'Use import instead.', }, { name: 'Buffer', - message: 'Import Buffer instead of using the global', + message: "Import 'Buffer' instead of using the global.", }, { name: 'process', - message: 'Import process instead of using the global', + message: "Import 'process' instead of using the global.", }, ] }, }, diff --git a/lib/_http_client.js b/lib/_http_client.js index 0ad234044f6adb..6d3b3591e7ba40 100644 --- a/lib/_http_client.js +++ b/lib/_http_client.js @@ -90,8 +90,19 @@ const kClientRequestStatistics = Symbol('ClientRequestStatistics'); const dc = require('diagnostics_channel'); const onClientRequestStartChannel = dc.channel('http.client.request.start'); +const onClientRequestErrorChannel = dc.channel('http.client.request.error'); const onClientResponseFinishChannel = dc.channel('http.client.response.finish'); +function emitErrorEvent(request, error) { + if (onClientRequestErrorChannel.hasSubscribers) { + onClientRequestErrorChannel.publish({ + request, + error, + }); + } + request.emit('error', error); +} + const { addAbortSignal, finished } = require('stream'); let debug = require('internal/util/debuglog').debuglog('http', (fn) => { @@ -343,7 +354,7 @@ function ClientRequest(input, options, cb) { if (typeof opts.createConnection === 'function') { const oncreate = once((err, socket) => { if (err) { - process.nextTick(() => this.emit('error', err)); + process.nextTick(() => emitErrorEvent(this, err)); } else { this.onSocket(socket); } @@ -465,7 +476,7 @@ function socketCloseListener() { // receive a response. The error needs to // fire on the request. req.socket._hadError = true; - req.emit('error', new ConnResetException('socket hang up')); + emitErrorEvent(req, new ConnResetException('socket hang up')); } req._closed = true; req.emit('close'); @@ -492,7 +503,7 @@ function socketErrorListener(err) { // For Safety. Some additional errors might fire later on // and we need to make sure we don't double-fire the error event. req.socket._hadError = true; - req.emit('error', err); + emitErrorEvent(req, err); } const parser = socket.parser; @@ -516,7 +527,7 @@ function socketOnEnd() { // If we don't have a response then we know that the socket // ended prematurely and we need to emit an error on the request. req.socket._hadError = true; - req.emit('error', new ConnResetException('socket hang up')); + emitErrorEvent(req, new ConnResetException('socket hang up')); } if (parser) { parser.finish(); @@ -541,7 +552,7 @@ function socketOnData(d) { socket.removeListener('end', socketOnEnd); socket.destroy(); req.socket._hadError = true; - req.emit('error', ret); + emitErrorEvent(req, ret); } else if (parser.incoming && parser.incoming.upgrade) { // Upgrade (if status code 101) or CONNECT const bytesParsed = ret; @@ -872,7 +883,7 @@ function onSocketNT(req, socket, err) { err = new ConnResetException('socket hang up'); } if (err) { - req.emit('error', err); + emitErrorEvent(req, err); } req._closed = true; req.emit('close'); diff --git a/lib/assert.js b/lib/assert.js index 9dfcf80a913942..eadc3844c20128 100644 --- a/lib/assert.js +++ b/lib/assert.js @@ -393,7 +393,7 @@ function innerOk(fn, argLen, value, message) { } else if (message == null) { generatedMessage = true; message = getErrMessage(message, fn); - } else if (message instanceof Error) { + } else if (isError(message)) { throw message; } diff --git a/lib/child_process.js b/lib/child_process.js index 41206dc7eda1f7..4e15255a01007b 100644 --- a/lib/child_process.js +++ b/lib/child_process.js @@ -568,6 +568,7 @@ function normalizeSpawnArguments(file, args, options) { else validateObject(options, 'options'); + options = { __proto__: null, ...options }; let cwd = options.cwd; // Validate the cwd, if present. diff --git a/lib/eslint.config_partial.mjs b/lib/eslint.config_partial.mjs index 46b754aa7bc562..97e4f56181564a 100644 --- a/lib/eslint.config_partial.mjs +++ b/lib/eslint.config_partial.mjs @@ -11,23 +11,23 @@ const noRestrictedSyntax = [ ...noRestrictedSyntaxCommonLib, { selector: "CallExpression[callee.object.name='assert']:not([callee.property.name='ok']):not([callee.property.name='fail']):not([callee.property.name='ifError'])", - message: 'Please only use simple assertions in ./lib', + message: 'Only use simple assertions', }, { selector: 'NewExpression[callee.name=/Error$/]:not([callee.name=/^(AssertionError|NghttpError|AbortError|NodeAggregateError)$/])', - message: 'Use an error exported by the internal/errors module.', + message: "Use an error exported by 'internal/errors' instead.", }, { selector: "CallExpression[callee.object.name='Error'][callee.property.name='captureStackTrace']", - message: "Please use `require('internal/errors').hideStackFrames()` instead.", + message: "Use 'hideStackFrames' from 'internal/errors' instead.", }, { selector: "AssignmentExpression:matches([left.object.name='Error']):matches([left.name='prepareStackTrace'], [left.property.name='prepareStackTrace'])", - message: "Use 'overrideStackTrace' from 'lib/internal/errors.js' instead of 'Error.prepareStackTrace'.", + message: "Use 'overrideStackTrace' from 'internal/errors' instead.", }, { selector: "ThrowStatement > NewExpression[callee.name=/^ERR_[A-Z_]+$/] > ObjectExpression:first-child:not(:has([key.name='message']):has([key.name='code']):has([key.name='syscall']))", - message: 'The context passed into SystemError constructor must have .code, .syscall and .message.', + message: 'The context passed into the SystemError constructor must include .code, .syscall, and .message properties.', }, ]; @@ -500,7 +500,7 @@ export default [ ...noRestrictedSyntax, { selector: 'VariableDeclarator:has(.init[name="primordials"]) Identifier[name=/Prototype[A-Z]/]:not([name=/^(Object|Reflect)(Get|Set)PrototypeOf$/])', - message: 'We do not use prototype primordials in this file', + message: 'Do not use prototype primordials in this file.', }, ], }, diff --git a/lib/fs.js b/lib/fs.js index 9e9d23941f114d..042abf8b22d2b8 100644 --- a/lib/fs.js +++ b/lib/fs.js @@ -1349,19 +1349,20 @@ function mkdirSync(path, options) { let mode = 0o777; let recursive = false; if (typeof options === 'number' || typeof options === 'string') { - mode = options; + mode = parseFileMode(options, 'mode'); } else if (options) { - if (options.recursive !== undefined) + if (options.recursive !== undefined) { recursive = options.recursive; - if (options.mode !== undefined) - mode = options.mode; + validateBoolean(recursive, 'options.recursive'); + } + if (options.mode !== undefined) { + mode = parseFileMode(options.mode, 'options.mode'); + } } - path = getValidatedPath(path); - validateBoolean(recursive, 'options.recursive'); const result = binding.mkdir( - path, - parseFileMode(mode, 'mode'), + getValidatedPath(path), + mode, recursive, ); diff --git a/lib/inspector.js b/lib/inspector.js index e51bcf2f3cd977..b38bb1af974819 100644 --- a/lib/inspector.js +++ b/lib/inspector.js @@ -42,6 +42,7 @@ const { isEnabled, waitForDebugger, console, + emitProtocolEvent, } = internalBinding('inspector'); class Session extends EventEmitter { @@ -188,6 +189,20 @@ function inspectorWaitForDebugger() { throw new ERR_INSPECTOR_NOT_ACTIVE(); } +function broadcastToFrontend(eventName, params) { + validateString(eventName, 'eventName'); + if (params) { + validateObject(params, 'params'); + } + emitProtocolEvent(eventName, JSONStringify(params ?? {})); +} + +const Network = { + requestWillBeSent: (params) => broadcastToFrontend('Network.requestWillBeSent', params), + responseReceived: (params) => broadcastToFrontend('Network.responseReceived', params), + loadingFinished: (params) => broadcastToFrontend('Network.loadingFinished', params), +}; + module.exports = { open: inspectorOpen, close: _debugEnd, @@ -195,4 +210,5 @@ module.exports = { waitForDebugger: inspectorWaitForDebugger, console, Session, + Network, }; diff --git a/lib/internal/assert/assertion_error.js b/lib/internal/assert/assertion_error.js index f12243790b0506..5d8c45040af0fe 100644 --- a/lib/internal/assert/assertion_error.js +++ b/lib/internal/assert/assertion_error.js @@ -6,9 +6,9 @@ const { Error, ErrorCaptureStackTrace, MathMax, + ObjectAssign, ObjectDefineProperty, ObjectGetPrototypeOf, - ObjectKeys, String, StringPrototypeEndsWith, StringPrototypeRepeat, @@ -46,11 +46,7 @@ const kReadableOperator = { const kMaxShortLength = 12; function copyError(source) { - const keys = ObjectKeys(source); - const target = { __proto__: ObjectGetPrototypeOf(source) }; - for (const key of keys) { - target[key] = source[key]; - } + const target = ObjectAssign({ __proto__: ObjectGetPrototypeOf(source) }, source); ObjectDefineProperty(target, 'message', { __proto__: null, value: source.message }); return target; } diff --git a/lib/internal/cluster/primary.js b/lib/internal/cluster/primary.js index 107ab258a47e04..630704da8fe614 100644 --- a/lib/internal/cluster/primary.js +++ b/lib/internal/cluster/primary.js @@ -221,12 +221,12 @@ function emitForkNT(worker) { } cluster.disconnect = function(cb) { - const workers = ObjectKeys(cluster.workers); + const workers = ObjectValues(cluster.workers); if (workers.length === 0) { process.nextTick(() => intercom.emit('disconnect')); } else { - for (const worker of ObjectValues(cluster.workers)) { + for (const worker of workers) { if (worker.isConnected()) { worker.disconnect(); } @@ -358,8 +358,6 @@ Worker.prototype.disconnect = function() { }; Worker.prototype.destroy = function(signo) { - const proc = this.process; const signal = signo || 'SIGTERM'; - - proc.kill(signal); + this.process.kill(signal); }; diff --git a/lib/internal/console/constructor.js b/lib/internal/console/constructor.js index c3488d40593acf..6c34a9ededcc60 100644 --- a/lib/internal/console/constructor.js +++ b/lib/internal/console/constructor.js @@ -78,7 +78,6 @@ function lazyUtilColors() { } // Track amount of indentation required via `console.group()`. -const kGroupIndent = Symbol('kGroupIndent'); const kGroupIndentationWidth = Symbol('kGroupIndentWidth'); const kFormatForStderr = Symbol('kFormatForStderr'); const kFormatForStdout = Symbol('kFormatForStdout'); @@ -91,7 +90,6 @@ const kBindStreamsEager = Symbol('kBindStreamsEager'); const kBindStreamsLazy = Symbol('kBindStreamsLazy'); const kUseStdout = Symbol('kUseStdout'); const kUseStderr = Symbol('kUseStderr'); -const kInternalTimeLogImpl = Symbol('kInternalTimeLogImpl'); const optionsMap = new SafeWeakMap(); function Console(options /* or: stdout, stderr, ignoreErrors = true */) { @@ -178,6 +176,8 @@ ObjectDefineProperty(Console, SymbolHasInstance, { const kColorInspectOptions = { colors: true }; const kNoColorInspectOptions = {}; +const internalIndentationMap = new SafeWeakMap(); + ObjectDefineProperties(Console.prototype, { [kBindStreamsEager]: { __proto__: null, @@ -247,7 +247,6 @@ ObjectDefineProperties(Console.prototype, { [kCounts]: { __proto__: null, ...consolePropAttributes, value: new SafeMap() }, [kColorMode]: { __proto__: null, ...consolePropAttributes, value: colorMode }, [kIsConsole]: { __proto__: null, ...consolePropAttributes, value: true }, - [kGroupIndent]: { __proto__: null, ...consolePropAttributes, value: '' }, [kGroupIndentationWidth]: { __proto__: null, ...consolePropAttributes, @@ -268,7 +267,7 @@ ObjectDefineProperties(Console.prototype, { ...consolePropAttributes, value: function(streamSymbol, string, color = '') { const ignoreErrors = this._ignoreErrors; - const groupIndent = this[kGroupIndent]; + const groupIndent = internalIndentationMap.get(this) || ''; const useStdout = streamSymbol === kUseStdout; const stream = useStdout ? this._stdout : this._stderr; @@ -372,11 +371,11 @@ function createWriteErrorHandler(instance, streamSymbol) { }; } -function timeLogImpl(label, formatted, args) { +function timeLogImpl(consoleRef, label, formatted, args) { if (args === undefined) { - this.log('%s: %s', label, formatted); + consoleRef.log('%s: %s', label, formatted); } else { - this.log('%s: %s', label, formatted, ...new SafeArrayIterator(args)); + consoleRef.log('%s: %s', label, formatted, ...new SafeArrayIterator(args)); } } @@ -407,17 +406,11 @@ const consoleMethods = { }, timeEnd(label = 'default') { - if (this[kInternalTimeLogImpl] === undefined) - this[kInternalTimeLogImpl] = FunctionPrototypeBind(timeLogImpl, this); - - timeEnd(this._times, kTraceConsoleCategory, 'console.timeEnd()', kNone, this[kInternalTimeLogImpl], label, `time::${label}`); + timeEnd(this._times, kTraceConsoleCategory, 'console.timeEnd()', kNone, (label, formatted, args) => timeLogImpl(this, label, formatted, args), label, `time::${label}`); }, timeLog(label = 'default', ...data) { - if (this[kInternalTimeLogImpl] === undefined) - this[kInternalTimeLogImpl] = FunctionPrototypeBind(timeLogImpl, this); - - timeLog(this._times, kTraceConsoleCategory, 'console.timeLog()', kNone, this[kInternalTimeLogImpl], label, `time::${label}`, data); + timeLog(this._times, kTraceConsoleCategory, 'console.timeLog()', kNone, (label, formatted, args) => timeLogImpl(this, label, formatted, args), label, `time::${label}`, data); }, trace: function trace(...args) { @@ -489,16 +482,22 @@ const consoleMethods = { if (data.length > 0) { ReflectApply(this.log, this, data); } - this[kGroupIndent] += - StringPrototypeRepeat(' ', this[kGroupIndentationWidth]); + + let currentIndentation = internalIndentationMap.get(this) || ''; + currentIndentation += StringPrototypeRepeat(' ', this[kGroupIndentationWidth]); + + internalIndentationMap.set(this, currentIndentation); }, groupEnd() { - this[kGroupIndent] = StringPrototypeSlice( - this[kGroupIndent], + const currentIndentation = internalIndentationMap.get(this) || ''; + const newIndentation = StringPrototypeSlice( + currentIndentation, 0, - this[kGroupIndent].length - this[kGroupIndentationWidth], + currentIndentation.length - this[kGroupIndentationWidth], ); + + internalIndentationMap.set(this, newIndentation); }, // https://console.spec.whatwg.org/#table diff --git a/lib/internal/errors.js b/lib/internal/errors.js index 45b71cc4a90dd1..855ba65c4bb100 100644 --- a/lib/internal/errors.js +++ b/lib/internal/errors.js @@ -1595,10 +1595,6 @@ E('ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT', 'start offset of %s should be a multiple of %s', RangeError); E('ERR_NAPI_INVALID_TYPEDARRAY_LENGTH', 'Invalid typed array length', RangeError); -E('ERR_NETWORK_IMPORT_BAD_RESPONSE', - "import '%s' received a bad response: %s", Error); -E('ERR_NETWORK_IMPORT_DISALLOWED', - "import of '%s' by %s is not supported: %s", Error); E('ERR_NOT_BUILDING_SNAPSHOT', 'Operation cannot be invoked when not building startup snapshot', Error); E('ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION', @@ -1837,6 +1833,9 @@ E('ERR_UNSUPPORTED_ESM_URL_SCHEME', (url, supported) => { msg += `. Received protocol '${url.protocol}'`; return msg; }, Error); +E('ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING', + 'Stripping types is currently unsupported for files under node_modules, for "%s"', + Error); E('ERR_UNSUPPORTED_RESOLVE_REQUEST', 'Failed to resolve module specifier "%s" from "%s": Invalid relative URL or base scheme is not hierarchical.', TypeError); diff --git a/lib/internal/fs/cp/cp-sync.js b/lib/internal/fs/cp/cp-sync.js index aebc575365dd2e..1e922b7805fc8c 100644 --- a/lib/internal/fs/cp/cp-sync.js +++ b/lib/internal/fs/cp/cp-sync.js @@ -2,33 +2,25 @@ // This file is a modified version of the fs-extra's copySync method. -const { areIdentical, isSrcSubdir } = require('internal/fs/cp/cp'); +const fsBinding = internalBinding('fs'); +const { isSrcSubdir } = require('internal/fs/cp/cp'); const { codes: { - ERR_FS_CP_DIR_TO_NON_DIR, ERR_FS_CP_EEXIST, ERR_FS_CP_EINVAL, - ERR_FS_CP_FIFO_PIPE, - ERR_FS_CP_NON_DIR_TO_DIR, - ERR_FS_CP_SOCKET, ERR_FS_CP_SYMLINK_TO_SUBDIRECTORY, - ERR_FS_CP_UNKNOWN, - ERR_FS_EISDIR, ERR_INVALID_RETURN_VALUE, } } = require('internal/errors'); const { os: { errno: { EEXIST, - EISDIR, EINVAL, - ENOTDIR, }, }, } = internalBinding('constants'); const { chmodSync, copyFileSync, - existsSync, lstatSync, mkdirSync, opendirSync, @@ -42,7 +34,6 @@ const { dirname, isAbsolute, join, - parse, resolve, } = require('path'); const { isPromise } = require('util/types'); @@ -54,145 +45,38 @@ function cpSyncFn(src, dest, opts) { 'node is not recommended'; process.emitWarning(warning, 'TimestampPrecisionWarning'); } - const { srcStat, destStat, skipped } = checkPathsSync(src, dest, opts); - if (skipped) return; - checkParentPathsSync(src, srcStat, dest); - return checkParentDir(destStat, src, dest, opts); -} - -function checkPathsSync(src, dest, opts) { if (opts.filter) { const shouldCopy = opts.filter(src, dest); if (isPromise(shouldCopy)) { throw new ERR_INVALID_RETURN_VALUE('boolean', 'filter', shouldCopy); } - if (!shouldCopy) return { __proto__: null, skipped: true }; + if (!shouldCopy) return; } - const { srcStat, destStat } = getStatsSync(src, dest, opts); - if (destStat) { - if (areIdentical(srcStat, destStat)) { - throw new ERR_FS_CP_EINVAL({ - message: 'src and dest cannot be the same', - path: dest, - syscall: 'cp', - errno: EINVAL, - code: 'EINVAL', - }); - } - if (srcStat.isDirectory() && !destStat.isDirectory()) { - throw new ERR_FS_CP_DIR_TO_NON_DIR({ - message: `cannot overwrite non-directory ${dest} ` + - `with directory ${src}`, - path: dest, - syscall: 'cp', - errno: EISDIR, - code: 'EISDIR', - }); - } - if (!srcStat.isDirectory() && destStat.isDirectory()) { - throw new ERR_FS_CP_NON_DIR_TO_DIR({ - message: `cannot overwrite directory ${dest} ` + - `with non-directory ${src}`, - path: dest, - syscall: 'cp', - errno: ENOTDIR, - code: 'ENOTDIR', - }); - } - } - - if (srcStat.isDirectory() && isSrcSubdir(src, dest)) { - throw new ERR_FS_CP_EINVAL({ - message: `cannot copy ${src} to a subdirectory of self ${dest}`, - path: dest, - syscall: 'cp', - errno: EINVAL, - code: 'EINVAL', - }); - } - return { __proto__: null, srcStat, destStat, skipped: false }; -} + fsBinding.cpSyncCheckPaths(src, dest, opts.dereference, opts.recursive); -function getStatsSync(src, dest, opts) { - const statFunc = opts.dereference ? statSync : lstatSync; - const srcStat = statFunc(src, { bigint: true, throwIfNoEntry: true }); - const destStat = statFunc(dest, { bigint: true, throwIfNoEntry: false }); - return { srcStat, destStat }; + return getStats(src, dest, opts); } -function checkParentPathsSync(src, srcStat, dest) { - const srcParent = resolve(dirname(src)); - const destParent = resolve(dirname(dest)); - if (destParent === srcParent || destParent === parse(destParent).root) return; - const destStat = statSync(destParent, { bigint: true, throwIfNoEntry: false }); - - if (destStat === undefined) { - return; - } - - if (areIdentical(srcStat, destStat)) { - throw new ERR_FS_CP_EINVAL({ - message: `cannot copy ${src} to a subdirectory of self ${dest}`, - path: dest, - syscall: 'cp', - errno: EINVAL, - code: 'EINVAL', - }); - } - return checkParentPathsSync(src, srcStat, destParent); -} - -function checkParentDir(destStat, src, dest, opts) { - const destParent = dirname(dest); - if (!existsSync(destParent)) mkdirSync(destParent, { recursive: true }); - return getStats(destStat, src, dest, opts); -} - -function getStats(destStat, src, dest, opts) { +function getStats(src, dest, opts) { + // TODO(@anonrig): Avoid making two stat calls. const statSyncFn = opts.dereference ? statSync : lstatSync; const srcStat = statSyncFn(src); + const destStat = statSyncFn(dest, { bigint: true, throwIfNoEntry: false }); if (srcStat.isDirectory() && opts.recursive) { return onDir(srcStat, destStat, src, dest, opts); - } else if (srcStat.isDirectory()) { - throw new ERR_FS_EISDIR({ - message: `${src} is a directory (not copied)`, - path: src, - syscall: 'cp', - errno: EINVAL, - code: 'EISDIR', - }); } else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) { return onFile(srcStat, destStat, src, dest, opts); } else if (srcStat.isSymbolicLink()) { - return onLink(destStat, src, dest, opts); - } else if (srcStat.isSocket()) { - throw new ERR_FS_CP_SOCKET({ - message: `cannot copy a socket file: ${dest}`, - path: dest, - syscall: 'cp', - errno: EINVAL, - code: 'EINVAL', - }); - } else if (srcStat.isFIFO()) { - throw new ERR_FS_CP_FIFO_PIPE({ - message: `cannot copy a FIFO pipe: ${dest}`, - path: dest, - syscall: 'cp', - errno: EINVAL, - code: 'EINVAL', - }); + return onLink(destStat, src, dest, opts.verbatimSymlinks); } - throw new ERR_FS_CP_UNKNOWN({ - message: `cannot copy an unknown file type: ${dest}`, - path: dest, - syscall: 'cp', - errno: EINVAL, - code: 'EINVAL', - }); + + // It is not possible to get here because all possible cases are handled above. + const assert = require('internal/assert'); + assert.fail('Unreachable code'); } function onFile(srcStat, destStat, src, dest, opts) { @@ -200,6 +84,7 @@ function onFile(srcStat, destStat, src, dest, opts) { return mayCopyFile(srcStat, src, dest, opts); } +// TODO(@anonrig): Move this function to C++. function mayCopyFile(srcStat, src, dest, opts) { if (opts.force) { unlinkSync(dest); @@ -249,6 +134,7 @@ function setDestTimestamps(src, dest) { return utimesSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime); } +// TODO(@anonrig): Move this function to C++. function onDir(srcStat, destStat, src, dest, opts) { if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts); return copyDir(src, dest, opts); @@ -260,6 +146,7 @@ function mkDirAndCopy(srcMode, src, dest, opts) { return setDestMode(dest, srcMode); } +// TODO(@anonrig): Move this function to C++. function copyDir(src, dest, opts) { const dir = opendirSync(src); @@ -270,17 +157,28 @@ function copyDir(src, dest, opts) { const { name } = dirent; const srcItem = join(src, name); const destItem = join(dest, name); - const { destStat, skipped } = checkPathsSync(srcItem, destItem, opts); - if (!skipped) getStats(destStat, srcItem, destItem, opts); + let shouldCopy = true; + + if (opts.filter) { + shouldCopy = opts.filter(srcItem, destItem); + if (isPromise(shouldCopy)) { + throw new ERR_INVALID_RETURN_VALUE('boolean', 'filter', shouldCopy); + } + } + + if (shouldCopy) { + getStats(srcItem, destItem, opts); + } } } finally { dir.closeSync(); } } -function onLink(destStat, src, dest, opts) { +// TODO(@anonrig): Move this function to C++. +function onLink(destStat, src, dest, verbatimSymlinks) { let resolvedSrc = readlinkSync(src); - if (!opts.verbatimSymlinks && !isAbsolute(resolvedSrc)) { + if (!verbatimSymlinks && !isAbsolute(resolvedSrc)) { resolvedSrc = resolve(dirname(src), resolvedSrc); } if (!destStat) { diff --git a/lib/internal/fs/glob.js b/lib/internal/fs/glob.js index 215257e1951ae9..be3c48da755520 100644 --- a/lib/internal/fs/glob.js +++ b/lib/internal/fs/glob.js @@ -542,7 +542,7 @@ class Glob { const fromSymlink = pattern.symlinks.has(index); if (current === lazyMinimatch().GLOBSTAR) { - if (entry.name[0] === '.' || (this.#exclude && this.#exclude(entry.name))) { + if (entry.name[0] === '.' || (this.#exclude && this.#exclude(this.#withFileTypes ? entry : entry.name))) { continue; } if (!fromSymlink && entry.isDirectory()) { diff --git a/lib/internal/fs/promises.js b/lib/internal/fs/promises.js index 8fe48a30cda3b9..79c4eeb1ae464c 100644 --- a/lib/internal/fs/promises.js +++ b/lib/internal/fs/promises.js @@ -1175,15 +1175,8 @@ async function mkdtemp(prefix, options) { prefix = getValidatedPath(prefix, 'prefix'); warnOnNonPortableTemplate(prefix); - let path; - if (typeof prefix === 'string') { - path = `${prefix}XXXXXX`; - } else { - path = Buffer.concat([prefix, Buffer.from('XXXXXX')]); - } - return await PromisePrototypeThen( - binding.mkdtemp(path, options.encoding, kUsePromises), + binding.mkdtemp(prefix, options.encoding, kUsePromises), undefined, handleErrorFromBinding, ); diff --git a/lib/internal/http.js b/lib/internal/http.js index 6fc0156bf5265f..251f51ec454f9c 100644 --- a/lib/internal/http.js +++ b/lib/internal/http.js @@ -6,7 +6,7 @@ const { } = primordials; const { setUnrefTimeout } = require('internal/timers'); -const { trace, isTraceCategoryEnabled } = internalBinding('trace_events'); +const { getCategoryEnabledBuffer, trace } = internalBinding('trace_events'); const { CHAR_LOWERCASE_B, CHAR_LOWERCASE_E, @@ -35,8 +35,10 @@ function getNextTraceEventId() { return ++traceEventId; } +const httpEnabled = getCategoryEnabledBuffer('node.http'); + function isTraceHTTPEnabled() { - return isTraceCategoryEnabled('node.http'); + return httpEnabled[0] > 0; } const traceEventCategory = 'node,node.http'; diff --git a/lib/internal/inspector_network_tracking.js b/lib/internal/inspector_network_tracking.js new file mode 100644 index 00000000000000..4865537e37b7d5 --- /dev/null +++ b/lib/internal/inspector_network_tracking.js @@ -0,0 +1,63 @@ +'use strict'; + +const { + DateNow, +} = primordials; + +let dc; +let Network; + +let requestId = 0; +const getNextRequestId = () => `node-network-event-${++requestId}`; + +function onClientRequestStart({ request }) { + const url = `${request.protocol}//${request.host}${request.path}`; + const wallTime = DateNow(); + const timestamp = wallTime / 1000; + request._inspectorRequestId = getNextRequestId(); + Network.requestWillBeSent({ + requestId: request._inspectorRequestId, + timestamp, + wallTime, + request: { + url, + method: request.method, + }, + }); +} + +function onClientResponseFinish({ request }) { + if (typeof request._inspectorRequestId !== 'string') { + return; + } + const timestamp = DateNow() / 1000; + Network.responseReceived({ + requestId: request._inspectorRequestId, + timestamp, + }); + Network.loadingFinished({ + requestId: request._inspectorRequestId, + timestamp, + }); +} + +function enable() { + if (!dc) { + dc = require('diagnostics_channel'); + } + if (!Network) { + Network = require('inspector').Network; + } + dc.subscribe('http.client.request.start', onClientRequestStart); + dc.subscribe('http.client.response.finish', onClientResponseFinish); +} + +function disable() { + dc.unsubscribe('http.client.request.start', onClientRequestStart); + dc.unsubscribe('http.client.response.finish', onClientResponseFinish); +} + +module.exports = { + enable, + disable, +}; diff --git a/lib/internal/main/eval_string.js b/lib/internal/main/eval_string.js index 1125aa8d98e5aa..716cb7e8c8eb06 100644 --- a/lib/internal/main/eval_string.js +++ b/lib/internal/main/eval_string.js @@ -14,7 +14,7 @@ const { markBootstrapComplete, } = require('internal/process/pre_execution'); const { evalModuleEntryPoint, evalScript } = require('internal/process/execution'); -const { addBuiltinLibsToObject } = require('internal/modules/helpers'); +const { addBuiltinLibsToObject, tsParse } = require('internal/modules/helpers'); const { getOptionValue } = require('internal/options'); @@ -22,7 +22,11 @@ prepareMainThreadExecution(); addBuiltinLibsToObject(globalThis, ''); markBootstrapComplete(); -const source = getOptionValue('--eval'); +const code = getOptionValue('--eval'); +const source = getOptionValue('--experimental-strip-types') ? + tsParse(code) : + code; + const print = getOptionValue('--print'); const shouldLoadESM = getOptionValue('--import').length > 0 || getOptionValue('--experimental-loader').length > 0; if (getOptionValue('--input-type') === 'module' || diff --git a/lib/internal/main/test_runner.js b/lib/internal/main/test_runner.js index 5d4140bef94a62..a42c1e5dff64cc 100644 --- a/lib/internal/main/test_runner.js +++ b/lib/internal/main/test_runner.js @@ -1,26 +1,20 @@ 'use strict'; const { - NumberParseInt, - RegExpPrototypeExec, - StringPrototypeSplit, + ArrayPrototypeSlice, } = primordials; const { prepareMainThreadExecution, markBootstrapComplete, } = require('internal/process/pre_execution'); -const { getOptionValue } = require('internal/options'); const { isUsingInspector } = require('internal/util/inspector'); const { run } = require('internal/test_runner/runner'); -const { setupTestReporters } = require('internal/test_runner/utils'); -const { exitCodes: { kGenericUserError } } = internalBinding('errors'); const { - codes: { - ERR_INVALID_ARG_VALUE, - }, -} = require('internal/errors'); - + parseCommandLine, + setupTestReporters, +} = require('internal/test_runner/utils'); +const { exitCodes: { kGenericUserError } } = internalBinding('errors'); let debug = require('internal/util/debuglog').debuglog('test_runner', (fn) => { debug = fn; }); @@ -28,7 +22,14 @@ let debug = require('internal/util/debuglog').debuglog('test_runner', (fn) => { prepareMainThreadExecution(false); markBootstrapComplete(); -let concurrency = getOptionValue('--test-concurrency') || true; +const { + perFileTimeout, + runnerConcurrency, + shard, + watchMode, +} = parseCommandLine(); + +let concurrency = runnerConcurrency; let inspectPort; if (isUsingInspector()) { @@ -38,40 +39,14 @@ if (isUsingInspector()) { inspectPort = process.debugPort; } -let shard; -const shardOption = getOptionValue('--test-shard'); -if (shardOption) { - if (!RegExpPrototypeExec(/^\d+\/\d+$/, shardOption)) { - process.exitCode = kGenericUserError; - - throw new ERR_INVALID_ARG_VALUE( - '--test-shard', - shardOption, - 'must be in the form of /', - ); - } - - const { 0: indexStr, 1: totalStr } = StringPrototypeSplit(shardOption, '/'); - - const index = NumberParseInt(indexStr, 10); - const total = NumberParseInt(totalStr, 10); - - shard = { - __proto__: null, - index, - total, - }; -} - -const timeout = getOptionValue('--test-timeout') || Infinity; - const options = { concurrency, inspectPort, - watch: getOptionValue('--watch'), + watch: watchMode, setup: setupTestReporters, - timeout, + timeout: perFileTimeout, shard, + globPatterns: ArrayPrototypeSlice(process.argv, 1), }; debug('test runner configuration:', options); run(options).on('test:fail', (data) => { diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js index 825c119674828c..9f9e37692a5929 100644 --- a/lib/internal/modules/cjs/loader.js +++ b/lib/internal/modules/cjs/loader.js @@ -146,6 +146,7 @@ const { safeGetenv } = internalBinding('credentials'); const { getCjsConditions, initializeCjsConditions, + isUnderNodeModules, loadBuiltinModule, makeRequireFunction, setHasStartedUserCJSExecution, @@ -168,6 +169,7 @@ const { ERR_REQUIRE_CYCLE_MODULE, ERR_REQUIRE_ESM, ERR_UNKNOWN_BUILTIN_MODULE, + ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING, }, setArrowMessage, } = require('internal/errors'); @@ -428,9 +430,18 @@ function initializeCJS() { Module.runMain = require('internal/modules/run_main').executeUserEntryPoint; + const tsEnabled = getOptionValue('--experimental-strip-types'); + if (tsEnabled) { + emitExperimentalWarning('Type Stripping'); + Module._extensions['.cts'] = loadCTS; + Module._extensions['.ts'] = loadTS; + } if (getOptionValue('--experimental-require-module')) { emitExperimentalWarning('Support for loading ES Module in require()'); Module._extensions['.mjs'] = loadESMFromCJS; + if (tsEnabled) { + Module._extensions['.mts'] = loadESMFromCJS; + } } } @@ -639,10 +650,28 @@ function resolveExports(nmPath, request) { // We don't cache this in case user extends the extensions. function getDefaultExtensions() { - const extensions = ObjectKeys(Module._extensions); + let extensions = ObjectKeys(Module._extensions); + const tsEnabled = getOptionValue('--experimental-strip-types'); + if (tsEnabled) { + // remove .ts and .cts from the default extensions + // to avoid extensionless require of .ts and .cts files. + // it behaves similarly to how .mjs is handled when --experimental-require-module + // is enabled. + extensions = ArrayPrototypeFilter(extensions, (ext) => + (ext !== '.ts' || Module._extensions['.ts'] !== loadTS) && + (ext !== '.cts' || Module._extensions['.cts'] !== loadCTS), + ); + } + if (!getOptionValue('--experimental-require-module')) { return extensions; } + + if (tsEnabled) { + extensions = ArrayPrototypeFilter(extensions, (ext) => + ext !== '.mts' || Module._extensions['.mts'] !== loadESMFromCJS, + ); + } // If the .mjs extension is added by --experimental-require-module, // remove it from the supported default extensions to maintain // compatibility. @@ -1279,6 +1308,12 @@ Module.prototype.load = function(filename) { throw new ERR_REQUIRE_ESM(filename, true); } + if (getOptionValue('--experimental-strip-types')) { + if (StringPrototypeEndsWith(filename, '.mts') && !Module._extensions['.mts']) { + throw new ERR_REQUIRE_ESM(filename, true); + } + } + Module._extensions[extension](this, filename); this.loaded = true; @@ -1322,7 +1357,14 @@ let hasPausedEntry = false; * @param {string} filename Absolute path of the file. */ function loadESMFromCJS(mod, filename) { - const source = getMaybeCachedSource(mod, filename); + let source = getMaybeCachedSource(mod, filename); + if (getOptionValue('--experimental-strip-types') && path.extname(filename) === '.mts') { + if (isUnderNodeModules(filename)) { + throw new ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING(filename); + } + const { tsParse } = require('internal/modules/helpers'); + source = tsParse(source); + } const cascadedLoader = require('internal/modules/esm/loader').getOrInitializeCascadedLoader(); const isMain = mod[kIsMainSymbol]; if (isMain) { @@ -1529,6 +1571,77 @@ function getMaybeCachedSource(mod, filename) { return content; } +function loadCTS(module, filename) { + if (isUnderNodeModules(filename)) { + throw new ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING(filename); + } + const source = getMaybeCachedSource(module, filename); + const { tsParse } = require('internal/modules/helpers'); + const content = tsParse(source); + module._compile(content, filename, 'commonjs'); +} + +/** + * Built-in handler for `.ts` files. + * @param {Module} module The module to compile + * @param {string} filename The file path of the module + */ +function loadTS(module, filename) { + if (isUnderNodeModules(filename)) { + throw new ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING(filename); + } + // If already analyzed the source, then it will be cached. + const source = getMaybeCachedSource(module, filename); + const { tsParse } = require('internal/modules/helpers'); + const content = tsParse(source); + let format; + const pkg = packageJsonReader.getNearestParentPackageJSON(filename); + // Function require shouldn't be used in ES modules. + if (pkg?.data.type === 'module') { + if (getOptionValue('--experimental-require-module')) { + module._compile(content, filename, 'module'); + return; + } + + const parent = module[kModuleParent]; + const parentPath = parent?.filename; + const packageJsonPath = path.resolve(pkg.path, 'package.json'); + const usesEsm = containsModuleSyntax(content, filename); + const err = new ERR_REQUIRE_ESM(filename, usesEsm, parentPath, + packageJsonPath); + // Attempt to reconstruct the parent require frame. + if (Module._cache[parentPath]) { + let parentSource; + try { + parentSource = tsParse(fs.readFileSync(parentPath, 'utf8')); + } catch { + // Continue regardless of error. + } + if (parentSource) { + reconstructErrorStack(err, parentPath, parentSource); + } + } + throw err; + } else if (pkg?.data.type === 'commonjs') { + format = 'commonjs'; + } + + module._compile(content, filename, format); +}; + +function reconstructErrorStack(err, parentPath, parentSource) { + const errLine = StringPrototypeSplit( + StringPrototypeSlice(err.stack, StringPrototypeIndexOf( + err.stack, ' at ')), '\n', 1)[0]; + const { 1: line, 2: col } = + RegExpPrototypeExec(/(\d+):(\d+)\)/, errLine) || []; + if (line && col) { + const srcLine = StringPrototypeSplit(parentSource, '\n')[line - 1]; + const frame = `${parentPath}:${line}\n${srcLine}\n${StringPrototypeRepeat(' ', col - 1)}^\n`; + setArrowMessage(err, frame); + } +} + /** * Built-in handler for `.js` files. * @param {Module} module The module to compile @@ -1564,17 +1677,7 @@ Module._extensions['.js'] = function(module, filename) { // Continue regardless of error. } if (parentSource) { - const errLine = StringPrototypeSplit( - StringPrototypeSlice(err.stack, StringPrototypeIndexOf( - err.stack, ' at ')), '\n', 1)[0]; - const { 1: line, 2: col } = - RegExpPrototypeExec(/(\d+):(\d+)\)/, errLine) || []; - if (line && col) { - const srcLine = StringPrototypeSplit(parentSource, '\n')[line - 1]; - const frame = `${parentPath}:${line}\n${srcLine}\n${ - StringPrototypeRepeat(' ', col - 1)}^\n`; - setArrowMessage(err, frame); - } + reconstructErrorStack(err, parentPath, parentSource); } } throw err; diff --git a/lib/internal/modules/esm/formats.js b/lib/internal/modules/esm/formats.js index 9f59349997fce3..608b69caf3fe49 100644 --- a/lib/internal/modules/esm/formats.js +++ b/lib/internal/modules/esm/formats.js @@ -23,6 +23,12 @@ if (experimentalWasmModules) { extensionFormatMap['.wasm'] = 'wasm'; } +if (getOptionValue('--experimental-strip-types')) { + extensionFormatMap['.ts'] = 'module-typescript'; + extensionFormatMap['.mts'] = 'module-typescript'; + extensionFormatMap['.cts'] = 'commonjs-typescript'; +} + /** * @param {string} mime * @returns {string | null} diff --git a/lib/internal/modules/esm/get_format.js b/lib/internal/modules/esm/get_format.js index cd5c88dce8e021..207cd91edd61af 100644 --- a/lib/internal/modules/esm/get_format.js +++ b/lib/internal/modules/esm/get_format.js @@ -2,8 +2,6 @@ const { ObjectPrototypeHasOwnProperty, - PromisePrototypeThen, - PromiseResolve, RegExpPrototypeExec, SafeSet, StringPrototypeCharCodeAt, @@ -17,8 +15,7 @@ const { mimeToFormat, } = require('internal/modules/esm/formats'); -const experimentalNetworkImports = - getOptionValue('--experimental-network-imports'); +const detectModule = getOptionValue('--experimental-detect-module'); const { containsModuleSyntax } = internalBinding('contextify'); const { getPackageScopeConfig, getPackageType } = require('internal/modules/package_json_reader'); const { fileURLToPath } = require('internal/url'); @@ -28,11 +25,20 @@ const protocolHandlers = { '__proto__': null, 'data:': getDataProtocolModuleFormat, 'file:': getFileProtocolModuleFormat, - 'http:': getHttpProtocolModuleFormat, - 'https:': getHttpProtocolModuleFormat, 'node:'() { return 'builtin'; }, }; +/** + * Determine whether the given ambiguous source contains CommonJS or ES module syntax. + * @param {string | Buffer | undefined} source + * @param {URL} url + */ +function detectModuleFormat(source, url) { + if (!source) { return detectModule ? null : 'commonjs'; } + if (!detectModule) { return 'commonjs'; } + return containsModuleSyntax(`${source}`, fileURLToPath(url), url) ? 'module' : 'commonjs'; +} + /** * @param {URL} parsed * @returns {string | null} @@ -83,6 +89,18 @@ function underNodeModules(url) { } let typelessPackageJsonFilesWarnedAbout; +function warnTypelessPackageJsonFile(pjsonPath, url) { + typelessPackageJsonFilesWarnedAbout ??= new SafeSet(); + if (!typelessPackageJsonFilesWarnedAbout.has(pjsonPath)) { + const warning = `${url} parsed as an ES module because module syntax was detected;` + + ` to avoid the performance penalty of syntax detection, add "type": "module" to ${pjsonPath}`; + process.emitWarning(warning, { + code: 'MODULE_TYPELESS_PACKAGE_JSON', + }); + typelessPackageJsonFilesWarnedAbout.add(pjsonPath); + } +} + /** * @param {URL} url * @param {{parentURL: string; source?: Buffer}} context @@ -112,26 +130,47 @@ function getFileProtocolModuleFormat(url, context = { __proto__: null }, ignoreE default: { // The user did not pass `--experimental-default-type`. // `source` is undefined when this is called from `defaultResolve`; // but this gets called again from `defaultLoad`/`defaultLoadSync`. - if (getOptionValue('--experimental-detect-module')) { - const format = source ? - (containsModuleSyntax(`${source}`, fileURLToPath(url), url) ? 'module' : 'commonjs') : - null; - if (format === 'module') { - // This module has a .js extension, a package.json with no `type` field, and ESM syntax. - // Warn about the missing `type` field so that the user can avoid the performance penalty of detection. - typelessPackageJsonFilesWarnedAbout ??= new SafeSet(); - if (!typelessPackageJsonFilesWarnedAbout.has(pjsonPath)) { - const warning = `${url} parsed as an ES module because module syntax was detected;` + - ` to avoid the performance penalty of syntax detection, add "type": "module" to ${pjsonPath}`; - process.emitWarning(warning, { - code: 'MODULE_TYPELESS_PACKAGE_JSON', - }); - typelessPackageJsonFilesWarnedAbout.add(pjsonPath); - } - } - return format; + // For ambiguous files (no type field, .js extension) we return + // undefined from `resolve` and re-run the check in `load`. + const format = detectModuleFormat(source, url); + if (format === 'module') { + // This module has a .js extension, a package.json with no `type` field, and ESM syntax. + // Warn about the missing `type` field so that the user can avoid the performance penalty of detection. + warnTypelessPackageJsonFile(pjsonPath, url); } - return 'commonjs'; + return format; + } + } + } + if (ext === '.ts' && getOptionValue('--experimental-strip-types')) { + const { type: packageType, pjsonPath } = getPackageScopeConfig(url); + if (packageType !== 'none') { + return `${packageType}-typescript`; + } + // The controlling `package.json` file has no `type` field. + switch (getOptionValue('--experimental-default-type')) { + case 'module': { // The user explicitly passed `--experimental-default-type=module`. + // An exception to the type flag making ESM the default everywhere is that package scopes under `node_modules` + // should retain the assumption that a lack of a `type` field means CommonJS. + return underNodeModules(url) ? 'commonjs-typescript' : 'module-typescript'; + } + case 'commonjs': { // The user explicitly passed `--experimental-default-type=commonjs`. + return 'commonjs-typescript'; + } + default: { // The user did not pass `--experimental-default-type`. + // `source` is undefined when this is called from `defaultResolve`; + // but this gets called again from `defaultLoad`/`defaultLoadSync`. + const { tsParse } = require('internal/modules/helpers'); + const parsedSource = tsParse(source); + const detectedFormat = detectModuleFormat(parsedSource, url); + // When source is undefined, default to module-typescript. + const format = detectedFormat ? `${detectedFormat}-typescript` : 'module-typescript'; + if (format === 'module-typescript') { + // This module has a .js extension, a package.json with no `type` field, and ESM syntax. + // Warn about the missing `type` field so that the user can avoid the performance penalty of detection. + warnTypelessPackageJsonFile(pjsonPath, url); + } + return format; } } } @@ -154,15 +193,14 @@ function getFileProtocolModuleFormat(url, context = { __proto__: null }, ignoreE return 'commonjs'; } default: { // The user did not pass `--experimental-default-type`. - if (getOptionValue('--experimental-detect-module')) { - if (!source) { return null; } - const format = getFormatOfExtensionlessFile(url); - if (format === 'module') { - return containsModuleSyntax(`${source}`, fileURLToPath(url), url) ? 'module' : 'commonjs'; - } + if (!source) { + return null; + } + const format = getFormatOfExtensionlessFile(url); + if (format === 'wasm') { return format; } - return 'commonjs'; + return detectModuleFormat(source, url); } } } @@ -176,23 +214,6 @@ function getFileProtocolModuleFormat(url, context = { __proto__: null }, ignoreE throw new ERR_UNKNOWN_FILE_EXTENSION(ext, filepath); } -/** - * @param {URL} url - * @param {{parentURL: string}} context - * @returns {Promise | undefined} only works when enabled - */ -function getHttpProtocolModuleFormat(url, context) { - if (experimentalNetworkImports) { - const { fetchModule } = require('internal/modules/esm/fetch_module'); - return PromisePrototypeThen( - PromiseResolve(fetchModule(url, context)), - (entry) => { - return mimeToFormat(entry.headers['content-type']); - }, - ); - } -} - /** * @param {URL} url * @param {{parentURL: string}} context diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js index 1ca6495c84a029..e82f7715e7aa45 100644 --- a/lib/internal/modules/esm/load.js +++ b/lib/internal/modules/esm/load.js @@ -1,7 +1,6 @@ 'use strict'; const { - ArrayPrototypePush, RegExpPrototypeExec, decodeURIComponent, } = primordials; @@ -12,18 +11,20 @@ const { validateAttributes, emitImportAssertionWarning } = require('internal/mod const { getOptionValue } = require('internal/options'); const { readFileSync } = require('fs'); -const experimentalNetworkImports = - getOptionValue('--experimental-network-imports'); const defaultType = getOptionValue('--experimental-default-type'); const { Buffer: { from: BufferFrom } } = require('buffer'); +const { + isUnderNodeModules, +} = require('internal/modules/helpers'); const { URL } = require('internal/url'); const { ERR_INVALID_URL, ERR_UNKNOWN_MODULE_FORMAT, ERR_UNSUPPORTED_ESM_URL_SCHEME, + ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING, } = require('internal/errors').codes; const DATA_URL_PATTERN = /^[^/]+\/[^,;]+(?:[^,]*?)(;base64)?,([\s\S]*)$/; @@ -35,7 +36,7 @@ const DATA_URL_PATTERN = /^[^/]+\/[^,;]+(?:[^,]*?)(;base64)?,([\s\S]*)$/; */ async function getSource(url, context) { const { protocol, href } = url; - let responseURL = href; + const responseURL = href; let source; if (protocol === 'file:') { const { readFile: readFileAsync } = require('internal/fs/promises').exports; @@ -47,19 +48,8 @@ async function getSource(url, context) { } const { 1: base64, 2: body } = match; source = BufferFrom(decodeURIComponent(body), base64 ? 'base64' : 'utf8'); - } else if (experimentalNetworkImports && ( - protocol === 'https:' || - protocol === 'http:' - )) { - const { fetchModule } = require('internal/modules/esm/fetch_module'); - const res = await fetchModule(url, context); - source = await res.body; - responseURL = res.resolvedHREF; } else { const supportedSchemes = ['file', 'data']; - if (experimentalNetworkImports) { - ArrayPrototypePush(supportedSchemes, 'http', 'https'); - } throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(url, supportedSchemes); } return { __proto__: null, responseURL, source }; @@ -117,7 +107,7 @@ async function defaultLoad(url, context = kEmptyObject) { const urlInstance = new URL(url); - throwIfUnsupportedURLScheme(urlInstance, experimentalNetworkImports); + throwIfUnsupportedURLScheme(urlInstance); if (urlInstance.protocol === 'node:') { source = null; @@ -147,6 +137,12 @@ async function defaultLoad(url, context = kEmptyObject) { format = 'commonjs-sync'; } + if (getOptionValue('--experimental-strip-types') && + (format === 'module-typescript' || format === 'commonjs-typescript') && + isUnderNodeModules(url)) { + throw new ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING(url); + } + return { __proto__: null, format, @@ -214,9 +210,8 @@ function defaultLoadSync(url, context = kEmptyObject) { * throws an error if the protocol is not one of the protocols * that can be loaded in the default loader * @param {URL} parsed - * @param {boolean} experimentalNetworkImports */ -function throwIfUnsupportedURLScheme(parsed, experimentalNetworkImports) { +function throwIfUnsupportedURLScheme(parsed) { // Avoid accessing the `protocol` property due to the lazy getters. const protocol = parsed?.protocol; if ( @@ -225,17 +220,11 @@ function throwIfUnsupportedURLScheme(parsed, experimentalNetworkImports) { protocol !== 'data:' && protocol !== 'node:' && ( - !experimentalNetworkImports || - ( - protocol !== 'https:' && - protocol !== 'http:' - ) + protocol !== 'https:' && + protocol !== 'http:' ) ) { const schemes = ['file', 'data', 'node']; - if (experimentalNetworkImports) { - ArrayPrototypePush(schemes, 'https', 'http'); - } throw new ERR_UNSUPPORTED_ESM_URL_SCHEME(parsed, schemes); } } diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js index 92491e088ee054..e0d39808332466 100644 --- a/lib/internal/modules/esm/loader.js +++ b/lib/internal/modules/esm/loader.js @@ -30,7 +30,7 @@ const { } = require('internal/errors').codes; const { getOptionValue } = require('internal/options'); const { isURL, pathToFileURL, URLParse } = require('internal/url'); -const { emitExperimentalWarning, kEmptyObject } = require('internal/util'); +const { kEmptyObject } = require('internal/util'); const { compileSourceTextModule, getDefaultConditions, @@ -145,9 +145,6 @@ class ModuleLoader { #customizations; constructor(customizations) { - if (getOptionValue('--experimental-network-imports')) { - emitExperimentalWarning('Network Imports'); - } this.setCustomizations(customizations); } @@ -579,13 +576,18 @@ class ModuleLoader { this.#customizations.loadSync(url, context) : defaultLoadSync(url, context); let format = result?.format; - if (format === 'module') { + if (format === 'module' || format === 'module-typescript') { throw new ERR_REQUIRE_ESM(url, true); } if (format === 'commonjs') { format = 'require-commonjs'; result = { __proto__: result, format }; } + if (format === 'commonjs-typescript') { + format = 'require-commonjs-typescript'; + result = { __proto__: result, format }; + } + this.validateLoadResult(url, format); return result; } diff --git a/lib/internal/modules/esm/resolve.js b/lib/internal/modules/esm/resolve.js index 66126d9702c5b0..e18fbf65075773 100644 --- a/lib/internal/modules/esm/resolve.js +++ b/lib/internal/modules/esm/resolve.js @@ -30,8 +30,6 @@ const { getOptionValue } = require('internal/options'); const { sep, posix: { relative: relativePosixPath }, resolve } = require('path'); const preserveSymlinks = getOptionValue('--preserve-symlinks'); const preserveSymlinksMain = getOptionValue('--preserve-symlinks-main'); -const experimentalNetworkImports = - getOptionValue('--experimental-network-imports'); const inputTypeFlag = getOptionValue('--input-type'); const { URL, pathToFileURL, fileURLToPath, isURL, URLParse } = require('internal/url'); const { getCWDURL, setOwnProperty } = require('internal/util'); @@ -48,7 +46,6 @@ const { ERR_PACKAGE_PATH_NOT_EXPORTED, ERR_UNSUPPORTED_DIR_IMPORT, ERR_UNSUPPORTED_RESOLVE_REQUEST, - ERR_NETWORK_IMPORT_DISALLOWED, } = require('internal/errors').codes; const { Module: CJSModule } = require('internal/modules/cjs/loader'); @@ -886,10 +883,6 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) { StringPrototypeSlice(base, 0, StringPrototypeIndexOf(base, ':') + 1) : base.protocol; const isData = protocol === 'data:'; - const isRemote = - isData || - protocol === 'http:' || - protocol === 'https:'; // Order swapped from spec for minor perf gain. // Ok since relative URLs cannot parse as URLs. let resolved; @@ -907,7 +900,7 @@ function moduleResolve(specifier, base, conditions, preserveSymlinks) { try { resolved = new URL(specifier); } catch (cause) { - if (isRemote && !BuiltinModule.canBeRequiredWithoutScheme(specifier)) { + if (isData && !BuiltinModule.canBeRequiredWithoutScheme(specifier)) { const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base); setOwnProperty(error, 'cause', cause); throw error; @@ -976,57 +969,6 @@ function resolveAsCommonJS(specifier, parentURL) { } } -/** - * Throw an error if an import is not allowed. - * TODO(@JakobJingleheimer): de-dupe `specifier` & `parsed` - * @param {string} specifier - The import specifier. - * @param {URL} parsed - The parsed URL of the import specifier. - * @param {URL} parsedParentURL - The parsed URL of the parent module. - * @throws {ERR_NETWORK_IMPORT_DISALLOWED} - If the import is disallowed. - */ -function checkIfDisallowedImport(specifier, parsed, parsedParentURL) { - if (parsedParentURL) { - // Avoid accessing the `protocol` property due to the lazy getters. - const parentProtocol = parsedParentURL.protocol; - if ( - parentProtocol === 'http:' || - parentProtocol === 'https:' - ) { - if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) { - // Avoid accessing the `protocol` property due to the lazy getters. - const parsedProtocol = parsed?.protocol; - // data: and blob: disallowed due to allowing file: access via - // indirection - if (parsedProtocol && - parsedProtocol !== 'https:' && - parsedProtocol !== 'http:' - ) { - throw new ERR_NETWORK_IMPORT_DISALLOWED( - specifier, - parsedParentURL, - 'remote imports cannot import from a local location.', - ); - } - - return { url: parsed.href }; - } - if (BuiltinModule.canBeRequiredWithoutScheme(specifier)) { - throw new ERR_NETWORK_IMPORT_DISALLOWED( - specifier, - parsedParentURL, - 'remote imports cannot import from a local location.', - ); - } - - throw new ERR_NETWORK_IMPORT_DISALLOWED( - specifier, - parsedParentURL, - 'only relative and absolute specifiers are supported.', - ); - } - } -} - /** * Validate user-input in `context` supplied by a custom loader. * @param {string | URL | undefined} parentURL - The parent URL. @@ -1068,38 +1010,11 @@ function defaultResolve(specifier, context = {}) { // Avoid accessing the `protocol` property due to the lazy getters. protocol = parsed.protocol; - if (protocol === 'data:' && - parsedParentURL.protocol !== 'file:' && - experimentalNetworkImports) { - throw new ERR_NETWORK_IMPORT_DISALLOWED( - specifier, - parsedParentURL, - 'import data: from a non file: is not allowed', - ); - } - if (protocol === 'data:' || - (experimentalNetworkImports && - ( - protocol === 'https:' || - protocol === 'http:' - ) - ) - ) { + if (protocol === 'data:') { return { __proto__: null, url: parsed.href }; } } - // There are multiple deep branches that can either throw or return; instead - // of duplicating that deeply nested logic for the possible returns, DRY and - // check for a return. This seems the least gnarly. - const maybeReturn = checkIfDisallowedImport( - specifier, - parsed, - parsedParentURL, - ); - - if (maybeReturn) { return maybeReturn; } - // This must come after checkIfDisallowedImport protocol ??= parsed?.protocol; if (protocol === 'node:') { return { __proto__: null, url: specifier }; } diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js index 973e8853cc099d..d931d72f5ec1e0 100644 --- a/lib/internal/modules/esm/translators.js +++ b/lib/internal/modules/esm/translators.js @@ -3,6 +3,7 @@ const { ArrayPrototypeMap, Boolean, + FunctionPrototypeCall, JSONParse, ObjectKeys, ObjectPrototypeHasOwnProperty, @@ -37,6 +38,7 @@ const { readFileSync } = require('fs'); const { dirname, extname, isAbsolute } = require('path'); const { loadBuiltinModule, + tsParse, stripBOM, urlToFilename, } = require('internal/modules/helpers'); @@ -302,6 +304,15 @@ translators.set('require-commonjs', (url, source, isMain) => { return createCJSModuleWrap(url, source); }); +// Handle CommonJS modules referenced by `require` calls. +// This translator function must be sync, as `require` is sync. +translators.set('require-commonjs-typescript', (url, source, isMain) => { + emitExperimentalWarning('Type Stripping'); + assert(cjsParse); + const code = tsParse(stringify(source)); + return createCJSModuleWrap(url, code); +}); + // Handle CommonJS modules referenced by `import` statements or expressions, // or as the initial entry point when the ESM loader handles a CommonJS entry. translators.set('commonjs', async function commonjsStrategy(url, source, @@ -510,3 +521,21 @@ translators.set('wasm', async function(url, source) { } }).module; }); + +// Strategy for loading a commonjs TypeScript module +translators.set('commonjs-typescript', function(url, source) { + emitExperimentalWarning('Type Stripping'); + assertBufferSource(source, false, 'load'); + const code = tsParse(stringify(source)); + debug(`Translating TypeScript ${url}`); + return FunctionPrototypeCall(translators.get('commonjs'), this, url, code, false); +}); + +// Strategy for loading an esm TypeScript module +translators.set('module-typescript', function(url, source) { + emitExperimentalWarning('Type Stripping'); + assertBufferSource(source, false, 'load'); + const code = tsParse(stringify(source)); + debug(`Translating TypeScript ${url}`); + return FunctionPrototypeCall(translators.get('module'), this, url, code, false); +}); diff --git a/lib/internal/modules/helpers.js b/lib/internal/modules/helpers.js index c9742f7f2317dc..36de471a66a02e 100644 --- a/lib/internal/modules/helpers.js +++ b/lib/internal/modules/helpers.js @@ -2,6 +2,7 @@ const { ArrayPrototypeForEach, + ArrayPrototypeIncludes, ObjectDefineProperty, ObjectPrototypeHasOwnProperty, SafeMap, @@ -9,6 +10,7 @@ const { StringPrototypeCharCodeAt, StringPrototypeIncludes, StringPrototypeSlice, + StringPrototypeSplit, StringPrototypeStartsWith, } = primordials; const { @@ -298,14 +300,42 @@ function getBuiltinModule(id) { return normalizedId ? require(normalizedId) : undefined; } +let parseTS; + +function lazyLoadTSParser() { + parseTS ??= require('internal/deps/amaro/dist/index').transformSync; + return parseTS; +} + +/** + * Performs type-stripping to TypeScript source code. + * @param {string} source TypeScript code to parse. + * @returns {string} JavaScript code. + */ +function tsParse(source) { + if (!source || typeof source !== 'string') { return ''; } + const transformSync = lazyLoadTSParser(); + const { code } = transformSync(source, { __proto__: null, mode: 'strip-only' }); + return code; +} + +function isUnderNodeModules(filename) { + const resolvedPath = path.resolve(filename); + const normalizedPath = path.normalize(resolvedPath); + const splitPath = StringPrototypeSplit(normalizedPath, path.sep); + return ArrayPrototypeIncludes(splitPath, 'node_modules'); +} + module.exports = { addBuiltinLibsToObject, getBuiltinModule, getCjsConditions, initializeCjsConditions, + isUnderNodeModules, loadBuiltinModule, makeRequireFunction, normalizeReferrerURL, + tsParse, stripBOM, toRealPath, hasStartedUserCJSExecution() { diff --git a/lib/internal/modules/run_main.js b/lib/internal/modules/run_main.js index 6c5601ed458b89..23953365d9f502 100644 --- a/lib/internal/modules/run_main.js +++ b/lib/internal/modules/run_main.js @@ -81,6 +81,14 @@ function shouldUseESMLoader(mainPath) { if (mainPath && StringPrototypeEndsWith(mainPath, '.mjs')) { return true; } if (!mainPath || StringPrototypeEndsWith(mainPath, '.cjs')) { return false; } + if (getOptionValue('--experimental-strip-types')) { + // This ensures that --experimental-default-type=commonjs and .mts files are treated as commonjs + if (getOptionValue('--experimental-default-type') === 'commonjs') { return false; } + if (!mainPath || StringPrototypeEndsWith(mainPath, '.cts')) { return false; } + // This will likely change in the future to start with commonjs loader by default + if (mainPath && StringPrototypeEndsWith(mainPath, '.mts')) { return true; } + } + const type = getNearestParentPackageJSONType(mainPath); // No package.json or no `type` field. diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js index 383dee4e6988e4..64e03d2130db7a 100644 --- a/lib/internal/process/pre_execution.js +++ b/lib/internal/process/pre_execution.js @@ -36,6 +36,7 @@ const { exposeLazyInterfaces, defineReplaceableLazyAttribute, setupCoverageHooks, + emitExperimentalWarning, } = require('internal/util'); const { @@ -106,6 +107,7 @@ function prepareExecution(options) { const mainEntry = patchProcessObject(expandArgv1); setupTraceCategoryState(); setupInspectorHooks(); + setupNetworkInspection(); setupNavigator(); setupWarningHandler(); setupUndici(); @@ -513,6 +515,16 @@ function setupInspectorHooks() { } } +function setupNetworkInspection() { + if (internalBinding('config').hasInspector && getOptionValue('--experimental-network-inspection')) { + const { + enable, + disable, + } = require('internal/inspector_network_tracking'); + internalBinding('inspector').setupNetworkTracking(enable, disable); + } +} + // In general deprecations are initialized wherever the APIs are implemented, // this is used to deprecate APIs implemented in C++ where the deprecation // utilities are not easily accessible. @@ -613,8 +625,7 @@ function initializePermission() { }; // Guarantee path module isn't monkey-patched to bypass permission model ObjectFreeze(require('path')); - process.emitWarning('Permission is an experimental feature', - 'ExperimentalWarning'); + emitExperimentalWarning('Permission'); const { has } = require('internal/process/permission'); const warnFlags = [ '--allow-addons', @@ -703,8 +714,7 @@ function initializeSourceMapsHandlers() { function initializeFrozenIntrinsics() { if (getOptionValue('--frozen-intrinsics')) { - process.emitWarning('The --frozen-intrinsics flag is experimental', - 'ExperimentalWarning'); + emitExperimentalWarning('Frozen intristics'); require('internal/freeze_intrinsics')(); } } diff --git a/lib/internal/source_map/prepare_stack_trace.js b/lib/internal/source_map/prepare_stack_trace.js index 1b12bb89f084ca..60c9d1ed3316ff 100644 --- a/lib/internal/source_map/prepare_stack_trace.js +++ b/lib/internal/source_map/prepare_stack_trace.js @@ -24,6 +24,8 @@ const { const { fileURLToPath } = require('internal/url'); const { setGetSourceMapErrorSource } = internalBinding('errors'); +const kStackLineAt = '\n at '; + // Create a prettified stacktrace, inserting context from source maps // if possible. function prepareStackTraceWithSourceMaps(error, trace) { @@ -40,14 +42,13 @@ function prepareStackTraceWithSourceMaps(error, trace) { let lastSourceMap; let lastFileName; - const preparedTrace = ArrayPrototypeJoin(ArrayPrototypeMap(trace, (t, i) => { - const str = '\n at '; + const preparedTrace = ArrayPrototypeJoin(ArrayPrototypeMap(trace, (callSite, i) => { try { // A stack trace will often have several call sites in a row within the // same file, cache the source map and file content accordingly: - let fileName = t.getFileName(); + let fileName = callSite.getFileName(); if (fileName === undefined) { - fileName = t.getEvalOrigin(); + fileName = callSite.getEvalOrigin(); } const sm = fileName === lastFileName ? lastSourceMap : @@ -55,60 +56,84 @@ function prepareStackTraceWithSourceMaps(error, trace) { lastSourceMap = sm; lastFileName = fileName; if (sm) { - // Source Map V3 lines/columns start at 0/0 whereas stack traces - // start at 1/1: - const { - originalLine, - originalColumn, - originalSource, - } = sm.findEntry(t.getLineNumber() - 1, t.getColumnNumber() - 1); - if (originalSource && originalLine !== undefined && - originalColumn !== undefined) { - const name = getOriginalSymbolName(sm, trace, i); - // Construct call site name based on: v8.dev/docs/stack-trace-api: - const fnName = t.getFunctionName() ?? t.getMethodName(); - const typeName = t.getTypeName(); - const namePrefix = typeName !== null && typeName !== 'global' ? `${typeName}.` : ''; - const originalName = `${namePrefix}${fnName || ''}`; - // The original call site may have a different symbol name - // associated with it, use it: - const prefix = (name && name !== originalName) ? - `${name}` : - `${originalName}`; - const hasName = !!(name || originalName); - const originalSourceNoScheme = - StringPrototypeStartsWith(originalSource, 'file://') ? - fileURLToPath(originalSource) : originalSource; - // Replace the transpiled call site with the original: - return `${str}${prefix}${hasName ? ' (' : ''}` + - `${originalSourceNoScheme}:${originalLine + 1}:` + - `${originalColumn + 1}${hasName ? ')' : ''}`; - } + return `${kStackLineAt}${serializeJSStackFrame(sm, callSite, trace[i + 1])}`; } } catch (err) { debug(err); } - return `${str}${t}`; + return `${kStackLineAt}${callSite}`; }), ''); return `${errorString}${preparedTrace}`; } +/** + * Serialize a single call site in the stack trace. + * Refer to SerializeJSStackFrame in deps/v8/src/objects/call-site-info.cc for + * more details about the default ToString(CallSite). + * The CallSite API is documented at https://v8.dev/docs/stack-trace-api. + * @param {import('internal/source_map/source_map').SourceMap} sm + * @param {CallSite} callSite - the CallSite object to be serialized + * @param {CallSite} callerCallSite - caller site info + * @returns {string} - the serialized call site + */ +function serializeJSStackFrame(sm, callSite, callerCallSite) { + // Source Map V3 lines/columns start at 0/0 whereas stack traces + // start at 1/1: + const { + originalLine, + originalColumn, + originalSource, + } = sm.findEntry(callSite.getLineNumber() - 1, callSite.getColumnNumber() - 1); + if (originalSource === undefined || originalLine === undefined || + originalColumn === undefined) { + return `${callSite}`; + } + const name = getOriginalSymbolName(sm, callSite, callerCallSite); + const originalSourceNoScheme = + StringPrototypeStartsWith(originalSource, 'file://') ? + fileURLToPath(originalSource) : originalSource; + // Construct call site name based on: v8.dev/docs/stack-trace-api: + const fnName = callSite.getFunctionName() ?? callSite.getMethodName(); + + let prefix = ''; + if (callSite.isAsync()) { + // Promise aggregation operation frame has no locations. This must be an + // async stack frame. + prefix = 'async '; + } else if (callSite.isConstructor()) { + prefix = 'new '; + } + + const typeName = callSite.getTypeName(); + const namePrefix = typeName !== null && typeName !== 'global' ? `${typeName}.` : ''; + const originalName = `${namePrefix}${fnName || ''}`; + // The original call site may have a different symbol name + // associated with it, use it: + const mappedName = (name && name !== originalName) ? + `${name}` : + `${originalName}`; + const hasName = !!(name || originalName); + // Replace the transpiled call site with the original: + return `${prefix}${mappedName}${hasName ? ' (' : ''}` + + `${originalSourceNoScheme}:${originalLine + 1}:` + + `${originalColumn + 1}${hasName ? ')' : ''}`; +} + // Transpilers may have removed the original symbol name used in the stack // trace, if possible restore it from the names field of the source map: -function getOriginalSymbolName(sourceMap, trace, curIndex) { +function getOriginalSymbolName(sourceMap, callSite, callerCallSite) { // First check for a symbol name associated with the enclosing function: const enclosingEntry = sourceMap.findEntry( - trace[curIndex].getEnclosingLineNumber() - 1, - trace[curIndex].getEnclosingColumnNumber() - 1, + callSite.getEnclosingLineNumber() - 1, + callSite.getEnclosingColumnNumber() - 1, ); if (enclosingEntry.name) return enclosingEntry.name; - // Fallback to using the symbol name attached to the next stack frame: - const currentFileName = trace[curIndex].getFileName(); - const nextCallSite = trace[curIndex + 1]; - if (nextCallSite && currentFileName === nextCallSite.getFileName()) { + // Fallback to using the symbol name attached to the caller site: + const currentFileName = callSite.getFileName(); + if (callerCallSite && currentFileName === callerCallSite.getFileName()) { const { name } = sourceMap.findEntry( - nextCallSite.getLineNumber() - 1, - nextCallSite.getColumnNumber() - 1, + callerCallSite.getLineNumber() - 1, + callerCallSite.getColumnNumber() - 1, ); return name; } diff --git a/lib/internal/streams/duplexpair.js b/lib/internal/streams/duplexpair.js new file mode 100644 index 00000000000000..a32084c4d4cbdf --- /dev/null +++ b/lib/internal/streams/duplexpair.js @@ -0,0 +1,62 @@ +'use strict'; +const { + Symbol, +} = primordials; + +const { Duplex } = require('stream'); +const assert = require('internal/assert'); + +const kCallback = Symbol('Callback'); +const kInitOtherSide = Symbol('InitOtherSide'); + +class DuplexSide extends Duplex { + #otherSide = null; + + constructor(options) { + super(options); + this[kCallback] = null; + this.#otherSide = null; + } + + [kInitOtherSide](otherSide) { + // Ensure this can only be set once, to enforce encapsulation. + if (this.#otherSide === null) { + this.#otherSide = otherSide; + } else { + assert(this.#otherSide === null); + } + } + + _read() { + const callback = this[kCallback]; + if (callback) { + this[kCallback] = null; + callback(); + } + } + + _write(chunk, encoding, callback) { + assert(this.#otherSide !== null); + assert(this.#otherSide[kCallback] === null); + if (chunk.length === 0) { + process.nextTick(callback); + } else { + this.#otherSide.push(chunk); + this.#otherSide[kCallback] = callback; + } + } + + _final(callback) { + this.#otherSide.on('end', callback); + this.#otherSide.push(null); + } +} + +function duplexPair(options) { + const side0 = new DuplexSide(options); + const side1 = new DuplexSide(options); + side0[kInitOtherSide](side1); + side1[kInitOtherSide](side0); + return [ side0, side1 ]; +} +module.exports = duplexPair; diff --git a/lib/internal/test_runner/coverage.js b/lib/internal/test_runner/coverage.js index 1ef13d89285cee..b97965235e7d47 100644 --- a/lib/internal/test_runner/coverage.js +++ b/lib/internal/test_runner/coverage.js @@ -25,7 +25,6 @@ const { readFileSync, } = require('fs'); const { setupCoverageHooks } = require('internal/util'); -const { getOptionValue } = require('internal/options'); const { tmpdir } = require('os'); const { join, resolve, relative, matchesGlob } = require('path'); const { fileURLToPath } = require('internal/url'); @@ -35,8 +34,6 @@ const kIgnoreRegex = /\/\* node:coverage ignore next (?\d+ )?\*\//; const kLineEndingRegex = /\r?\n$/u; const kLineSplitRegex = /(?<=\r?\n)/u; const kStatusRegex = /\/\* node:coverage (?enable|disable) \*\//; -const excludeFileGlobs = getOptionValue('--test-coverage-exclude'); -const includeFileGlobs = getOptionValue('--test-coverage-include'); class CoverageLine { constructor(line, startOffset, src, length = src?.length) { @@ -53,10 +50,12 @@ class CoverageLine { } class TestCoverage { - constructor(coverageDirectory, originalCoverageDirectory, workingDirectory) { + constructor(coverageDirectory, originalCoverageDirectory, workingDirectory, excludeGlobs, includeGlobs) { this.coverageDirectory = coverageDirectory; this.originalCoverageDirectory = originalCoverageDirectory; this.workingDirectory = workingDirectory; + this.excludeGlobs = excludeGlobs; + this.includeGlobs = includeGlobs; } #sourceLines = new SafeMap(); @@ -311,7 +310,7 @@ class TestCoverage { const coverageFile = join(this.coverageDirectory, entry.name); const coverage = JSONParse(readFileSync(coverageFile, 'utf8')); - mergeCoverage(result, this.mapCoverageWithSourceMap(coverage), this.workingDirectory); + this.mergeCoverage(result, this.mapCoverageWithSourceMap(coverage)); } return ArrayFrom(result.values()); @@ -334,7 +333,7 @@ class TestCoverage { const script = result[i]; const { url, functions } = script; - if (shouldSkipFileCoverage(url, this.workingDirectory) || sourceMapCache[url] == null) { + if (this.shouldSkipFileCoverage(url) || sourceMapCache[url] == null) { newResult.set(url, script); continue; } @@ -410,6 +409,54 @@ class TestCoverage { return MathMin(lines[line].startOffset + entry.originalColumn, lines[line].endOffset); } + mergeCoverage(merged, coverage) { + for (let i = 0; i < coverage.length; ++i) { + const newScript = coverage[i]; + const { url } = newScript; + + if (this.shouldSkipFileCoverage(url)) { + continue; + } + + const oldScript = merged.get(url); + + if (oldScript === undefined) { + merged.set(url, newScript); + } else { + mergeCoverageScripts(oldScript, newScript); + } + } + } + + shouldSkipFileCoverage(url) { + // This check filters out core modules, which start with 'node:' in + // coverage reports, as well as any invalid coverages which have been + // observed on Windows. + if (!StringPrototypeStartsWith(url, 'file:')) return true; + + const absolutePath = fileURLToPath(url); + const relativePath = relative(this.workingDirectory, absolutePath); + + // This check filters out files that match the exclude globs. + if (this.excludeGlobs?.length > 0) { + for (let i = 0; i < this.excludeGlobs.length; ++i) { + if (matchesGlob(relativePath, this.excludeGlobs[i]) || + matchesGlob(absolutePath, this.excludeGlobs[i])) return true; + } + } + + // This check filters out files that do not match the include globs. + if (this.includeGlobs?.length > 0) { + for (let i = 0; i < this.includeGlobs.length; ++i) { + if (matchesGlob(relativePath, this.includeGlobs[i]) || + matchesGlob(absolutePath, this.includeGlobs[i])) return false; + } + return true; + } + + // This check filters out the node_modules/ directory, unless it is explicitly included. + return StringPrototypeIncludes(url, '/node_modules/'); + } } function toPercentage(covered, total) { @@ -420,7 +467,7 @@ function sortCoverageFiles(a, b) { return StringPrototypeLocaleCompare(a.path, b.path); } -function setupCoverage() { +function setupCoverage(options) { let originalCoverageDirectory = process.env.NODE_V8_COVERAGE; const cwd = process.cwd(); @@ -444,7 +491,13 @@ function setupCoverage() { // child processes. process.env.NODE_V8_COVERAGE = coverageDirectory; - return new TestCoverage(coverageDirectory, originalCoverageDirectory, cwd); + return new TestCoverage( + coverageDirectory, + originalCoverageDirectory, + cwd, + options.coverageExcludeGlobs, + options.coverageIncludeGlobs, + ); } function mapRangeToLines(range, lines) { @@ -488,55 +541,6 @@ function mapRangeToLines(range, lines) { return { __proto__: null, lines: mappedLines, ignoredLines }; } -function shouldSkipFileCoverage(url, workingDirectory) { - // This check filters out core modules, which start with 'node:' in - // coverage reports, as well as any invalid coverages which have been - // observed on Windows. - if (!StringPrototypeStartsWith(url, 'file:')) return true; - - const absolutePath = fileURLToPath(url); - const relativePath = relative(workingDirectory, absolutePath); - - // This check filters out files that match the exclude globs. - if (excludeFileGlobs?.length > 0) { - for (let i = 0; i < excludeFileGlobs.length; ++i) { - if (matchesGlob(relativePath, excludeFileGlobs[i]) || - matchesGlob(absolutePath, excludeFileGlobs[i])) return true; - } - } - - // This check filters out files that do not match the include globs. - if (includeFileGlobs?.length > 0) { - for (let i = 0; i < includeFileGlobs.length; ++i) { - if (matchesGlob(relativePath, includeFileGlobs[i]) || - matchesGlob(absolutePath, includeFileGlobs[i])) return false; - } - return true; - } - - // This check filters out the node_modules/ directory, unless it is explicitly included. - return StringPrototypeIncludes(url, '/node_modules/'); -} - -function mergeCoverage(merged, coverage, workingDirectory) { - for (let i = 0; i < coverage.length; ++i) { - const newScript = coverage[i]; - const { url } = newScript; - - if (shouldSkipFileCoverage(url, workingDirectory)) { - continue; - } - - const oldScript = merged.get(url); - - if (oldScript === undefined) { - merged.set(url, newScript); - } else { - mergeCoverageScripts(oldScript, newScript); - } - } -} - function mergeCoverageScripts(oldScript, newScript) { // Merge the functions from the new coverage into the functions from the // existing (merged) coverage. diff --git a/lib/internal/test_runner/harness.js b/lib/internal/test_runner/harness.js index 4dce0ed2332b1a..ac52307cc38be5 100644 --- a/lib/internal/test_runner/harness.js +++ b/lib/internal/test_runner/harness.js @@ -28,18 +28,20 @@ const { } = require('internal/test_runner/utils'); const { queueMicrotask } = require('internal/process/task_queues'); const { bigint: hrtime } = process.hrtime; - +const resolvedPromise = PromiseResolve(); const testResources = new SafeMap(); +let globalRoot; testResources.set(reporterScope.asyncId(), reporterScope); function createTestTree(options = kEmptyObject) { - return setup(new Test({ __proto__: null, ...options, name: '' })); + globalRoot = setup(new Test({ __proto__: null, ...options, name: '' })); + return globalRoot; } function createProcessEventHandler(eventName, rootTest) { return (err) => { - if (!rootTest.harness.bootstrapComplete) { + if (rootTest.harness.bootstrapPromise) { // Something went wrong during the asynchronous portion of bootstrapping // the test runner. Since the test runner is not setup properly, we can't // do anything but throw the error. @@ -95,7 +97,7 @@ function configureCoverage(rootTest, globalOptions) { const { setupCoverage } = require('internal/test_runner/coverage'); try { - return setupCoverage(); + return setupCoverage(globalOptions); } catch (err) { const msg = `Warning: Code coverage could not be enabled. ${err}`; @@ -170,8 +172,13 @@ function setup(root) { kCancelledByParent)); hook.disable(); - process.removeListener('unhandledRejection', rejectionHandler); process.removeListener('uncaughtException', exceptionHandler); + process.removeListener('unhandledRejection', rejectionHandler); + process.removeListener('beforeExit', exitHandler); + if (globalOptions.isTestRunner) { + process.removeListener('SIGINT', terminationHandler); + process.removeListener('SIGTERM', terminationHandler); + } }; const terminationHandler = () => { @@ -191,7 +198,7 @@ function setup(root) { root.harness = { __proto__: null, allowTestsToRun: false, - bootstrapComplete: false, + bootstrapPromise: resolvedPromise, watching: false, coverage: FunctionPrototypeBind(collectCoverage, null, root, coverage), resetCounters() { @@ -208,7 +215,7 @@ function setup(root) { }; }, counters: null, - shouldColorizeTestFiles: false, + shouldColorizeTestFiles: shouldColorizeTestFiles(globalOptions.destinations), teardown: exitHandler, snapshotManager: null, }; @@ -217,35 +224,29 @@ function setup(root) { return root; } -let globalRoot; -let reportersSetup; -function getGlobalRoot() { +function lazyBootstrapRoot() { if (!globalRoot) { - globalRoot = createTestTree(); + // This is where the test runner is bootstrapped when node:test is used + // without the --test flag or the run() API. + createTestTree({ __proto__: null, entryFile: process.argv?.[1] }); globalRoot.reporter.on('test:fail', (data) => { if (data.todo === undefined || data.todo === false) { process.exitCode = kGenericUserError; } }); - reportersSetup = setupTestReporters(globalRoot.reporter); - globalRoot.harness.shouldColorizeTestFiles ||= shouldColorizeTestFiles(globalRoot); + globalRoot.harness.bootstrapPromise = setupTestReporters(globalRoot.reporter); } return globalRoot; } -async function startSubtest(subtest) { - if (reportersSetup) { +async function startSubtestAfterBootstrap(subtest) { + if (subtest.root.harness.bootstrapPromise) { // Only incur the overhead of awaiting the Promise once. - await reportersSetup; - reportersSetup = undefined; - } - - const root = getGlobalRoot(); - if (!root.harness.bootstrapComplete) { - root.harness.bootstrapComplete = true; + await subtest.root.harness.bootstrapPromise; + subtest.root.harness.bootstrapPromise = null; queueMicrotask(() => { - root.harness.allowTestsToRun = true; - root.processPendingSubtests(); + subtest.root.harness.allowTestsToRun = true; + subtest.root.processPendingSubtests(); }); } @@ -254,12 +255,13 @@ async function startSubtest(subtest) { function runInParentContext(Factory) { function run(name, options, fn, overrides) { - const parent = testResources.get(executionAsyncId()) || getGlobalRoot(); + const parent = testResources.get(executionAsyncId()) || lazyBootstrapRoot(); const subtest = parent.createSubtest(Factory, name, options, fn, overrides); - if (!(parent instanceof Suite)) { - return startSubtest(subtest); + if (parent instanceof Suite) { + return PromiseResolve(); } - return PromiseResolve(); + + return startSubtestAfterBootstrap(subtest); } const test = (name, options, fn) => { @@ -286,7 +288,7 @@ function runInParentContext(Factory) { function hook(hook) { return (fn, options) => { - const parent = testResources.get(executionAsyncId()) || getGlobalRoot(); + const parent = testResources.get(executionAsyncId()) || lazyBootstrapRoot(); parent.createHook(hook, fn, { __proto__: null, ...options, diff --git a/lib/internal/test_runner/mock/mock_timers.js b/lib/internal/test_runner/mock/mock_timers.js index 35c9a1ab68aac8..bacfbf41a207d6 100644 --- a/lib/internal/test_runner/mock/mock_timers.js +++ b/lib/internal/test_runner/mock/mock_timers.js @@ -304,7 +304,7 @@ class MockTimers { } #clearTimer(timer) { - if (timer.priorityQueuePosition !== undefined) { + if (timer?.priorityQueuePosition !== undefined) { this.#executionQueue.removeAt(timer.priorityQueuePosition); timer.priorityQueuePosition = undefined; } diff --git a/lib/internal/test_runner/reporter/dot.js b/lib/internal/test_runner/reporter/dot.js index e9ba0b8dc7bd11..1e581f7a337845 100644 --- a/lib/internal/test_runner/reporter/dot.js +++ b/lib/internal/test_runner/reporter/dot.js @@ -12,10 +12,10 @@ module.exports = async function* dot(source) { const failedTests = []; for await (const { type, data } of source) { if (type === 'test:pass') { - yield '.'; + yield `${colors.green}.${colors.clear}`; } if (type === 'test:fail') { - yield 'X'; + yield `${colors.red}X${colors.clear}`; ArrayPrototypePush(failedTests, data); } if ((type === 'test:fail' || type === 'test:pass') && ++count === columns) { diff --git a/lib/internal/test_runner/runner.js b/lib/internal/test_runner/runner.js index 6fd1cb72f3b508..a14cc97ce8690c 100644 --- a/lib/internal/test_runner/runner.js +++ b/lib/internal/test_runner/runner.js @@ -1,4 +1,5 @@ 'use strict'; + const { ArrayIsArray, ArrayPrototypeEvery, @@ -10,7 +11,6 @@ const { ArrayPrototypeMap, ArrayPrototypePush, ArrayPrototypeShift, - ArrayPrototypeSlice, ArrayPrototypeSome, ArrayPrototypeSort, ObjectAssign, @@ -32,8 +32,7 @@ const { spawn } = require('child_process'); const { finished } = require('internal/streams/end-of-stream'); const { resolve } = require('path'); const { DefaultDeserializer, DefaultSerializer } = require('v8'); -// TODO(aduh95): switch to internal/readline/interface when backporting to Node.js 16.x is no longer a concern. -const { createInterface } = require('readline'); +const { Interface } = require('internal/readline/interface'); const { deserializeError } = require('internal/error_serdes'); const { Buffer } = require('buffer'); const { FilesWatcher } = require('internal/watch_mode/files_watcher'); @@ -70,7 +69,6 @@ const { convertStringToRegExp, countCompletedTest, kDefaultPattern, - shouldColorizeTestFiles, } = require('internal/test_runner/utils'); const { Glob } = require('internal/fs/glob'); const { once } = require('events'); @@ -88,10 +86,12 @@ const kCanceledTests = new SafeSet() let kResistStopPropagation; -function createTestFileList() { +function createTestFileList(patterns) { const cwd = process.cwd(); - const hasUserSuppliedPattern = process.argv.length > 1; - const patterns = hasUserSuppliedPattern ? ArrayPrototypeSlice(process.argv, 1) : [kDefaultPattern]; + const hasUserSuppliedPattern = patterns != null; + if (!patterns || patterns.length === 0) { + patterns = [kDefaultPattern]; + } const glob = new Glob(patterns, { __proto__: null, cwd, @@ -345,7 +345,6 @@ function runTestFile(path, filesWatcher, opts) { let err; - child.on('error', (error) => { err = error; }); @@ -354,7 +353,7 @@ function runTestFile(path, filesWatcher, opts) { subtest.parseMessage(data); }); - const rl = createInterface({ __proto__: null, input: child.stderr }); + const rl = new Interface({ __proto__: null, input: child.stderr }); rl.on('line', (line) => { if (isInspectorMessage(line)) { process.stderr.write(line + '\n'); @@ -419,8 +418,8 @@ function watchFiles(testFiles, opts) { opts.root.harness.watching = true; watcher.on('changed', ({ owners, eventType }) => { - if (eventType === 'rename') { - const updatedTestFiles = createTestFileList(); + if (!opts.hasFiles && eventType === 'rename') { + const updatedTestFiles = createTestFileList(opts.globPatterns); const newFileName = ArrayPrototypeFind(updatedTestFiles, (x) => !ArrayPrototypeIncludes(testFiles, x)); const previousFileName = ArrayPrototypeFind(testFiles, (x) => !ArrayPrototypeIncludes(updatedTestFiles, x)); @@ -483,6 +482,7 @@ function run(options = kEmptyObject) { watch, setup, only, + globPatterns, } = options; if (files != null) { @@ -503,6 +503,16 @@ function run(options = kEmptyObject) { if (only != null) { validateBoolean(only, 'options.only'); } + if (globPatterns != null) { + validateArray(globPatterns, 'options.globPatterns'); + } + + if (globPatterns?.length > 0 && files?.length > 0) { + throw new ERR_INVALID_ARG_VALUE( + 'options.globPatterns', globPatterns, 'is not supported when specifying \'options.files\'', + ); + } + if (shard != null) { validateObject(shard, 'options.shard'); // Avoid re-evaluating the shard object in case it's a getter @@ -552,20 +562,20 @@ function run(options = kEmptyObject) { } const root = createTestTree({ __proto__: null, concurrency, timeout, signal }); - root.harness.shouldColorizeTestFiles ||= shouldColorizeTestFiles(root); if (process.env.NODE_TEST_CONTEXT !== undefined) { process.emitWarning('node:test run() is being called recursively within a test file. skipping running files.'); root.postRun(); return root.reporter; } - let testFiles = files ?? createTestFileList(); + let testFiles = files ?? createTestFileList(globPatterns); if (shard) { testFiles = ArrayPrototypeFilter(testFiles, (_, index) => index % shard.total === shard.index - 1); } let postRun = () => root.postRun(); + let teardown = () => root.harness.teardown(); let filesWatcher; const opts = { __proto__: null, @@ -574,15 +584,18 @@ function run(options = kEmptyObject) { inspectPort, testNamePatterns, testSkipPatterns, + hasFiles: files != null, + globPatterns, only, forceExit, }; if (watch) { filesWatcher = watchFiles(testFiles, opts); postRun = undefined; + teardown = undefined; } const runFiles = () => { - root.harness.bootstrapComplete = true; + root.harness.bootstrapPromise = null; root.harness.allowTestsToRun = true; return SafePromiseAllSettledReturnVoid(testFiles, (path) => { const subtest = runTestFile(path, filesWatcher, opts); @@ -591,7 +604,8 @@ function run(options = kEmptyObject) { }); }; - PromisePrototypeThen(PromisePrototypeThen(PromiseResolve(setup?.(root.reporter)), runFiles), postRun); + const setupPromise = PromiseResolve(setup?.(root.reporter)); + PromisePrototypeThen(PromisePrototypeThen(PromisePrototypeThen(setupPromise, runFiles), postRun), teardown); return root.reporter; } diff --git a/lib/internal/test_runner/snapshot.js b/lib/internal/test_runner/snapshot.js index a2ab85239d7299..7e41a0bf76f0cd 100644 --- a/lib/internal/test_runner/snapshot.js +++ b/lib/internal/test_runner/snapshot.js @@ -58,50 +58,12 @@ function setDefaultSnapshotSerializers(serializers) { serializerFns = ArrayPrototypeSlice(serializers); } -class SnapshotManager { - constructor(entryFile, updateSnapshots) { - this.entryFile = entryFile; - this.snapshotFile = undefined; +class SnapshotFile { + constructor(snapshotFile) { + this.snapshotFile = snapshotFile; this.snapshots = { __proto__: null }; this.nameCounts = new SafeMap(); - // A manager instance will only read or write snapshot files based on the - // updateSnapshots argument. - this.loaded = updateSnapshots; - this.updateSnapshots = updateSnapshots; - } - - resolveSnapshotFile() { - if (this.snapshotFile === undefined) { - const resolved = resolveSnapshotPathFn(this.entryFile); - - if (typeof resolved !== 'string') { - const err = new ERR_INVALID_STATE('Invalid snapshot filename.'); - err.filename = resolved; - throw err; - } - - this.snapshotFile = resolved; - } - } - - serialize(input, serializers = serializerFns) { - try { - let value = input; - - for (let i = 0; i < serializers.length; ++i) { - const fn = serializers[i]; - value = fn(value); - } - - return `\n${templateEscape(value)}\n`; - } catch (err) { - const error = new ERR_INVALID_STATE( - 'The provided serializers did not generate a string.', - ); - error.input = input; - error.cause = err; - throw error; - } + this.loaded = false; } getSnapshot(id) { @@ -122,12 +84,11 @@ class SnapshotManager { nextId(name) { const count = this.nameCounts.get(name) ?? 1; - this.nameCounts.set(name, count + 1); return `${name} ${count}`; } - readSnapshotFile() { + readFile() { if (this.loaded) { debug('skipping read of snapshot file'); return; @@ -164,12 +125,7 @@ class SnapshotManager { } } - writeSnapshotFile() { - if (!this.updateSnapshots) { - debug('skipping write of snapshot file'); - return; - } - + writeFile() { try { const keys = ArrayPrototypeSort(ObjectKeys(this.snapshots)); const snapshotStrings = ArrayPrototypeMap(keys, (key) => { @@ -186,34 +142,87 @@ class SnapshotManager { throw error; } } +} + +class SnapshotManager { + constructor(updateSnapshots) { + // A manager instance will only read or write snapshot files based on the + // updateSnapshots argument. + this.updateSnapshots = updateSnapshots; + this.cache = new SafeMap(); + } + + resolveSnapshotFile(entryFile) { + let snapshotFile = this.cache.get(entryFile); + + if (snapshotFile === undefined) { + const resolved = resolveSnapshotPathFn(entryFile); + + if (typeof resolved !== 'string') { + const err = new ERR_INVALID_STATE('Invalid snapshot filename.'); + err.filename = resolved; + throw err; + } + + snapshotFile = new SnapshotFile(resolved); + snapshotFile.loaded = this.updateSnapshots; + this.cache.set(entryFile, snapshotFile); + } + + return snapshotFile; + } + + serialize(input, serializers = serializerFns) { + try { + let value = input; + + for (let i = 0; i < serializers.length; ++i) { + const fn = serializers[i]; + value = fn(value); + } + + return `\n${templateEscape(value)}\n`; + } catch (err) { + const error = new ERR_INVALID_STATE( + 'The provided serializers did not generate a string.', + ); + error.input = input; + error.cause = err; + throw error; + } + } + + writeSnapshotFiles() { + if (!this.updateSnapshots) { + debug('skipping write of snapshot files'); + return; + } + + this.cache.forEach((snapshotFile) => { + snapshotFile.writeFile(); + }); + } createAssert() { const manager = this; return function snapshotAssertion(actual, options = kEmptyObject) { emitExperimentalWarning(kExperimentalWarning); - // Resolve the snapshot file here so that any resolution errors are - // surfaced as early as possible. - manager.resolveSnapshotFile(); - - const { fullName } = this; - const id = manager.nextId(fullName); - validateObject(options, 'options'); - const { serializers = serializerFns, } = options; - validateFunctionArray(serializers, 'options.serializers'); - + const { filePath, fullName } = this; + const snapshotFile = manager.resolveSnapshotFile(filePath); const value = manager.serialize(actual, serializers); + const id = snapshotFile.nextId(fullName); if (manager.updateSnapshots) { - manager.setSnapshot(id, value); + snapshotFile.setSnapshot(id, value); } else { - manager.readSnapshotFile(); - strictEqual(value, manager.getSnapshot(id)); + snapshotFile.readFile(); + strictEqual(value, snapshotFile.getSnapshot(id)); } }; } diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js index eacaf62bb34d11..1c461a07f16bfa 100644 --- a/lib/internal/test_runner/test.js +++ b/lib/internal/test_runner/test.js @@ -75,7 +75,6 @@ const kHookFailure = 'hookFailed'; const kDefaultTimeout = null; const noop = FunctionPrototype; const kShouldAbort = Symbol('kShouldAbort'); -const kFilename = process.argv?.[1]; const kHookNames = ObjectSeal(['before', 'after', 'beforeEach', 'afterEach']); const kUnwrapErrors = new SafeSet() .add(kTestCodeFailure).add(kHookFailure) @@ -133,7 +132,7 @@ function lazyAssertObject(harness) { const { getOptionValue } = require('internal/options'); if (getOptionValue('--experimental-test-snapshots')) { const { SnapshotManager } = require('internal/test_runner/snapshot'); - harness.snapshotManager = new SnapshotManager(kFilename, updateSnapshots); + harness.snapshotManager = new SnapshotManager(updateSnapshots); assertObj.set('snapshot', harness.snapshotManager.createAssert()); } } @@ -225,6 +224,10 @@ class TestContext { return this.#test.name; } + get filePath() { + return this.#test.entryFile; + } + get fullName() { return getFullName(this.#test); } @@ -343,6 +346,10 @@ class SuiteContext { return this.#suite.name; } + get filePath() { + return this.#suite.entryFile; + } + get fullName() { return getFullName(this.#suite); } @@ -357,7 +364,7 @@ class Test extends AsyncResource { super('Test'); let { fn, name, parent } = options; - const { concurrency, loc, only, timeout, todo, skip, signal, plan } = options; + const { concurrency, entryFile, loc, only, timeout, todo, skip, signal, plan } = options; if (typeof fn !== 'function') { fn = noop; @@ -386,6 +393,7 @@ class Test extends AsyncResource { this.runOnlySubtests = this.only; this.childNumber = 0; this.timeout = kDefaultTimeout; + this.entryFile = entryFile; this.root = this; this.hooks = { __proto__: null, @@ -406,6 +414,7 @@ class Test extends AsyncResource { this.runOnlySubtests = !this.only; this.childNumber = parent.subtests.length + 1; this.timeout = parent.timeout; + this.entryFile = parent.entryFile; this.root = parent.root; this.hooks = { __proto__: null, @@ -498,7 +507,7 @@ class Test extends AsyncResource { this.diagnostic(warning); } - if (loc === undefined || kFilename === undefined) { + if (loc === undefined) { this.loc = undefined; } else { this.loc = { @@ -967,7 +976,7 @@ class Test extends AsyncResource { // Call this harness.coverage() before collecting diagnostics, since failure to collect coverage is a diagnostic. const coverage = harness.coverage(); - harness.snapshotManager?.writeSnapshotFile(); + harness.snapshotManager?.writeSnapshotFiles(); for (let i = 0; i < diagnostics.length; i++) { reporter.diagnostic(nesting, loc, diagnostics[i]); } diff --git a/lib/internal/test_runner/utils.js b/lib/internal/test_runner/utils.js index b8576dbe6673b5..aae2a756800a0f 100644 --- a/lib/internal/test_runner/utils.js +++ b/lib/internal/test_runner/utils.js @@ -9,6 +9,7 @@ const { MathFloor, MathMax, MathMin, + NumberParseInt, NumberPrototypeToFixed, ObjectGetOwnPropertyDescriptor, RegExp, @@ -19,6 +20,7 @@ const { StringPrototypePadStart, StringPrototypeRepeat, StringPrototypeSlice, + StringPrototypeSplit, } = primordials; const { AsyncResource } = require('async_hooks'); @@ -129,10 +131,9 @@ function tryBuiltinReporter(name) { return require(builtinPath); } -function shouldColorizeTestFiles(rootTest) { +function shouldColorizeTestFiles(destinations) { // This function assumes only built-in destinations (stdout/stderr) supports coloring - const { reporters, destinations } = parseCommandLine(); - return ArrayPrototypeSome(reporters, (_, index) => { + return ArrayPrototypeSome(destinations, (_, index) => { const destination = kBuiltinDestinations.get(destinations[index]); return destination && shouldColorize(destination); }); @@ -196,13 +197,19 @@ function parseCommandLine() { const forceExit = getOptionValue('--test-force-exit'); const sourceMaps = getOptionValue('--enable-source-maps'); const updateSnapshots = getOptionValue('--test-update-snapshots'); + const watchMode = getOptionValue('--watch'); const isChildProcess = process.env.NODE_TEST_CONTEXT === 'child'; const isChildProcessV8 = process.env.NODE_TEST_CONTEXT === 'child-v8'; + let coverageExcludeGlobs; + let coverageIncludeGlobs; let destinations; + let perFileTimeout; let reporters; + let runnerConcurrency; let testNamePatterns; let testSkipPatterns; let testOnlyFlag; + let shard; if (isChildProcessV8) { kBuiltinReporters.set('v8-serializer', 'internal/test_runner/reporter/v8-serializer'); @@ -232,9 +239,31 @@ function parseCommandLine() { } if (isTestRunner) { + perFileTimeout = getOptionValue('--test-timeout') || Infinity; + runnerConcurrency = getOptionValue('--test-concurrency') || true; testOnlyFlag = false; testNamePatterns = null; + + const shardOption = getOptionValue('--test-shard'); + if (shardOption) { + if (!RegExpPrototypeExec(/^\d+\/\d+$/, shardOption)) { + throw new ERR_INVALID_ARG_VALUE( + '--test-shard', + shardOption, + 'must be in the form of /', + ); + } + + const indexAndTotal = StringPrototypeSplit(shardOption, '/'); + shard = { + __proto__: null, + index: NumberParseInt(indexAndTotal[0], 10), + total: NumberParseInt(indexAndTotal[1], 10), + }; + } } else { + perFileTimeout = Infinity; + runnerConcurrency = 1; const testNamePatternFlag = getOptionValue('--test-name-pattern'); testOnlyFlag = getOptionValue('--test-only'); testNamePatterns = testNamePatternFlag?.length > 0 ? @@ -247,11 +276,21 @@ function parseCommandLine() { ArrayPrototypeMap(testSkipPatternFlag, (re) => convertStringToRegExp(re, '--test-skip-pattern')) : null; } + if (coverage) { + coverageExcludeGlobs = getOptionValue('--test-coverage-exclude'); + coverageIncludeGlobs = getOptionValue('--test-coverage-include'); + } + globalTestOptions = { __proto__: null, isTestRunner, coverage, + coverageExcludeGlobs, + coverageIncludeGlobs, forceExit, + perFileTimeout, + runnerConcurrency, + shard, sourceMaps, testOnlyFlag, testNamePatterns, @@ -259,6 +298,7 @@ function parseCommandLine() { updateSnapshots, reporters, destinations, + watchMode, }; return globalTestOptions; diff --git a/lib/internal/util/debuglog.js b/lib/internal/util/debuglog.js index e4a283d9faa767..87d19dcc843170 100644 --- a/lib/internal/util/debuglog.js +++ b/lib/internal/util/debuglog.js @@ -20,7 +20,7 @@ const { CHAR_LOWERCASE_N: kTraceInstant, } = require('internal/constants'); const { inspect, format, formatWithOptions } = require('internal/util/inspect'); -const { isTraceCategoryEnabled, trace } = internalBinding('trace_events'); +const { getCategoryEnabledBuffer, trace } = internalBinding('trace_events'); // `debugImpls` and `testEnabled` are deliberately not initialized so any call // to `debuglog()` before `initializeDebugEnv()` is called will throw. @@ -372,18 +372,34 @@ function debugWithTimer(set, cb) { ); } - const kTraceCategory = `node,node.${StringPrototypeToLowerCase(set)}`; + const traceCategory = `node,node.${StringPrototypeToLowerCase(set)}`; + let traceCategoryBuffer; let debugLogCategoryEnabled = false; - let traceCategoryEnabled = false; let timerFlags = kNone; + const skipAll = kSkipLog | kSkipTrace; + + function ensureTimerFlagsAreUpdated() { + timerFlags &= ~kSkipTrace; + + if (traceCategoryBuffer[0] === 0) { + timerFlags |= kSkipTrace; + } + } + /** * @type {TimerStart} */ function internalStartTimer(logLabel, traceLabel) { + ensureTimerFlagsAreUpdated(); + + if (timerFlags === skipAll) { + return; + } + time( tracesStores[set], - kTraceCategory, + traceCategory, 'debuglog.time', timerFlags, logLabel, @@ -395,9 +411,15 @@ function debugWithTimer(set, cb) { * @type {TimerEnd} */ function internalEndTimer(logLabel, traceLabel) { + ensureTimerFlagsAreUpdated(); + + if (timerFlags === skipAll) { + return; + } + timeEnd( tracesStores[set], - kTraceCategory, + traceCategory, 'debuglog.timeEnd', timerFlags, logImpl, @@ -410,9 +432,15 @@ function debugWithTimer(set, cb) { * @type {TimerLog} */ function internalLogTimer(logLabel, traceLabel, args) { + ensureTimerFlagsAreUpdated(); + + if (timerFlags === skipAll) { + return; + } + timeLog( tracesStores[set], - kTraceCategory, + traceCategory, 'debuglog.timeLog', timerFlags, logImpl, @@ -428,21 +456,19 @@ function debugWithTimer(set, cb) { } emitWarningIfNeeded(set); debugLogCategoryEnabled = testEnabled(set); - traceCategoryEnabled = isTraceCategoryEnabled(kTraceCategory); + traceCategoryBuffer = getCategoryEnabledBuffer(traceCategory); + + timerFlags = kNone; if (!debugLogCategoryEnabled) { timerFlags |= kSkipLog; } - if (!traceCategoryEnabled) { + if (traceCategoryBuffer[0] === 0) { timerFlags |= kSkipTrace; } - // TODO(H4ad): support traceCategory being enabled dynamically - if (debugLogCategoryEnabled || traceCategoryEnabled) - cb(internalStartTimer, internalEndTimer, internalLogTimer); - else - cb(noop, noop, noop); + cb(internalStartTimer, internalEndTimer, internalLogTimer); } /** @@ -451,7 +477,7 @@ function debugWithTimer(set, cb) { const startTimer = (logLabel, traceLabel) => { init(); - if (debugLogCategoryEnabled || traceCategoryEnabled) + if (timerFlags !== skipAll) internalStartTimer(logLabel, traceLabel); }; @@ -461,7 +487,7 @@ function debugWithTimer(set, cb) { const endTimer = (logLabel, traceLabel) => { init(); - if (debugLogCategoryEnabled || traceCategoryEnabled) + if (timerFlags !== skipAll) internalEndTimer(logLabel, traceLabel); }; @@ -471,7 +497,7 @@ function debugWithTimer(set, cb) { const logTimer = (logLabel, traceLabel, args) => { init(); - if (debugLogCategoryEnabled || traceCategoryEnabled) + if (timerFlags !== skipAll) internalLogTimer(logLabel, traceLabel, args); }; diff --git a/lib/internal/webstorage.js b/lib/internal/webstorage.js index 1732d880b6bb86..7f58299a1e835f 100644 --- a/lib/internal/webstorage.js +++ b/lib/internal/webstorage.js @@ -6,7 +6,6 @@ const { ERR_INVALID_ARG_VALUE } = require('internal/errors').codes; const { getOptionValue } = require('internal/options'); const { emitExperimentalWarning } = require('internal/util'); const { kConstructorKey, Storage } = internalBinding('webstorage'); -const { resolve, toNamespacedPath } = require('path'); const { getValidatedPath } = require('internal/fs/utils'); const kInMemoryPath = ':memory:'; @@ -25,7 +24,7 @@ ObjectDefineProperties(module.exports, { enumerable: true, get() { if (lazyLocalStorage === undefined) { - let location = getOptionValue('--localstorage-file'); + const location = getOptionValue('--localstorage-file'); if (location === '') { throw new ERR_INVALID_ARG_VALUE('--localstorage-file', @@ -33,8 +32,7 @@ ObjectDefineProperties(module.exports, { 'is an invalid localStorage location'); } - location = toNamespacedPath(resolve(getValidatedPath(location))); - lazyLocalStorage = new Storage(kConstructorKey, location); + lazyLocalStorage = new Storage(kConstructorKey, getValidatedPath(location)); } return lazyLocalStorage; diff --git a/lib/stream.js b/lib/stream.js index a69354138a2248..420415a2259827 100644 --- a/lib/stream.js +++ b/lib/stream.js @@ -101,6 +101,7 @@ Stream.Writable = require('internal/streams/writable'); Stream.Duplex = require('internal/streams/duplex'); Stream.Transform = require('internal/streams/transform'); Stream.PassThrough = require('internal/streams/passthrough'); +Stream.duplexPair = require('internal/streams/duplexpair'); Stream.pipeline = pipeline; const { addAbortSignal } = require('internal/streams/add-abort-signal'); Stream.addAbortSignal = addAbortSignal; diff --git a/node.gyp b/node.gyp index acb5fffe7d780b..46baef1db3eace 100644 --- a/node.gyp +++ b/node.gyp @@ -56,6 +56,7 @@ 'deps/acorn/acorn/dist/acorn.js', 'deps/acorn/acorn-walk/dist/walk.js', 'deps/minimatch/index.js', + 'deps/amaro/dist/index.js', '<@(node_builtin_shareable_builtins)', ], 'node_sources': [ @@ -950,6 +951,9 @@ '<@(node_crypto_sources)', '<@(node_quic_sources)', ], + 'dependencies': [ + 'deps/ncrypto/ncrypto.gyp:ncrypto', + ], }], [ 'OS in "linux freebsd mac solaris" and ' 'target_arch=="x64" and ' @@ -1211,6 +1215,9 @@ 'defines': [ 'HAVE_OPENSSL=1', ], + 'dependencies': [ + 'deps/ncrypto/ncrypto.gyp:ncrypto', + ], 'sources': [ '<@(node_cctest_openssl_sources)' ], }], ['v8_enable_inspector==1', { @@ -1404,6 +1411,9 @@ 'defines': [ 'NODE_MKSNAPSHOT_USE_ARRAY_LITERALS=1' ], }], [ 'node_use_openssl=="true"', { + 'dependencies': [ + 'deps/ncrypto/ncrypto.gyp:ncrypto', + ], 'defines': [ 'HAVE_OPENSSL=1', ], diff --git a/src/amaro_version.h b/src/amaro_version.h new file mode 100644 index 00000000000000..81fc5136298d0c --- /dev/null +++ b/src/amaro_version.h @@ -0,0 +1,6 @@ +// This is an auto generated file, please do not edit. +// Refer to tools/dep_updaters/update-amaro.sh +#ifndef SRC_AMARO_VERSION_H_ +#define SRC_AMARO_VERSION_H_ +#define AMARO_VERSION "0.0.6" +#endif // SRC_AMARO_VERSION_H_ diff --git a/src/crypto/crypto_aes.cc b/src/crypto/crypto_aes.cc index 6ec43c0a461e78..774030d408711c 100644 --- a/src/crypto/crypto_aes.cc +++ b/src/crypto/crypto_aes.cc @@ -476,83 +476,38 @@ Maybe AESCipherTraits::AdditionalConfig( params->variant = static_cast(args[offset].As()->Value()); + AESCipherMode cipher_op_mode; int cipher_nid; +#define V(name, _, mode, nid) \ + case kKeyVariantAES_##name: { \ + cipher_op_mode = mode; \ + cipher_nid = nid; \ + break; \ + } switch (params->variant) { - case kKeyVariantAES_CTR_128: - if (!ValidateIV(env, mode, args[offset + 1], params) || - !ValidateCounter(env, args[offset + 2], params)) { - return Nothing(); - } - cipher_nid = NID_aes_128_ctr; - break; - case kKeyVariantAES_CTR_192: - if (!ValidateIV(env, mode, args[offset + 1], params) || - !ValidateCounter(env, args[offset + 2], params)) { - return Nothing(); - } - cipher_nid = NID_aes_192_ctr; - break; - case kKeyVariantAES_CTR_256: - if (!ValidateIV(env, mode, args[offset + 1], params) || - !ValidateCounter(env, args[offset + 2], params)) { - return Nothing(); - } - cipher_nid = NID_aes_256_ctr; - break; - case kKeyVariantAES_CBC_128: - if (!ValidateIV(env, mode, args[offset + 1], params)) - return Nothing(); - cipher_nid = NID_aes_128_cbc; - break; - case kKeyVariantAES_CBC_192: - if (!ValidateIV(env, mode, args[offset + 1], params)) - return Nothing(); - cipher_nid = NID_aes_192_cbc; - break; - case kKeyVariantAES_CBC_256: - if (!ValidateIV(env, mode, args[offset + 1], params)) - return Nothing(); - cipher_nid = NID_aes_256_cbc; - break; - case kKeyVariantAES_KW_128: - UseDefaultIV(params); - cipher_nid = NID_id_aes128_wrap; - break; - case kKeyVariantAES_KW_192: - UseDefaultIV(params); - cipher_nid = NID_id_aes192_wrap; - break; - case kKeyVariantAES_KW_256: - UseDefaultIV(params); - cipher_nid = NID_id_aes256_wrap; - break; - case kKeyVariantAES_GCM_128: - if (!ValidateIV(env, mode, args[offset + 1], params) || - !ValidateAuthTag(env, mode, cipher_mode, args[offset + 2], params) || - !ValidateAdditionalData(env, mode, args[offset + 3], params)) { - return Nothing(); - } - cipher_nid = NID_aes_128_gcm; - break; - case kKeyVariantAES_GCM_192: - if (!ValidateIV(env, mode, args[offset + 1], params) || - !ValidateAuthTag(env, mode, cipher_mode, args[offset + 2], params) || - !ValidateAdditionalData(env, mode, args[offset + 3], params)) { + VARIANTS(V) + default: + UNREACHABLE(); + } +#undef V + + if (cipher_op_mode != AESCipherMode::KW) { + if (!ValidateIV(env, mode, args[offset + 1], params)) { + return Nothing(); + } + if (cipher_op_mode == AESCipherMode::CTR) { + if (!ValidateCounter(env, args[offset + 2], params)) { return Nothing(); } - cipher_nid = NID_aes_192_gcm; - break; - case kKeyVariantAES_GCM_256: - if (!ValidateIV(env, mode, args[offset + 1], params) || - !ValidateAuthTag(env, mode, cipher_mode, args[offset + 2], params) || + } else if (cipher_op_mode == AESCipherMode::GCM) { + if (!ValidateAuthTag(env, mode, cipher_mode, args[offset + 2], params) || !ValidateAdditionalData(env, mode, args[offset + 3], params)) { return Nothing(); } - cipher_nid = NID_aes_256_gcm; - break; - default: - UNREACHABLE(); + } + } else { + UseDefaultIV(params); } params->cipher = EVP_get_cipherbynid(cipher_nid); @@ -577,8 +532,8 @@ WebCryptoCipherStatus AESCipherTraits::DoCipher( const AESCipherConfig& params, const ByteSource& in, ByteSource* out) { -#define V(name, fn) \ - case kKeyVariantAES_ ## name: \ +#define V(name, fn, _, __) \ + case kKeyVariantAES_##name: \ return fn(env, key_data.get(), cipher_mode, params, in, out); switch (params.variant) { VARIANTS(V) @@ -591,7 +546,7 @@ WebCryptoCipherStatus AESCipherTraits::DoCipher( void AES::Initialize(Environment* env, Local target) { AESCryptoJob::Initialize(env, target); -#define V(name, _) NODE_DEFINE_CONSTANT(target, kKeyVariantAES_ ## name); +#define V(name, _, __, ___) NODE_DEFINE_CONSTANT(target, kKeyVariantAES_##name); VARIANTS(V) #undef V } diff --git a/src/crypto/crypto_aes.h b/src/crypto/crypto_aes.h index 9dfa5edc6544e7..2ddbc14b8e606e 100644 --- a/src/crypto/crypto_aes.h +++ b/src/crypto/crypto_aes.h @@ -15,22 +15,29 @@ constexpr size_t kAesBlockSize = 16; constexpr unsigned kNoAuthTagLength = static_cast(-1); constexpr const char* kDefaultWrapIV = "\xa6\xa6\xa6\xa6\xa6\xa6\xa6\xa6"; -#define VARIANTS(V) \ - V(CTR_128, AES_CTR_Cipher) \ - V(CTR_192, AES_CTR_Cipher) \ - V(CTR_256, AES_CTR_Cipher) \ - V(CBC_128, AES_Cipher) \ - V(CBC_192, AES_Cipher) \ - V(CBC_256, AES_Cipher) \ - V(GCM_128, AES_Cipher) \ - V(GCM_192, AES_Cipher) \ - V(GCM_256, AES_Cipher) \ - V(KW_128, AES_Cipher) \ - V(KW_192, AES_Cipher) \ - V(KW_256, AES_Cipher) +enum class AESCipherMode { + CTR, + CBC, + GCM, + KW, +}; + +#define VARIANTS(V) \ + V(CTR_128, AES_CTR_Cipher, AESCipherMode::CTR, NID_aes_128_ctr) \ + V(CTR_192, AES_CTR_Cipher, AESCipherMode::CTR, NID_aes_192_ctr) \ + V(CTR_256, AES_CTR_Cipher, AESCipherMode::CTR, NID_aes_256_ctr) \ + V(CBC_128, AES_Cipher, AESCipherMode::CBC, NID_aes_128_cbc) \ + V(CBC_192, AES_Cipher, AESCipherMode::CBC, NID_aes_192_cbc) \ + V(CBC_256, AES_Cipher, AESCipherMode::CBC, NID_aes_256_cbc) \ + V(GCM_128, AES_Cipher, AESCipherMode::GCM, NID_aes_128_gcm) \ + V(GCM_192, AES_Cipher, AESCipherMode::GCM, NID_aes_192_gcm) \ + V(GCM_256, AES_Cipher, AESCipherMode::GCM, NID_aes_256_gcm) \ + V(KW_128, AES_Cipher, AESCipherMode::KW, NID_id_aes128_wrap) \ + V(KW_192, AES_Cipher, AESCipherMode::KW, NID_id_aes192_wrap) \ + V(KW_256, AES_Cipher, AESCipherMode::KW, NID_id_aes256_wrap) enum AESKeyVariant { -#define V(name, _) kKeyVariantAES_ ## name, +#define V(name, _, __, ___) kKeyVariantAES_##name, VARIANTS(V) #undef V }; diff --git a/src/crypto/crypto_context.cc b/src/crypto/crypto_context.cc index 7bf10371799b61..22443405aca5a1 100644 --- a/src/crypto/crypto_context.cc +++ b/src/crypto/crypto_context.cc @@ -1,10 +1,11 @@ #include "crypto/crypto_context.h" +#include "base_object-inl.h" #include "crypto/crypto_bio.h" #include "crypto/crypto_common.h" #include "crypto/crypto_util.h" -#include "base_object-inl.h" #include "env-inl.h" #include "memory_tracker-inl.h" +#include "ncrypto.h" #include "node.h" #include "node_buffer.h" #include "node_options.h" @@ -33,7 +34,7 @@ using v8::HandleScope; using v8::Int32; using v8::Integer; using v8::Isolate; -using v8::Just; +using v8::JustVoid; using v8::Local; using v8::Maybe; using v8::Nothing; @@ -546,9 +547,9 @@ void SecureContext::Init(const FunctionCallbackInfo& args) { // OpenSSL 1.1.0 changed the ticket key size, but the OpenSSL 1.0.x size was // exposed in the public API. To retain compatibility, install a callback // which restores the old algorithm. - if (CSPRNG(sc->ticket_key_name_, sizeof(sc->ticket_key_name_)).is_err() || - CSPRNG(sc->ticket_key_hmac_, sizeof(sc->ticket_key_hmac_)).is_err() || - CSPRNG(sc->ticket_key_aes_, sizeof(sc->ticket_key_aes_)).is_err()) { + if (!ncrypto::CSPRNG(sc->ticket_key_name_, sizeof(sc->ticket_key_name_)) || + !ncrypto::CSPRNG(sc->ticket_key_hmac_, sizeof(sc->ticket_key_hmac_)) || + !ncrypto::CSPRNG(sc->ticket_key_aes_, sizeof(sc->ticket_key_aes_))) { return THROW_ERR_CRYPTO_OPERATION_FAILED( env, "Error generating ticket keys"); } @@ -575,20 +576,20 @@ void SecureContext::SetKeylogCallback(KeylogCb cb) { SSL_CTX_set_keylog_callback(ctx_.get(), cb); } -Maybe SecureContext::UseKey(Environment* env, +Maybe SecureContext::UseKey(Environment* env, std::shared_ptr key) { if (key->GetKeyType() != KeyType::kKeyTypePrivate) { THROW_ERR_CRYPTO_INVALID_KEYTYPE(env); - return Nothing(); + return Nothing(); } ClearErrorOnReturn clear_error_on_return; if (!SSL_CTX_use_PrivateKey(ctx_.get(), key->GetAsymmetricKey().get())) { ThrowCryptoError(env, ERR_get_error(), "SSL_CTX_use_PrivateKey"); - return Nothing(); + return Nothing(); } - return Just(true); + return JustVoid(); } void SecureContext::SetKey(const FunctionCallbackInfo& args) { @@ -655,26 +656,28 @@ void SecureContext::SetEngineKey(const FunctionCallbackInfo& args) { "experimental permission model is enabled"); } - CryptoErrorStore errors; + ncrypto::CryptoErrorList errors; Utf8Value engine_id(env->isolate(), args[1]); - EnginePointer engine = LoadEngineById(*engine_id, &errors); + auto engine = ncrypto::EnginePointer::getEngineByName( + engine_id.ToStringView(), &errors); if (!engine) { Local exception; - if (errors.ToException(env).ToLocal(&exception)) + if (errors.empty()) { + errors.add(getNodeCryptoErrorString(NodeCryptoError::ENGINE_NOT_FOUND, + *engine_id)); + } + if (cryptoErrorListToException(env, errors).ToLocal(&exception)) env->isolate()->ThrowException(exception); return; } - if (!ENGINE_init(engine.get())) { + if (!engine.init(true /* finish on exit*/)) { return THROW_ERR_CRYPTO_OPERATION_FAILED( env, "Failure to initialize engine"); } - engine.finish_on_exit = true; - Utf8Value key_name(env->isolate(), args[0]); - EVPKeyPointer key(ENGINE_load_private_key(engine.get(), *key_name, - nullptr, nullptr)); + auto key = engine.loadPrivateKey(key_name.ToStringView()); if (!key) return ThrowCryptoError(env, ERR_get_error(), "ENGINE_load_private_key"); @@ -686,9 +689,10 @@ void SecureContext::SetEngineKey(const FunctionCallbackInfo& args) { } #endif // !OPENSSL_NO_ENGINE -Maybe SecureContext::AddCert(Environment* env, BIOPointer&& bio) { +Maybe SecureContext::AddCert(Environment* env, BIOPointer&& bio) { ClearErrorOnReturn clear_error_on_return; - if (!bio) return Just(false); + // TODO(tniessen): this should be checked by the caller and not treated as ok + if (!bio) return JustVoid(); cert_.reset(); issuer_.reset(); @@ -698,9 +702,9 @@ Maybe SecureContext::AddCert(Environment* env, BIOPointer&& bio) { if (SSL_CTX_use_certificate_chain( ctx_.get(), std::move(bio), &cert_, &issuer_) == 0) { ThrowCryptoError(env, ERR_get_error(), "SSL_CTX_use_certificate_chain"); - return Nothing(); + return Nothing(); } - return Just(true); + return JustVoid(); } void SecureContext::SetCert(const FunctionCallbackInfo& args) { @@ -742,16 +746,17 @@ void SecureContext::AddCACert(const FunctionCallbackInfo& args) { sc->SetCACert(bio); } -Maybe SecureContext::SetCRL(Environment* env, const BIOPointer& bio) { +Maybe SecureContext::SetCRL(Environment* env, const BIOPointer& bio) { ClearErrorOnReturn clear_error_on_return; - if (!bio) return Just(false); + // TODO(tniessen): this should be checked by the caller and not treated as ok + if (!bio) return JustVoid(); DeleteFnPtr crl( PEM_read_bio_X509_CRL(bio.get(), nullptr, NoPasswordCallback, nullptr)); if (!crl) { THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Failed to parse CRL"); - return Nothing(); + return Nothing(); } X509_STORE* cert_store = SSL_CTX_get_cert_store(ctx_.get()); @@ -764,7 +769,7 @@ Maybe SecureContext::SetCRL(Environment* env, const BIOPointer& bio) { CHECK_EQ(1, X509_STORE_set_flags( cert_store, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL)); - return Just(true); + return JustVoid(); } void SecureContext::AddCRL(const FunctionCallbackInfo& args) { @@ -1143,12 +1148,17 @@ void SecureContext::SetClientCertEngine( "experimental permission model is enabled"); } - CryptoErrorStore errors; + ncrypto::CryptoErrorList errors; const Utf8Value engine_id(env->isolate(), args[0]); - EnginePointer engine = LoadEngineById(*engine_id, &errors); + auto engine = ncrypto::EnginePointer::getEngineByName( + engine_id.ToStringView(), &errors); if (!engine) { Local exception; - if (errors.ToException(env).ToLocal(&exception)) + if (errors.empty()) { + errors.add(getNodeCryptoErrorString(NodeCryptoError::ENGINE_NOT_FOUND, + *engine_id)); + } + if (cryptoErrorListToException(env, errors).ToLocal(&exception)) env->isolate()->ThrowException(exception); return; } @@ -1314,7 +1324,7 @@ int SecureContext::TicketCompatibilityCallback(SSL* ssl, if (enc) { memcpy(name, sc->ticket_key_name_, sizeof(sc->ticket_key_name_)); - if (CSPRNG(iv, 16).is_err() || + if (!ncrypto::CSPRNG(iv, 16) || EVP_EncryptInit_ex( ectx, EVP_aes_128_cbc(), nullptr, sc->ticket_key_aes_, iv) <= 0 || HMAC_Init_ex(hctx, diff --git a/src/crypto/crypto_context.h b/src/crypto/crypto_context.h index 108ee0e2b2c8de..f646433bdd222a 100644 --- a/src/crypto/crypto_context.h +++ b/src/crypto/crypto_context.h @@ -60,9 +60,9 @@ class SecureContext final : public BaseObject { inline const X509Pointer& issuer() const { return issuer_; } inline const X509Pointer& cert() const { return cert_; } - v8::Maybe AddCert(Environment* env, BIOPointer&& bio); - v8::Maybe SetCRL(Environment* env, const BIOPointer& bio); - v8::Maybe UseKey(Environment* env, std::shared_ptr key); + v8::Maybe AddCert(Environment* env, BIOPointer&& bio); + v8::Maybe SetCRL(Environment* env, const BIOPointer& bio); + v8::Maybe UseKey(Environment* env, std::shared_ptr key); void SetCACert(const BIOPointer& bio); void SetRootCerts(); @@ -147,7 +147,7 @@ class SecureContext final : public BaseObject { X509Pointer issuer_; #ifndef OPENSSL_NO_ENGINE bool client_cert_engine_provided_ = false; - EnginePointer private_key_engine_; + ncrypto::EnginePointer private_key_engine_; #endif // !OPENSSL_NO_ENGINE unsigned char ticket_key_name_[16]; diff --git a/src/crypto/crypto_keygen.cc b/src/crypto/crypto_keygen.cc index b36f908a0b5a62..7e9c3b0dbc07ec 100644 --- a/src/crypto/crypto_keygen.cc +++ b/src/crypto/crypto_keygen.cc @@ -4,6 +4,7 @@ #include "debug_utils-inl.h" #include "env-inl.h" #include "memory_tracker-inl.h" +#include "ncrypto.h" #include "threadpoolwork-inl.h" #include "v8.h" @@ -71,7 +72,7 @@ Maybe SecretKeyGenTraits::AdditionalConfig( KeyGenJobStatus SecretKeyGenTraits::DoKeyGen(Environment* env, SecretKeyGenConfig* params) { ByteSource::Builder bytes(params->length); - if (CSPRNG(bytes.data(), params->length).is_err()) + if (!ncrypto::CSPRNG(bytes.data(), params->length)) return KeyGenJobStatus::FAILED; params->out = std::move(bytes).release(); return KeyGenJobStatus::OK; diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc index d9bfe3ba3faa61..35474c31bfc2e3 100644 --- a/src/crypto/crypto_keys.cc +++ b/src/crypto/crypto_keys.cc @@ -509,16 +509,17 @@ Maybe ExportJWKAsymmetricKey(Environment* env, std::shared_ptr ImportJWKAsymmetricKey( Environment* env, Local jwk, - const char* kty, + std::string_view kty, const FunctionCallbackInfo& args, unsigned int offset) { - if (strcmp(kty, "RSA") == 0) { + if (kty == "RSA") { return ImportJWKRsaKey(env, jwk, args, offset); - } else if (strcmp(kty, "EC") == 0) { + } else if (kty == "EC") { return ImportJWKEcKey(env, jwk, args, offset); } - THROW_ERR_CRYPTO_INVALID_JWK(env, "%s is not a supported JWK key type", kty); + THROW_ERR_CRYPTO_INVALID_JWK( + env, "%s is not a supported JWK key type", kty.data()); return std::shared_ptr(); } diff --git a/src/crypto/crypto_random.cc b/src/crypto/crypto_random.cc index 48154df7dc91ed..843eaeeabcfffc 100644 --- a/src/crypto/crypto_random.cc +++ b/src/crypto/crypto_random.cc @@ -3,6 +3,7 @@ #include "crypto/crypto_util.h" #include "env-inl.h" #include "memory_tracker-inl.h" +#include "ncrypto.h" #include "threadpoolwork-inl.h" #include "v8.h" @@ -60,7 +61,7 @@ bool RandomBytesTraits::DeriveBits( Environment* env, const RandomBytesConfig& params, ByteSource* unused) { - return CSPRNG(params.buffer, params.size).is_ok(); + return ncrypto::CSPRNG(params.buffer, params.size); } void RandomPrimeConfig::MemoryInfo(MemoryTracker* tracker) const { @@ -154,7 +155,7 @@ bool RandomPrimeTraits::DeriveBits(Environment* env, ByteSource* unused) { // BN_generate_prime_ex() calls RAND_bytes_ex() internally. // Make sure the CSPRNG is properly seeded. - CHECK(CSPRNG(nullptr, 0).is_ok()); + CHECK(ncrypto::CSPRNG(nullptr, 0)); if (BN_generate_prime_ex( params.prime.get(), diff --git a/src/crypto/crypto_rsa.cc b/src/crypto/crypto_rsa.cc index 23b2b8c56dec8a..100f94460686bd 100644 --- a/src/crypto/crypto_rsa.cc +++ b/src/crypto/crypto_rsa.cc @@ -441,7 +441,7 @@ std::shared_ptr ImportJWKRsaKey( KeyType type = d_value->IsString() ? kKeyTypePrivate : kKeyTypePublic; - RsaPointer rsa(RSA_new()); + RSAPointer rsa(RSA_new()); ByteSource n = ByteSource::FromEncodedString(env, n_value.As()); ByteSource e = ByteSource::FromEncodedString(env, e_value.As()); diff --git a/src/crypto/crypto_tls.cc b/src/crypto/crypto_tls.cc index 9fb567f89c11d4..0ad6fa28542978 100644 --- a/src/crypto/crypto_tls.cc +++ b/src/crypto/crypto_tls.cc @@ -64,6 +64,26 @@ using v8::Value; namespace crypto { namespace { + +// Our custom implementation of the certificate verify callback +// used when establishing a TLS handshake. Because we cannot perform +// I/O quickly enough with X509_STORE_CTX_ APIs in this callback, +// we ignore preverify_ok errors here and let the handshake continue. +// In other words, this VerifyCallback is a non-op. It is imperative +// that the user user Connection::VerifyError after the `secure` +// callback has been made. +int VerifyCallback(int preverify_ok, X509_STORE_CTX* ctx) { + // From https://www.openssl.org/docs/man1.1.1/man3/SSL_verify_cb: + // + // If VerifyCallback returns 1, the verification process is continued. If + // VerifyCallback always returns 1, the TLS/SSL handshake will not be + // terminated with respect to verification failures and the connection will + // be established. The calling process can however retrieve the error code + // of the last verification error using SSL_get_verify_result(3) or by + // maintaining its own error storage managed by VerifyCallback. + return 1; +} + SSL_SESSION* GetSessionCallback( SSL* s, const unsigned char* key, diff --git a/src/crypto/crypto_util.cc b/src/crypto/crypto_util.cc index 990638ec3993bd..b164eaadffe705 100644 --- a/src/crypto/crypto_util.cc +++ b/src/crypto/crypto_util.cc @@ -4,6 +4,7 @@ #include "crypto/crypto_keys.h" #include "env-inl.h" #include "memory_tracker-inl.h" +#include "ncrypto.h" #include "node_buffer.h" #include "node_options-inl.h" #include "string_bytes.h" @@ -11,6 +12,10 @@ #include "util-inl.h" #include "v8.h" +#ifndef OPENSSL_NO_ENGINE +#include +#endif // !OPENSSL_NO_ENGINE + #include "math.h" #if OPENSSL_VERSION_MAJOR >= 3 @@ -43,56 +48,6 @@ using v8::Uint8Array; using v8::Value; namespace crypto { -int VerifyCallback(int preverify_ok, X509_STORE_CTX* ctx) { - // From https://www.openssl.org/docs/man1.1.1/man3/SSL_verify_cb: - // - // If VerifyCallback returns 1, the verification process is continued. If - // VerifyCallback always returns 1, the TLS/SSL handshake will not be - // terminated with respect to verification failures and the connection will - // be established. The calling process can however retrieve the error code - // of the last verification error using SSL_get_verify_result(3) or by - // maintaining its own error storage managed by VerifyCallback. - // - // Since we cannot perform I/O quickly enough with X509_STORE_CTX_ APIs in - // this callback, we ignore all preverify_ok errors and let the handshake - // continue. It is imperative that the user use Connection::VerifyError after - // the 'secure' callback has been made. - return 1; -} - -MUST_USE_RESULT CSPRNGResult CSPRNG(void* buffer, size_t length) { - unsigned char* buf = static_cast(buffer); - do { - if (1 == RAND_status()) { -#if OPENSSL_VERSION_MAJOR >= 3 - if (1 == RAND_bytes_ex(nullptr, buf, length, 0)) return {true}; -#else - while (length > INT_MAX && 1 == RAND_bytes(buf, INT_MAX)) { - buf += INT_MAX; - length -= INT_MAX; - } - if (length <= INT_MAX && 1 == RAND_bytes(buf, static_cast(length))) - return {true}; -#endif - } -#if OPENSSL_VERSION_MAJOR >= 3 - const auto code = ERR_peek_last_error(); - // A misconfigured OpenSSL 3 installation may report 1 from RAND_poll() - // and RAND_status() but fail in RAND_bytes() if it cannot look up - // a matching algorithm for the CSPRNG. - if (ERR_GET_LIB(code) == ERR_LIB_RAND) { - const auto reason = ERR_GET_REASON(code); - if (reason == RAND_R_ERROR_INSTANTIATING_DRBG || - reason == RAND_R_UNABLE_TO_FETCH_DRBG || - reason == RAND_R_UNABLE_TO_CREATE_DRBG) { - return {false}; - } - } -#endif - } while (1 == RAND_poll()); - - return {false}; -} int PasswordCallback(char* buf, int size, int rwflag, void* u) { const ByteSource* passphrase = *static_cast(u); @@ -206,21 +161,14 @@ void InitCryptoOnce() { sk_SSL_COMP_zero(SSL_COMP_get_compression_methods()); #ifndef OPENSSL_NO_ENGINE - ERR_load_ENGINE_strings(); - ENGINE_load_builtin_engines(); + ncrypto::EnginePointer::initEnginesOnce(); #endif // !OPENSSL_NO_ENGINE } void GetFipsCrypto(const FunctionCallbackInfo& args) { Mutex::ScopedLock lock(per_process::cli_options_mutex); Mutex::ScopedLock fips_lock(fips_mutex); - -#if OPENSSL_VERSION_MAJOR >= 3 - args.GetReturnValue().Set(EVP_default_properties_is_fips_enabled(nullptr) ? - 1 : 0); -#else - args.GetReturnValue().Set(FIPS_mode() ? 1 : 0); -#endif + args.GetReturnValue().Set(ncrypto::isFipsEnabled() ? 1 : 0); } void SetFipsCrypto(const FunctionCallbackInfo& args) { @@ -232,43 +180,19 @@ void SetFipsCrypto(const FunctionCallbackInfo& args) { CHECK(env->owns_process_state()); bool enable = args[0]->BooleanValue(env->isolate()); -#if OPENSSL_VERSION_MAJOR >= 3 - if (enable == EVP_default_properties_is_fips_enabled(nullptr)) -#else - if (static_cast(enable) == FIPS_mode()) -#endif - return; // No action needed. - -#if OPENSSL_VERSION_MAJOR >= 3 - if (!EVP_default_properties_enable_fips(nullptr, enable)) { -#else - if (!FIPS_mode_set(enable)) { -#endif - unsigned long err = ERR_get_error(); // NOLINT(runtime/int) - return ThrowCryptoError(env, err); + ncrypto::CryptoErrorList errors; + if (!ncrypto::setFipsEnabled(enable, &errors)) { + Local exception; + if (cryptoErrorListToException(env, errors).ToLocal(&exception)) { + env->isolate()->ThrowException(exception); + } } } void TestFipsCrypto(const v8::FunctionCallbackInfo& args) { Mutex::ScopedLock lock(per_process::cli_options_mutex); Mutex::ScopedLock fips_lock(fips_mutex); - -#if OPENSSL_VERSION_MAJOR >= 3 - OSSL_PROVIDER* fips_provider = nullptr; - if (OSSL_PROVIDER_available(nullptr, "fips")) { - fips_provider = OSSL_PROVIDER_load(nullptr, "fips"); - } - const auto enabled = fips_provider == nullptr ? 0 : - OSSL_PROVIDER_self_test(fips_provider) ? 1 : 0; -#else -#ifdef OPENSSL_FIPS - const auto enabled = FIPS_selftest() ? 1 : 0; -#else // OPENSSL_FIPS - const auto enabled = 0; -#endif // OPENSSL_FIPS -#endif - - args.GetReturnValue().Set(enabled); + args.GetReturnValue().Set(ncrypto::testFipsEnabled() ? 1 : 0); } void CryptoErrorStore::Capture() { @@ -285,6 +209,60 @@ bool CryptoErrorStore::Empty() const { return errors_.empty(); } +MaybeLocal cryptoErrorListToException( + Environment* env, const ncrypto::CryptoErrorList& errors) { + // The CryptoErrorList contains a listing of zero or more errors. + // If there are no errors, it is likely a bug but we will return + // an error anyway. + if (errors.empty()) { + return Exception::Error(FIXED_ONE_BYTE_STRING(env->isolate(), "Ok")); + } + + // The last error in the list is the one that will be used as the + // error message. All other errors will be added to the .opensslErrorStack + // property. We know there has to be at least one error in the list at + // this point. + auto& last = errors.peek_back(); + Local message; + if (!String::NewFromUtf8( + env->isolate(), last.data(), NewStringType::kNormal, last.size()) + .ToLocal(&message)) { + return {}; + } + + Local exception = Exception::Error(message); + CHECK(!exception.IsEmpty()); + + if (errors.size() > 1) { + CHECK(exception->IsObject()); + Local exception_obj = exception.As(); + std::vector> stack(errors.size() - 1); + + // Iterate over all but the last error in the list. + auto current = errors.begin(); + auto last = errors.end(); + last--; + while (current != last) { + Local error; + if (!ToV8Value(env->context(), *current).ToLocal(&error)) { + return {}; + } + stack.push_back(error); + ++current; + } + + Local stackArray = + v8::Array::New(env->isolate(), &stack[0], stack.size()); + + if (!exception_obj + ->Set(env->context(), env->openssl_error_stack(), stackArray) + .IsNothing()) { + return {}; + } + } + return exception; +} + MaybeLocal CryptoErrorStore::ToException( Environment* env, Local exception_string) const { @@ -591,54 +569,8 @@ void ThrowCryptoError(Environment* env, } #ifndef OPENSSL_NO_ENGINE -EnginePointer LoadEngineById(const char* id, CryptoErrorStore* errors) { - MarkPopErrorOnReturn mark_pop_error_on_return; - - EnginePointer engine(ENGINE_by_id(id)); - if (!engine) { - // Engine not found, try loading dynamically. - engine = EnginePointer(ENGINE_by_id("dynamic")); - if (engine) { - if (!ENGINE_ctrl_cmd_string(engine.get(), "SO_PATH", id, 0) || - !ENGINE_ctrl_cmd_string(engine.get(), "LOAD", nullptr, 0)) { - engine.reset(); - } - } - } - - if (!engine && errors != nullptr) { - errors->Capture(); - if (errors->Empty()) { - errors->Insert(NodeCryptoError::ENGINE_NOT_FOUND, id); - } - } - - return engine; -} - -bool SetEngine(const char* id, uint32_t flags, CryptoErrorStore* errors) { - ClearErrorOnReturn clear_error_on_return; - EnginePointer engine = LoadEngineById(id, errors); - if (!engine) - return false; - - if (!ENGINE_set_default(engine.get(), flags)) { - if (errors != nullptr) - errors->Capture(); - return false; - } - - return true; -} - void SetEngine(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); - CHECK(args.Length() >= 2 && args[0]->IsString()); - uint32_t flags; - if (!args[1]->Uint32Value(env->context()).To(&flags)) return; - - const node::Utf8Value engine_id(env->isolate(), args[0]); - if (UNLIKELY(env->permission()->enabled())) { return THROW_ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED( env, @@ -646,7 +578,16 @@ void SetEngine(const FunctionCallbackInfo& args) { "experimental permission model is enabled"); } - args.GetReturnValue().Set(SetEngine(*engine_id, flags)); + CHECK(args.Length() >= 2 && args[0]->IsString()); + uint32_t flags; + if (!args[1]->Uint32Value(env->context()).To(&flags)) return; + + const node::Utf8Value engine_id(env->isolate(), args[0]); + // If the engine name is not known, calling setAsDefault on the + // empty engine pointer will be non-op that always returns false. + args.GetReturnValue().Set( + ncrypto::EnginePointer::getEngineByName(engine_id.ToStringView()) + .setAsDefault(flags)); } #endif // !OPENSSL_NO_ENGINE @@ -655,8 +596,8 @@ MaybeLocal EncodeBignum( const BIGNUM* bn, int size, Local* error) { - std::vector buf(size); - CHECK_EQ(BN_bn2binpad(bn, buf.data(), size), size); + std::vector buf = ncrypto::BignumPointer::encodePadded(bn, size); + CHECK_EQ(buf.size(), static_cast(size)); return StringBytes::Encode( env->isolate(), reinterpret_cast(buf.data()), diff --git a/src/crypto/crypto_util.h b/src/crypto/crypto_util.h index 4ba261014695cf..c7aeaa7753c90a 100644 --- a/src/crypto/crypto_util.h +++ b/src/crypto/crypto_util.h @@ -12,6 +12,8 @@ #include "util.h" #include "v8.h" +#include "ncrypto.h" + #include #include #include @@ -20,9 +22,7 @@ #include #include #include -#ifndef OPENSSL_NO_ENGINE -# include -#endif // !OPENSSL_NO_ENGINE + // The FIPS-related functions are only available // when the OpenSSL itself was compiled with FIPS support. #if defined(OPENSSL_FIPS) && OPENSSL_VERSION_MAJOR < 3 @@ -54,39 +54,32 @@ constexpr size_t kSizeOf_EVP_PKEY_CTX = 80; constexpr size_t kSizeOf_HMAC_CTX = 32; // Define smart pointers for the most commonly used OpenSSL types: -using X509Pointer = DeleteFnPtr; -using BIOPointer = DeleteFnPtr; -using SSLCtxPointer = DeleteFnPtr; -using SSLSessionPointer = DeleteFnPtr; -using SSLPointer = DeleteFnPtr; -using PKCS8Pointer = DeleteFnPtr; -using EVPKeyPointer = DeleteFnPtr; -using EVPKeyCtxPointer = DeleteFnPtr; -using EVPMDCtxPointer = DeleteFnPtr; -using RSAPointer = DeleteFnPtr; -using ECPointer = DeleteFnPtr; -using BignumPointer = DeleteFnPtr; -using BignumCtxPointer = DeleteFnPtr; -using NetscapeSPKIPointer = DeleteFnPtr; -using ECGroupPointer = DeleteFnPtr; -using ECPointPointer = DeleteFnPtr; -using ECKeyPointer = DeleteFnPtr; -using DHPointer = DeleteFnPtr; -using ECDSASigPointer = DeleteFnPtr; -using HMACCtxPointer = DeleteFnPtr; -using CipherCtxPointer = DeleteFnPtr; -using RsaPointer = DeleteFnPtr; -using DsaPointer = DeleteFnPtr; -using DsaSigPointer = DeleteFnPtr; - -// Our custom implementation of the certificate verify callback -// used when establishing a TLS handshake. Because we cannot perform -// I/O quickly enough with X509_STORE_CTX_ APIs in this callback, -// we ignore preverify_ok errors here and let the handshake continue. -// In other words, this VerifyCallback is a non-op. It is imperative -// that the user user Connection::VerifyError after the `secure` -// callback has been made. -extern int VerifyCallback(int preverify_ok, X509_STORE_CTX* ctx); +using X509Pointer = ncrypto::X509Pointer; +using BIOPointer = ncrypto::BIOPointer; +using SSLCtxPointer = ncrypto::SSLCtxPointer; +using SSLSessionPointer = ncrypto::SSLSessionPointer; +using SSLPointer = ncrypto::SSLPointer; +using PKCS8Pointer = ncrypto::PKCS8Pointer; +using EVPKeyPointer = ncrypto::EVPKeyPointer; +using EVPKeyCtxPointer = ncrypto::EVPKeyCtxPointer; +using EVPMDCtxPointer = ncrypto::EVPMDCtxPointer; +using RSAPointer = ncrypto::RSAPointer; +using ECPointer = ncrypto::ECPointer; +using BignumPointer = ncrypto::BignumPointer; +using BignumCtxPointer = ncrypto::BignumCtxPointer; +using NetscapeSPKIPointer = ncrypto::NetscapeSPKIPointer; +using ECGroupPointer = ncrypto::ECGroupPointer; +using ECPointPointer = ncrypto::ECPointPointer; +using ECKeyPointer = ncrypto::ECKeyPointer; +using DHPointer = ncrypto::DHPointer; +using ECDSASigPointer = ncrypto::ECDSASigPointer; +using HMACCtxPointer = ncrypto::HMACCtxPointer; +using CipherCtxPointer = ncrypto::CipherCtxPointer; +using DsaPointer = ncrypto::DSAPointer; +using DsaSigPointer = ncrypto::DSASigPointer; + +using ClearErrorOnReturn = ncrypto::ClearErrorOnReturn; +using MarkPopErrorOnReturn = ncrypto::MarkPopErrorOnReturn; bool ProcessFipsOptions(); @@ -97,34 +90,6 @@ void InitCrypto(v8::Local target); extern void UseExtraCaCerts(const std::string& file); -// Forcibly clear OpenSSL's error stack on return. This stops stale errors -// from popping up later in the lifecycle of crypto operations where they -// would cause spurious failures. It's a rather blunt method, though. -// ERR_clear_error() isn't necessarily cheap either. -struct ClearErrorOnReturn { - ~ClearErrorOnReturn() { ERR_clear_error(); } -}; - -// Pop errors from OpenSSL's error stack that were added -// between when this was constructed and destructed. -struct MarkPopErrorOnReturn { - MarkPopErrorOnReturn() { ERR_set_mark(); } - ~MarkPopErrorOnReturn() { ERR_pop_to_mark(); } -}; - -struct CSPRNGResult { - const bool ok; - MUST_USE_RESULT bool is_ok() const { return ok; } - MUST_USE_RESULT bool is_err() const { return !ok; } -}; - -// Either succeeds with exactly |length| bytes of cryptographically -// strong pseudo-random data, or fails. This function may block. -// Don't assume anything about the contents of |buffer| on error. -// As a special case, |length == 0| can be used to check if the CSPRNG -// is properly seeded without consuming entropy. -MUST_USE_RESULT CSPRNGResult CSPRNG(void* buffer, size_t length); - int PasswordCallback(char* buf, int size, int rwflag, void* u); int NoPasswordCallback(char* buf, int size, int rwflag, void* u); @@ -165,6 +130,21 @@ enum class NodeCryptoError { #undef V }; +template +std::string getNodeCryptoErrorString(const NodeCryptoError error, + Args&&... args) { + const char* error_string = nullptr; + switch (error) { +#define V(CODE, DESCRIPTION) \ + case NodeCryptoError::CODE: \ + error_string = DESCRIPTION; \ + break; + NODE_CRYPTO_ERROR_CODES_MAP(V) +#undef V + } + return SPrintF(error_string, std::forward(args)...); +} + // Utility struct used to harvest error information from openssl's error stack struct CryptoErrorStore final : public MemoryRetainer { public: @@ -200,6 +180,9 @@ void CryptoErrorStore::Insert(const NodeCryptoError error, Args&&... args) { std::forward(args)...)); } +v8::MaybeLocal cryptoErrorListToException( + Environment* env, const ncrypto::CryptoErrorList& errors); + template T* MallocOpenSSL(size_t count) { void* mem = OPENSSL_malloc(MultiplyWithOverflowCheck(count, sizeof(T))); @@ -552,72 +535,6 @@ void ThrowCryptoError(Environment* env, unsigned long err, // NOLINT(runtime/int) const char* message = nullptr); -#ifndef OPENSSL_NO_ENGINE -struct EnginePointer { - ENGINE* engine = nullptr; - bool finish_on_exit = false; - - inline EnginePointer() = default; - - inline explicit EnginePointer(ENGINE* engine_, bool finish_on_exit_ = false) - : engine(engine_), - finish_on_exit(finish_on_exit_) {} - - inline EnginePointer(EnginePointer&& other) noexcept - : engine(other.engine), - finish_on_exit(other.finish_on_exit) { - other.release(); - } - - inline ~EnginePointer() { reset(); } - - inline EnginePointer& operator=(EnginePointer&& other) noexcept { - if (this == &other) return *this; - this->~EnginePointer(); - return *new (this) EnginePointer(std::move(other)); - } - - inline operator bool() const { return engine != nullptr; } - - inline ENGINE* get() { return engine; } - - inline void reset(ENGINE* engine_ = nullptr, bool finish_on_exit_ = false) { - if (engine != nullptr) { - if (finish_on_exit) { - // This also does the equivalent of ENGINE_free. - CHECK_EQ(ENGINE_finish(engine), 1); - } else { - CHECK_EQ(ENGINE_free(engine), 1); - } - } - engine = engine_; - finish_on_exit = finish_on_exit_; - } - - inline ENGINE* release() { - ENGINE* ret = engine; - engine = nullptr; - finish_on_exit = false; - return ret; - } -}; - -EnginePointer LoadEngineById(const char* id, CryptoErrorStore* errors); - -bool SetEngine( - const char* id, - uint32_t flags, - CryptoErrorStore* errors = nullptr); - -void SetEngine(const v8::FunctionCallbackInfo& args); -#endif // !OPENSSL_NO_ENGINE - -void GetFipsCrypto(const v8::FunctionCallbackInfo& args); - -void SetFipsCrypto(const v8::FunctionCallbackInfo& args); - -void TestFipsCrypto(const v8::FunctionCallbackInfo& args); - class CipherPushContext { public: inline explicit CipherPushContext(Environment* env) : env_(env) {} diff --git a/src/dataqueue/queue.cc b/src/dataqueue/queue.cc index c3de4eb570beab..64643680903a78 100644 --- a/src/dataqueue/queue.cc +++ b/src/dataqueue/queue.cc @@ -840,7 +840,9 @@ class FdEntry final : public EntryImpl { path_(std::move(path_)), stat_(stat), start_(start), - end_(end) {} + end_(end) { + CHECK_LE(start, end); + } std::shared_ptr get_reader() override { return ReaderImpl::Create(this); @@ -851,7 +853,7 @@ class FdEntry final : public EntryImpl { uint64_t new_start = start_ + start; uint64_t new_end = end_; if (end.has_value()) { - new_end = std::min(end.value(), end_); + new_end = std::min(end.value() + start_, end_); } CHECK(new_start >= start_); diff --git a/src/env_properties.h b/src/env_properties.h index c6262a79504e61..1ed8ab4d116313 100644 --- a/src/env_properties.h +++ b/src/env_properties.h @@ -448,7 +448,9 @@ V(immediate_callback_function, v8::Function) \ V(inspector_console_extension_installer, v8::Function) \ V(inspector_disable_async_hooks, v8::Function) \ + V(inspector_disable_network_tracking, v8::Function) \ V(inspector_enable_async_hooks, v8::Function) \ + V(inspector_enable_network_tracking, v8::Function) \ V(maybe_cache_generated_source_map, v8::Function) \ V(messaging_deserialize_create_object, v8::Function) \ V(message_port, v8::Object) \ diff --git a/src/inspector/network_agent.cc b/src/inspector/network_agent.cc new file mode 100644 index 00000000000000..de17ff0ecb2041 --- /dev/null +++ b/src/inspector/network_agent.cc @@ -0,0 +1,84 @@ +#include "network_agent.h" +#include "network_inspector.h" + +namespace node { +namespace inspector { +namespace protocol { + +std::unique_ptr Request(const String& url, + const String& method) { + return Network::Request::create().setUrl(url).setMethod(method).build(); +} + +NetworkAgent::NetworkAgent(NetworkInspector* inspector) + : inspector_(inspector) { + event_notifier_map_["requestWillBeSent"] = &NetworkAgent::requestWillBeSent; + event_notifier_map_["responseReceived"] = &NetworkAgent::responseReceived; + event_notifier_map_["loadingFinished"] = &NetworkAgent::loadingFinished; +} + +void NetworkAgent::emitNotification( + const String& event, std::unique_ptr params) { + if (!inspector_->IsEnabled()) return; + auto it = event_notifier_map_.find(event); + if (it != event_notifier_map_.end()) { + (this->*(it->second))(std::move(params)); + } +} + +void NetworkAgent::Wire(UberDispatcher* dispatcher) { + frontend_ = std::make_unique(dispatcher->channel()); + Network::Dispatcher::wire(dispatcher, this); +} + +DispatchResponse NetworkAgent::enable() { + inspector_->Enable(); + return DispatchResponse::OK(); +} + +DispatchResponse NetworkAgent::disable() { + inspector_->Disable(); + return DispatchResponse::OK(); +} + +void NetworkAgent::requestWillBeSent( + std::unique_ptr params) { + String request_id; + params->getString("requestId", &request_id); + double timestamp; + params->getDouble("timestamp", ×tamp); + double wall_time; + params->getDouble("wallTime", &wall_time); + auto request = params->getObject("request"); + String url; + request->getString("url", &url); + String method; + request->getString("method", &method); + + frontend_->requestWillBeSent( + request_id, Request(url, method), timestamp, wall_time); +} + +void NetworkAgent::responseReceived( + std::unique_ptr params) { + String request_id; + params->getString("requestId", &request_id); + double timestamp; + params->getDouble("timestamp", ×tamp); + + frontend_->responseReceived(request_id, timestamp); +} + +void NetworkAgent::loadingFinished( + std::unique_ptr params) { + String request_id; + params->getString("requestId", &request_id); + double timestamp; + params->getDouble("timestamp", ×tamp); + + frontend_->loadingFinished(request_id, timestamp); +} + +} // namespace protocol +} // namespace inspector +} // namespace node diff --git a/src/inspector/network_agent.h b/src/inspector/network_agent.h new file mode 100644 index 00000000000000..e2ca447b6e9480 --- /dev/null +++ b/src/inspector/network_agent.h @@ -0,0 +1,49 @@ +#ifndef SRC_INSPECTOR_NETWORK_AGENT_H_ +#define SRC_INSPECTOR_NETWORK_AGENT_H_ + +#include "node/inspector/protocol/Network.h" + +#include + +namespace node { + +namespace inspector { +class NetworkInspector; + +namespace protocol { + +std::unique_ptr Request(const String& url, + const String& method); + +class NetworkAgent : public Network::Backend { + public: + explicit NetworkAgent(NetworkInspector* inspector); + + void Wire(UberDispatcher* dispatcher); + + DispatchResponse enable() override; + + DispatchResponse disable() override; + + void emitNotification(const String& event, + std::unique_ptr params); + + void requestWillBeSent(std::unique_ptr params); + + void responseReceived(std::unique_ptr params); + + void loadingFinished(std::unique_ptr params); + + private: + NetworkInspector* inspector_; + std::shared_ptr frontend_; + using EventNotifier = + void (NetworkAgent::*)(std::unique_ptr); + std::unordered_map event_notifier_map_; +}; + +} // namespace protocol +} // namespace inspector +} // namespace node + +#endif // SRC_INSPECTOR_NETWORK_AGENT_H_ diff --git a/src/inspector/network_inspector.cc b/src/inspector/network_inspector.cc new file mode 100644 index 00000000000000..a03a66d461e527 --- /dev/null +++ b/src/inspector/network_inspector.cc @@ -0,0 +1,48 @@ +#include "network_inspector.h" + +namespace node { +namespace inspector { + +NetworkInspector::NetworkInspector(Environment* env) + : enabled_(false), env_(env) { + network_agent_ = std::make_unique(this); +} +NetworkInspector::~NetworkInspector() { + network_agent_.reset(); +} + +void NetworkInspector::Wire(protocol::UberDispatcher* dispatcher) { + network_agent_->Wire(dispatcher); +} + +bool NetworkInspector::canEmit(const std::string& domain) { + return domain == "Network"; +} + +void NetworkInspector::emitNotification( + const std::string& domain, + const std::string& method, + std::unique_ptr params) { + if (domain == "Network") { + network_agent_->emitNotification(method, std::move(params)); + } else { + UNREACHABLE("Unknown domain"); + } +} + +void NetworkInspector::Enable() { + if (auto agent = env_->inspector_agent()) { + agent->EnableNetworkTracking(); + } + enabled_ = true; +} + +void NetworkInspector::Disable() { + if (auto agent = env_->inspector_agent()) { + agent->DisableNetworkTracking(); + } + enabled_ = false; +} + +} // namespace inspector +} // namespace node diff --git a/src/inspector/network_inspector.h b/src/inspector/network_inspector.h new file mode 100644 index 00000000000000..1a30997bad98f1 --- /dev/null +++ b/src/inspector/network_inspector.h @@ -0,0 +1,38 @@ +#ifndef SRC_INSPECTOR_NETWORK_INSPECTOR_H_ +#define SRC_INSPECTOR_NETWORK_INSPECTOR_H_ + +#include "env.h" +#include "network_agent.h" + +namespace node { +class Environment; + +namespace inspector { + +class NetworkInspector { + public: + explicit NetworkInspector(Environment* env); + ~NetworkInspector(); + + void Wire(protocol::UberDispatcher* dispatcher); + + bool canEmit(const std::string& domain); + + void emitNotification(const std::string& domain, + const std::string& method, + std::unique_ptr params); + + void Enable(); + void Disable(); + bool IsEnabled() const { return enabled_; } + + private: + bool enabled_; + Environment* env_; + std::unique_ptr network_agent_; +}; + +} // namespace inspector +} // namespace node + +#endif // SRC_INSPECTOR_NETWORK_INSPECTOR_H_ diff --git a/src/inspector/node_inspector.gypi b/src/inspector/node_inspector.gypi index a2dfdcb42db196..d559004be80944 100644 --- a/src/inspector/node_inspector.gypi +++ b/src/inspector/node_inspector.gypi @@ -23,6 +23,10 @@ 'src/inspector/tracing_agent.h', 'src/inspector/worker_agent.cc', 'src/inspector/worker_agent.h', + 'src/inspector/network_inspector.cc', + 'src/inspector/network_inspector.h', + 'src/inspector/network_agent.cc', + 'src/inspector/network_agent.h', 'src/inspector/worker_inspector.cc', 'src/inspector/worker_inspector.h', ], @@ -36,6 +40,8 @@ '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/NodeTracing.h', '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/NodeRuntime.cpp', '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/NodeRuntime.h', + '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Network.cpp', + '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Network.h', ], 'node_protocol_files': [ '<(protocol_tool_path)/lib/Allocator_h.template', diff --git a/src/inspector/node_protocol.pdl b/src/inspector/node_protocol.pdl index d8a873de263f23..ab7b6a5414c846 100644 --- a/src/inspector/node_protocol.pdl +++ b/src/inspector/node_protocol.pdl @@ -98,6 +98,57 @@ experimental domain NodeWorker SessionID sessionId string message +# Partial support for Network domain of ChromeDevTools Protocol. +# https://chromedevtools.github.io/devtools-protocol/tot/Network +experimental domain Network + # Unique request identifier. + type RequestId extends string + + # UTC time in seconds, counted from January 1, 1970. + type TimeSinceEpoch extends number + + # Monotonically increasing time in seconds since an arbitrary point in the past. + type MonotonicTime extends number + + # HTTP request data. + type Request extends object + properties + string url + string method + + # Disables network tracking, prevents network events from being sent to the client. + command disable + + # Enables network tracking, network events will now be delivered to the client. + command enable + + # Fired when page is about to send HTTP request. + event requestWillBeSent + parameters + # Request identifier. + RequestId requestId + # Request data. + Request request + # Timestamp. + MonotonicTime timestamp + # Timestamp. + TimeSinceEpoch wallTime + + # Fired when HTTP response is available. + event responseReceived + parameters + # Request identifier. + RequestId requestId + # Timestamp. + MonotonicTime timestamp + + event loadingFinished + parameters + # Request identifier. + RequestId requestId + # Timestamp. + MonotonicTime timestamp + # Support for inspecting node process state. experimental domain NodeRuntime # Enable the NodeRuntime events except by `NodeRuntime.waitingForDisconnect`. diff --git a/src/inspector/node_string.cc b/src/inspector/node_string.cc index 7960971a094fd4..c62e7ed30c4e19 100644 --- a/src/inspector/node_string.cc +++ b/src/inspector/node_string.cc @@ -84,7 +84,7 @@ String StringViewToUtf8(v8_inspector::StringView view) { String fromDouble(double d) { std::ostringstream stream; stream.imbue(std::locale::classic()); // Ignore current locale - stream << d; + stream << std::fixed << d; return stream.str(); } diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc index 4cab7dea04379c..bb39a0cb42a7be 100644 --- a/src/inspector_agent.cc +++ b/src/inspector_agent.cc @@ -2,6 +2,7 @@ #include "env-inl.h" #include "inspector/main_thread_interface.h" +#include "inspector/network_inspector.h" #include "inspector/node_string.h" #include "inspector/runtime_agent.h" #include "inspector/tracing_agent.h" @@ -231,6 +232,8 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel, } runtime_agent_ = std::make_unique(); runtime_agent_->Wire(node_dispatcher_.get()); + network_inspector_ = std::make_unique(env); + network_inspector_->Wire(node_dispatcher_.get()); } ~ChannelImpl() override { @@ -242,6 +245,24 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel, } runtime_agent_->disable(); runtime_agent_.reset(); // Dispose before the dispatchers + network_inspector_->Disable(); + network_inspector_.reset(); // Dispose before the dispatchers + } + + void emitNotificationFromBackend(const StringView& event, + const StringView& params) { + std::unique_ptr value = + protocol::DictionaryValue::cast( + protocol::StringUtil::parseJSON(params)); + std::string raw_event = protocol::StringUtil::StringViewToUtf8(event); + std::string domain_name = raw_event.substr(0, raw_event.find('.')); + std::string event_name = raw_event.substr(raw_event.find('.') + 1); + if (network_inspector_->canEmit(domain_name)) { + network_inspector_->emitNotification( + domain_name, event_name, std::move(value)); + } else { + UNREACHABLE("Unknown domain for emitNotificationFromBackend"); + } } void dispatchProtocolMessage(const StringView& message) { @@ -259,8 +280,8 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel, Utf8ToStringView(method)->string())) { session_->dispatchProtocolMessage(message); } else { - node_dispatcher_->dispatch(call_id, method, std::move(value), - raw_message); + node_dispatcher_->dispatch( + call_id, method, std::move(value), raw_message); } } @@ -335,6 +356,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel, std::unique_ptr runtime_agent_; std::unique_ptr tracing_agent_; std::unique_ptr worker_agent_; + std::unique_ptr network_inspector_; std::unique_ptr delegate_; std::unique_ptr session_; std::unique_ptr node_dispatcher_; @@ -631,6 +653,12 @@ class NodeInspectorClient : public V8InspectorClient { return retaining_context; } + void emitNotification(const StringView& event, const StringView& params) { + for (const auto& id_channel : channels_) { + id_channel.second->emitNotificationFromBackend(event, params); + } + } + std::shared_ptr getThreadHandle() { if (!interface_) { interface_ = std::make_shared( @@ -844,6 +872,66 @@ std::unique_ptr Agent::ConnectToMainThread( prevent_shutdown); } +void Agent::EmitProtocolEvent(const StringView& event, + const StringView& params) { + if (!env()->options()->experimental_network_inspection) return; + client_->emitNotification(event, params); +} + +void Agent::SetupNetworkTracking(Local enable_function, + Local disable_function) { + parent_env_->set_inspector_enable_network_tracking(enable_function); + parent_env_->set_inspector_disable_network_tracking(disable_function); + if (pending_enable_network_tracking) { + pending_enable_network_tracking = false; + EnableNetworkTracking(); + } else if (pending_disable_network_tracking) { + pending_disable_network_tracking = false; + DisableNetworkTracking(); + } +} + +void Agent::EnableNetworkTracking() { + if (network_tracking_enabled_) { + return; + } + HandleScope scope(parent_env_->isolate()); + Local enable = parent_env_->inspector_enable_network_tracking(); + if (enable.IsEmpty()) { + pending_enable_network_tracking = true; + } else { + ToggleNetworkTracking(parent_env_->isolate(), enable); + network_tracking_enabled_ = true; + } +} + +void Agent::DisableNetworkTracking() { + if (!network_tracking_enabled_) { + return; + } + HandleScope scope(parent_env_->isolate()); + Local disable = parent_env_->inspector_disable_network_tracking(); + if (disable.IsEmpty()) { + pending_disable_network_tracking = true; + } else if (!client_->hasConnectedSessions()) { + ToggleNetworkTracking(parent_env_->isolate(), disable); + network_tracking_enabled_ = false; + } +} + +void Agent::ToggleNetworkTracking(Isolate* isolate, Local fn) { + if (!parent_env_->can_call_into_js()) return; + auto context = parent_env_->context(); + HandleScope scope(isolate); + CHECK(!fn.IsEmpty()); + v8::TryCatch try_catch(isolate); + USE(fn->Call(context, Undefined(isolate), 0, nullptr)); + if (try_catch.HasCaught() && !try_catch.HasTerminated()) { + PrintCaughtException(isolate, context, try_catch); + UNREACHABLE("Cannot toggle network tracking, please report this."); + } +} + void Agent::WaitForDisconnect() { THROW_IF_INSUFFICIENT_PERMISSIONS(parent_env_, permission::PermissionScope::kInspector, diff --git a/src/inspector_agent.h b/src/inspector_agent.h index 725275e43c7135..2ddffdb63ffee3 100644 --- a/src/inspector_agent.h +++ b/src/inspector_agent.h @@ -69,6 +69,14 @@ class Agent { void ReportUncaughtException(v8::Local error, v8::Local message); + void EmitProtocolEvent(const v8_inspector::StringView& event, + const v8_inspector::StringView& params); + + void SetupNetworkTracking(v8::Local enable_function, + v8::Local disable_function); + void EnableNetworkTracking(); + void DisableNetworkTracking(); + // Async stack traces instrumentation. void AsyncTaskScheduled(const v8_inspector::StringView& taskName, void* task, bool recurring); @@ -121,6 +129,7 @@ class Agent { private: void ToggleAsyncHook(v8::Isolate* isolate, v8::Local fn); + void ToggleNetworkTracking(v8::Isolate* isolate, v8::Local fn); node::Environment* parent_env_; // Encapsulates majority of the Inspector functionality @@ -139,6 +148,10 @@ class Agent { bool pending_enable_async_hook_ = false; bool pending_disable_async_hook_ = false; + + bool network_tracking_enabled_ = false; + bool pending_enable_network_tracking = false; + bool pending_disable_network_tracking = false; }; } // namespace inspector diff --git a/src/inspector_io.cc b/src/inspector_io.cc index b7b8f21e3ff16a..4e76e529fcf341 100644 --- a/src/inspector_io.cc +++ b/src/inspector_io.cc @@ -1,16 +1,17 @@ #include "inspector_io.h" -#include "inspector_socket_server.h" -#include "inspector/main_thread_interface.h" -#include "inspector/node_string.h" -#include "crypto/crypto_util.h" #include "base_object-inl.h" +#include "crypto/crypto_util.h" #include "debug_utils-inl.h" +#include "inspector/main_thread_interface.h" +#include "inspector/node_string.h" +#include "inspector_socket_server.h" +#include "ncrypto.h" #include "node.h" #include "node_internals.h" #include "node_mutex.h" -#include "v8-inspector.h" #include "util-inl.h" +#include "v8-inspector.h" #include "zlib.h" #include @@ -46,7 +47,7 @@ std::string ScriptPath(uv_loop_t* loop, const std::string& script_name) { // Used ver 4 - with numbers std::string GenerateID() { uint16_t buffer[8]; - CHECK(crypto::CSPRNG(buffer, sizeof(buffer)).is_ok()); + CHECK(ncrypto::CSPRNG(buffer, sizeof(buffer))); char uuid[256]; snprintf(uuid, sizeof(uuid), "%04x%04x-%04x-%04x-%04x-%04x%04x%04x", diff --git a/src/inspector_js_api.cc b/src/inspector_js_api.cc index 5700f8c5efc698..282575601545d1 100644 --- a/src/inspector_js_api.cc +++ b/src/inspector_js_api.cc @@ -270,6 +270,30 @@ static void RegisterAsyncHookWrapper(const FunctionCallbackInfo& args) { enable_function, disable_function); } +void EmitProtocolEvent(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + CHECK(args[0]->IsString()); + Local eventName = args[0].As(); + CHECK(args[1]->IsString()); + Local params = args[1].As(); + + env->inspector_agent()->EmitProtocolEvent( + ToProtocolString(env->isolate(), eventName)->string(), + ToProtocolString(env->isolate(), params)->string()); +} + +void SetupNetworkTracking(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + + CHECK(args[0]->IsFunction()); + Local enable_function = args[0].As(); + CHECK(args[1]->IsFunction()); + Local disable_function = args[1].As(); + + env->inspector_agent()->SetupNetworkTracking(enable_function, + disable_function); +} + void IsEnabled(const FunctionCallbackInfo& args) { Environment* env = Environment::GetCurrent(args); args.GetReturnValue().Set(env->inspector_agent()->IsListening()); @@ -354,6 +378,8 @@ void Initialize(Local target, Local unused, SetMethod(context, target, "registerAsyncHook", RegisterAsyncHookWrapper); SetMethodNoSideEffect(context, target, "isEnabled", IsEnabled); + SetMethod(context, target, "emitProtocolEvent", EmitProtocolEvent); + SetMethod(context, target, "setupNetworkTracking", SetupNetworkTracking); Local console_string = FIXED_ONE_BYTE_STRING(isolate, "console"); @@ -387,6 +413,8 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) { registry->Register(RegisterAsyncHookWrapper); registry->Register(IsEnabled); + registry->Register(EmitProtocolEvent); + registry->Register(SetupNetworkTracking); registry->Register(JSBindingsConnection::New); registry->Register(JSBindingsConnection::Dispatch); diff --git a/src/js_native_api.h b/src/js_native_api.h index c5114651dc6b00..1558a9f996a069 100644 --- a/src/js_native_api.h +++ b/src/js_native_api.h @@ -50,7 +50,7 @@ EXTERN_C_START NAPI_EXTERN napi_status NAPI_CDECL napi_get_last_error_info( - node_api_nogc_env env, const napi_extended_error_info** result); + node_api_basic_env env, const napi_extended_error_info** result); // Getters for defined singletons NAPI_EXTERN napi_status NAPI_CDECL napi_get_undefined(napi_env env, @@ -94,19 +94,19 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf16(napi_env env, napi_value* result); #ifdef NAPI_EXPERIMENTAL #define NODE_API_EXPERIMENTAL_HAS_EXTERNAL_STRINGS -NAPI_EXTERN napi_status NAPI_CDECL -node_api_create_external_string_latin1(napi_env env, - char* str, - size_t length, - node_api_nogc_finalize finalize_callback, - void* finalize_hint, - napi_value* result, - bool* copied); +NAPI_EXTERN napi_status NAPI_CDECL node_api_create_external_string_latin1( + napi_env env, + char* str, + size_t length, + node_api_basic_finalize finalize_callback, + void* finalize_hint, + napi_value* result, + bool* copied); NAPI_EXTERN napi_status NAPI_CDECL node_api_create_external_string_utf16(napi_env env, char16_t* str, size_t length, - node_api_nogc_finalize finalize_callback, + node_api_basic_finalize finalize_callback, void* finalize_hint, napi_value* result, bool* copied); @@ -318,12 +318,13 @@ napi_define_class(napi_env env, napi_value* result); // Methods to work with external data objects -NAPI_EXTERN napi_status NAPI_CDECL napi_wrap(napi_env env, - napi_value js_object, - void* native_object, - node_api_nogc_finalize finalize_cb, - void* finalize_hint, - napi_ref* result); +NAPI_EXTERN napi_status NAPI_CDECL +napi_wrap(napi_env env, + napi_value js_object, + void* native_object, + node_api_basic_finalize finalize_cb, + void* finalize_hint, + napi_ref* result); NAPI_EXTERN napi_status NAPI_CDECL napi_unwrap(napi_env env, napi_value js_object, void** result); @@ -333,7 +334,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_remove_wrap(napi_env env, NAPI_EXTERN napi_status NAPI_CDECL napi_create_external(napi_env env, void* data, - node_api_nogc_finalize finalize_cb, + node_api_basic_finalize finalize_cb, void* finalize_hint, napi_value* result); NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_external(napi_env env, @@ -432,7 +433,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_create_external_arraybuffer(napi_env env, void* external_data, size_t byte_length, - node_api_nogc_finalize finalize_cb, + node_api_basic_finalize finalize_cb, void* finalize_hint, napi_value* result); #endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED @@ -474,7 +475,7 @@ napi_get_dataview_info(napi_env env, size_t* byte_offset); // version management -NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_nogc_env env, +NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_basic_env env, uint32_t* result); // Promises @@ -498,7 +499,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_run_script(napi_env env, // Memory management NAPI_EXTERN napi_status NAPI_CDECL napi_adjust_external_memory( - node_api_nogc_env env, int64_t change_in_bytes, int64_t* adjusted_value); + node_api_basic_env env, int64_t change_in_bytes, int64_t* adjusted_value); #if NAPI_VERSION >= 5 @@ -520,7 +521,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_add_finalizer(napi_env env, napi_value js_object, void* finalize_data, - node_api_nogc_finalize finalize_cb, + node_api_basic_finalize finalize_cb, void* finalize_hint, napi_ref* result); @@ -530,7 +531,7 @@ napi_add_finalizer(napi_env env, #define NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER NAPI_EXTERN napi_status NAPI_CDECL -node_api_post_finalizer(node_api_nogc_env env, +node_api_post_finalizer(node_api_basic_env env, napi_finalize finalize_cb, void* finalize_data, void* finalize_hint); @@ -575,13 +576,13 @@ napi_get_all_property_names(napi_env env, // Instance data NAPI_EXTERN napi_status NAPI_CDECL -napi_set_instance_data(node_api_nogc_env env, +napi_set_instance_data(node_api_basic_env env, void* data, napi_finalize finalize_cb, void* finalize_hint); -NAPI_EXTERN napi_status NAPI_CDECL napi_get_instance_data(node_api_nogc_env env, - void** data); +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_instance_data(node_api_basic_env env, void** data); #endif // NAPI_VERSION >= 6 #if NAPI_VERSION >= 7 diff --git a/src/js_native_api_types.h b/src/js_native_api_types.h index 7cb5b080cc377a..43e7bb77ff94e7 100644 --- a/src/js_native_api_types.h +++ b/src/js_native_api_types.h @@ -27,7 +27,7 @@ typedef struct napi_env__* napi_env; // meaning that they do not affect the state of the JS engine, and can // therefore be called synchronously from a finalizer that itself runs // synchronously during GC. Such APIs can receive either a `napi_env` or a -// `node_api_nogc_env` as their first parameter, because we should be able to +// `node_api_basic_env` as their first parameter, because we should be able to // also call them during normal, non-garbage-collecting operations, whereas // APIs that affect the state of the JS engine can only receive a `napi_env` as // their first parameter, because we must not call them during GC. In lieu of @@ -37,19 +37,21 @@ typedef struct napi_env__* napi_env; // expecting a non-const value. // // In conjunction with appropriate CFLAGS to warn us if we're passing a const -// (nogc) environment into an API that expects a non-const environment, and the -// definition of nogc finalizer function pointer types below, which receive a -// nogc environment as their first parameter, and can thus only call nogc APIs -// (unless the user explicitly casts the environment), we achieve the ability -// to ensure at compile time that we do not call APIs that affect the state of -// the JS engine from a synchronous (nogc) finalizer. +// (basic) environment into an API that expects a non-const environment, and +// the definition of basic finalizer function pointer types below, which +// receive a basic environment as their first parameter, and can thus only call +// basic APIs (unless the user explicitly casts the environment), we achieve +// the ability to ensure at compile time that we do not call APIs that affect +// the state of the JS engine from a synchronous (basic) finalizer. #if !defined(NAPI_EXPERIMENTAL) || \ (defined(NAPI_EXPERIMENTAL) && \ - defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT)) + (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) || \ + defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT))) typedef struct napi_env__* node_api_nogc_env; #else typedef const struct napi_env__* node_api_nogc_env; #endif +typedef node_api_nogc_env node_api_basic_env; typedef struct napi_value__* napi_value; typedef struct napi_ref__* napi_ref; @@ -147,13 +149,15 @@ typedef void(NAPI_CDECL* napi_finalize)(napi_env env, #if !defined(NAPI_EXPERIMENTAL) || \ (defined(NAPI_EXPERIMENTAL) && \ - defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT)) + (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) || \ + defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT))) typedef napi_finalize node_api_nogc_finalize; #else typedef void(NAPI_CDECL* node_api_nogc_finalize)(node_api_nogc_env env, void* finalize_data, void* finalize_hint); #endif +typedef node_api_nogc_finalize node_api_basic_finalize; typedef struct { // One of utf8name or name should be NULL. diff --git a/src/js_native_api_v8.cc b/src/js_native_api_v8.cc index 44270df350c174..c03e1570ca6c0c 100644 --- a/src/js_native_api_v8.cc +++ b/src/js_native_api_v8.cc @@ -909,8 +909,8 @@ static const char* error_messages[] = { }; napi_status NAPI_CDECL napi_get_last_error_info( - node_api_nogc_env nogc_env, const napi_extended_error_info** result) { - napi_env env = const_cast(nogc_env); + node_api_basic_env basic_env, const napi_extended_error_info** result) { + napi_env env = const_cast(basic_env); CHECK_ENV(env); CHECK_ARG(env, result); @@ -1652,12 +1652,12 @@ napi_status NAPI_CDECL node_api_create_external_string_latin1( napi_env env, char* str, size_t length, - node_api_nogc_finalize nogc_finalize_callback, + node_api_basic_finalize basic_finalize_callback, void* finalize_hint, napi_value* result, bool* copied) { napi_finalize finalize_callback = - reinterpret_cast(nogc_finalize_callback); + reinterpret_cast(basic_finalize_callback); return v8impl::NewExternalString( env, str, @@ -1681,12 +1681,12 @@ napi_status NAPI_CDECL node_api_create_external_string_utf16( napi_env env, char16_t* str, size_t length, - node_api_nogc_finalize nogc_finalize_callback, + node_api_basic_finalize basic_finalize_callback, void* finalize_hint, napi_value* result, bool* copied) { napi_finalize finalize_callback = - reinterpret_cast(nogc_finalize_callback); + reinterpret_cast(basic_finalize_callback); return v8impl::NewExternalString( env, str, @@ -2560,10 +2560,11 @@ GEN_COERCE_FUNCTION(STRING, String, string) napi_status NAPI_CDECL napi_wrap(napi_env env, napi_value js_object, void* native_object, - node_api_nogc_finalize nogc_finalize_cb, + node_api_basic_finalize basic_finalize_cb, void* finalize_hint, napi_ref* result) { - napi_finalize finalize_cb = reinterpret_cast(nogc_finalize_cb); + napi_finalize finalize_cb = + reinterpret_cast(basic_finalize_cb); return v8impl::Wrap( env, js_object, native_object, finalize_cb, finalize_hint, result); } @@ -2583,10 +2584,11 @@ napi_status NAPI_CDECL napi_remove_wrap(napi_env env, napi_status NAPI_CDECL napi_create_external(napi_env env, void* data, - node_api_nogc_finalize nogc_finalize_cb, + node_api_basic_finalize basic_finalize_cb, void* finalize_hint, napi_value* result) { - napi_finalize finalize_cb = reinterpret_cast(nogc_finalize_cb); + napi_finalize finalize_cb = + reinterpret_cast(basic_finalize_cb); NAPI_PREAMBLE(env); CHECK_ARG(env, result); @@ -3027,7 +3029,7 @@ napi_status NAPI_CDECL napi_create_external_arraybuffer(napi_env env, void* external_data, size_t byte_length, - node_api_nogc_finalize finalize_cb, + node_api_basic_finalize finalize_cb, void* finalize_hint, napi_value* result) { // The API contract here is that the cleanup function runs on the JS thread, @@ -3292,7 +3294,7 @@ napi_status NAPI_CDECL napi_get_dataview_info(napi_env env, return napi_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_version(node_api_nogc_env env, +napi_status NAPI_CDECL napi_get_version(node_api_basic_env env, uint32_t* result) { CHECK_ENV(env); CHECK_ARG(env, result); @@ -3414,12 +3416,13 @@ napi_status NAPI_CDECL napi_add_finalizer(napi_env env, napi_value js_object, void* finalize_data, - node_api_nogc_finalize nogc_finalize_cb, + node_api_basic_finalize basic_finalize_cb, void* finalize_hint, napi_ref* result) { // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw // JS exceptions. - napi_finalize finalize_cb = reinterpret_cast(nogc_finalize_cb); + napi_finalize finalize_cb = + reinterpret_cast(basic_finalize_cb); CHECK_ENV_NOT_IN_GC(env); CHECK_ARG(env, js_object); CHECK_ARG(env, finalize_cb); @@ -3443,11 +3446,11 @@ napi_add_finalizer(napi_env env, #ifdef NAPI_EXPERIMENTAL -napi_status NAPI_CDECL node_api_post_finalizer(node_api_nogc_env nogc_env, +napi_status NAPI_CDECL node_api_post_finalizer(node_api_basic_env basic_env, napi_finalize finalize_cb, void* finalize_data, void* finalize_hint) { - napi_env env = const_cast(nogc_env); + napi_env env = const_cast(basic_env); CHECK_ENV(env); env->EnqueueFinalizer(v8impl::TrackedFinalizer::New( env, finalize_cb, finalize_data, finalize_hint)); @@ -3456,7 +3459,7 @@ napi_status NAPI_CDECL node_api_post_finalizer(node_api_nogc_env nogc_env, #endif -napi_status NAPI_CDECL napi_adjust_external_memory(node_api_nogc_env env, +napi_status NAPI_CDECL napi_adjust_external_memory(node_api_basic_env env, int64_t change_in_bytes, int64_t* adjusted_value) { CHECK_ENV(env); @@ -3468,11 +3471,11 @@ napi_status NAPI_CDECL napi_adjust_external_memory(node_api_nogc_env env, return napi_clear_last_error(env); } -napi_status NAPI_CDECL napi_set_instance_data(node_api_nogc_env nogc_env, +napi_status NAPI_CDECL napi_set_instance_data(node_api_basic_env basic_env, void* data, napi_finalize finalize_cb, void* finalize_hint) { - napi_env env = const_cast(nogc_env); + napi_env env = const_cast(basic_env); CHECK_ENV(env); v8impl::RefBase* old_data = static_cast(env->instance_data); @@ -3488,7 +3491,7 @@ napi_status NAPI_CDECL napi_set_instance_data(node_api_nogc_env nogc_env, return napi_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_instance_data(node_api_nogc_env env, +napi_status NAPI_CDECL napi_get_instance_data(node_api_basic_env env, void** data) { CHECK_ENV(env); CHECK_ARG(env, data); diff --git a/src/js_native_api_v8.h b/src/js_native_api_v8.h index 1974c3f6873ef7..1817226b2daac4 100644 --- a/src/js_native_api_v8.h +++ b/src/js_native_api_v8.h @@ -4,7 +4,7 @@ #include "js_native_api_types.h" #include "js_native_api_v8_internals.h" -inline napi_status napi_clear_last_error(node_api_nogc_env env); +inline napi_status napi_clear_last_error(node_api_basic_env env); namespace v8impl { @@ -172,8 +172,8 @@ struct napi_env__ { virtual ~napi_env__() = default; }; -inline napi_status napi_clear_last_error(node_api_nogc_env nogc_env) { - napi_env env = const_cast(nogc_env); +inline napi_status napi_clear_last_error(node_api_basic_env basic_env) { + napi_env env = const_cast(basic_env); env->last_error.error_code = napi_ok; env->last_error.engine_error_code = 0; env->last_error.engine_reserved = nullptr; @@ -181,11 +181,11 @@ inline napi_status napi_clear_last_error(node_api_nogc_env nogc_env) { return napi_ok; } -inline napi_status napi_set_last_error(node_api_nogc_env nogc_env, +inline napi_status napi_set_last_error(node_api_basic_env basic_env, napi_status error_code, uint32_t engine_error_code = 0, void* engine_reserved = nullptr) { - napi_env env = const_cast(nogc_env); + napi_env env = const_cast(basic_env); env->last_error.error_code = error_code; env->last_error.engine_error_code = engine_error_code; env->last_error.engine_reserved = engine_reserved; diff --git a/src/node.cc b/src/node.cc index e2e6da2b725c3e..ec703ca4132e61 100644 --- a/src/node.cc +++ b/src/node.cc @@ -47,6 +47,7 @@ #include "node_version.h" #if HAVE_OPENSSL +#include "ncrypto.h" #include "node_crypto.h" #endif @@ -1191,14 +1192,14 @@ InitializeOncePerProcessInternal(const std::vector& args, } // Ensure CSPRNG is properly seeded. - CHECK(crypto::CSPRNG(nullptr, 0).is_ok()); + CHECK(ncrypto::CSPRNG(nullptr, 0)); V8::SetEntropySource([](unsigned char* buffer, size_t length) { // V8 falls back to very weak entropy when this function fails // and /dev/urandom isn't available. That wouldn't be so bad if // the entropy was only used for Math.random() but it's also used for // hash table and address space layout randomization. Better to abort. - CHECK(crypto::CSPRNG(buffer, length).is_ok()); + CHECK(ncrypto::CSPRNG(buffer, length)); return true; }); #endif // !defined(OPENSSL_IS_BORINGSSL) diff --git a/src/node_api.cc b/src/node_api.cc index 27f67d8c7a3875..3952b814f36ed7 100644 --- a/src/node_api.cc +++ b/src/node_api.cc @@ -765,7 +765,7 @@ void NAPI_CDECL napi_module_register(napi_module* mod) { node::node_module_register(nm); } -napi_status NAPI_CDECL napi_add_env_cleanup_hook(node_api_nogc_env env, +napi_status NAPI_CDECL napi_add_env_cleanup_hook(node_api_basic_env env, napi_cleanup_hook fun, void* arg) { CHECK_ENV(env); @@ -776,7 +776,7 @@ napi_status NAPI_CDECL napi_add_env_cleanup_hook(node_api_nogc_env env, return napi_ok; } -napi_status NAPI_CDECL napi_remove_env_cleanup_hook(node_api_nogc_env env, +napi_status NAPI_CDECL napi_remove_env_cleanup_hook(node_api_basic_env env, napi_cleanup_hook fun, void* arg) { CHECK_ENV(env); @@ -823,11 +823,11 @@ struct napi_async_cleanup_hook_handle__ { }; napi_status NAPI_CDECL -napi_add_async_cleanup_hook(node_api_nogc_env nogc_env, +napi_add_async_cleanup_hook(node_api_basic_env basic_env, napi_async_cleanup_hook hook, void* arg, napi_async_cleanup_hook_handle* remove_handle) { - napi_env env = const_cast(nogc_env); + napi_env env = const_cast(basic_env); CHECK_ENV(env); CHECK_ARG(env, hook); @@ -1042,10 +1042,11 @@ napi_status NAPI_CDECL napi_create_external_buffer(napi_env env, size_t length, void* data, - node_api_nogc_finalize nogc_finalize_cb, + node_api_basic_finalize basic_finalize_cb, void* finalize_hint, napi_value* result) { - napi_finalize finalize_cb = reinterpret_cast(nogc_finalize_cb); + napi_finalize finalize_cb = + reinterpret_cast(basic_finalize_cb); NAPI_PREAMBLE(env); CHECK_ARG(env, result); @@ -1131,7 +1132,7 @@ napi_status NAPI_CDECL napi_get_buffer_info(napi_env env, return napi_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_node_version(node_api_nogc_env env, +napi_status NAPI_CDECL napi_get_node_version(node_api_basic_env env, const napi_node_version** result) { CHECK_ENV(env); CHECK_ARG(env, result); @@ -1275,16 +1276,16 @@ napi_status NAPI_CDECL napi_delete_async_work(napi_env env, return napi_clear_last_error(env); } -napi_status NAPI_CDECL napi_get_uv_event_loop(node_api_nogc_env nogc_env, +napi_status NAPI_CDECL napi_get_uv_event_loop(node_api_basic_env basic_env, uv_loop_t** loop) { - napi_env env = const_cast(nogc_env); + napi_env env = const_cast(basic_env); CHECK_ENV(env); CHECK_ARG(env, loop); *loop = reinterpret_cast(env)->node_env()->event_loop(); return napi_clear_last_error(env); } -napi_status NAPI_CDECL napi_queue_async_work(node_api_nogc_env env, +napi_status NAPI_CDECL napi_queue_async_work(node_api_basic_env env, napi_async_work work) { CHECK_ENV(env); CHECK_ARG(env, work); @@ -1299,7 +1300,7 @@ napi_status NAPI_CDECL napi_queue_async_work(node_api_nogc_env env, return napi_clear_last_error(env); } -napi_status NAPI_CDECL napi_cancel_async_work(node_api_nogc_env env, +napi_status NAPI_CDECL napi_cancel_async_work(node_api_basic_env env, napi_async_work work) { CHECK_ENV(env); CHECK_ARG(env, work); @@ -1405,20 +1406,20 @@ napi_status NAPI_CDECL napi_release_threadsafe_function( } napi_status NAPI_CDECL napi_unref_threadsafe_function( - node_api_nogc_env env, napi_threadsafe_function func) { + node_api_basic_env env, napi_threadsafe_function func) { CHECK_NOT_NULL(func); return reinterpret_cast(func)->Unref(); } napi_status NAPI_CDECL napi_ref_threadsafe_function( - node_api_nogc_env env, napi_threadsafe_function func) { + node_api_basic_env env, napi_threadsafe_function func) { CHECK_NOT_NULL(func); return reinterpret_cast(func)->Ref(); } -napi_status NAPI_CDECL node_api_get_module_file_name(node_api_nogc_env nogc_env, - const char** result) { - napi_env env = const_cast(nogc_env); +napi_status NAPI_CDECL node_api_get_module_file_name( + node_api_basic_env basic_env, const char** result) { + napi_env env = const_cast(basic_env); CHECK_ENV(env); CHECK_ARG(env, result); diff --git a/src/node_api.h b/src/node_api.h index e94ee486392840..526cdd5d406eb6 100644 --- a/src/node_api.h +++ b/src/node_api.h @@ -131,7 +131,7 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_create_external_buffer(napi_env env, size_t length, void* data, - node_api_nogc_finalize finalize_cb, + node_api_basic_finalize finalize_cb, void* finalize_hint, napi_value* result); #endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED @@ -159,20 +159,20 @@ napi_create_async_work(napi_env env, napi_async_work* result); NAPI_EXTERN napi_status NAPI_CDECL napi_delete_async_work(napi_env env, napi_async_work work); -NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(node_api_nogc_env env, +NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(node_api_basic_env env, napi_async_work work); -NAPI_EXTERN napi_status NAPI_CDECL napi_cancel_async_work(node_api_nogc_env env, - napi_async_work work); +NAPI_EXTERN napi_status NAPI_CDECL +napi_cancel_async_work(node_api_basic_env env, napi_async_work work); // version management -NAPI_EXTERN napi_status NAPI_CDECL -napi_get_node_version(node_api_nogc_env env, const napi_node_version** version); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_node_version( + node_api_basic_env env, const napi_node_version** version); #if NAPI_VERSION >= 2 // Return the current libuv event loop for a given environment NAPI_EXTERN napi_status NAPI_CDECL -napi_get_uv_event_loop(node_api_nogc_env env, struct uv_loop_s** loop); +napi_get_uv_event_loop(node_api_basic_env env, struct uv_loop_s** loop); #endif // NAPI_VERSION >= 2 @@ -182,10 +182,10 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_fatal_exception(napi_env env, napi_value err); NAPI_EXTERN napi_status NAPI_CDECL napi_add_env_cleanup_hook( - node_api_nogc_env env, napi_cleanup_hook fun, void* arg); + node_api_basic_env env, napi_cleanup_hook fun, void* arg); NAPI_EXTERN napi_status NAPI_CDECL napi_remove_env_cleanup_hook( - node_api_nogc_env env, napi_cleanup_hook fun, void* arg); + node_api_basic_env env, napi_cleanup_hook fun, void* arg); NAPI_EXTERN napi_status NAPI_CDECL napi_open_callback_scope(napi_env env, @@ -229,17 +229,17 @@ NAPI_EXTERN napi_status NAPI_CDECL napi_release_threadsafe_function( napi_threadsafe_function func, napi_threadsafe_function_release_mode mode); NAPI_EXTERN napi_status NAPI_CDECL napi_unref_threadsafe_function( - node_api_nogc_env env, napi_threadsafe_function func); + node_api_basic_env env, napi_threadsafe_function func); NAPI_EXTERN napi_status NAPI_CDECL napi_ref_threadsafe_function( - node_api_nogc_env env, napi_threadsafe_function func); + node_api_basic_env env, napi_threadsafe_function func); #endif // NAPI_VERSION >= 4 #if NAPI_VERSION >= 8 NAPI_EXTERN napi_status NAPI_CDECL -napi_add_async_cleanup_hook(node_api_nogc_env env, +napi_add_async_cleanup_hook(node_api_basic_env env, napi_async_cleanup_hook hook, void* arg, napi_async_cleanup_hook_handle* remove_handle); @@ -252,7 +252,7 @@ napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle); #if NAPI_VERSION >= 9 NAPI_EXTERN napi_status NAPI_CDECL -node_api_get_module_file_name(node_api_nogc_env env, const char** result); +node_api_get_module_file_name(node_api_basic_env env, const char** result); #endif // NAPI_VERSION >= 9 diff --git a/src/node_builtins.cc b/src/node_builtins.cc index 1702ac0ac5332e..97dde02295c975 100644 --- a/src/node_builtins.cc +++ b/src/node_builtins.cc @@ -489,6 +489,14 @@ MaybeLocal BuiltinLoader::CompileAndCall(Local context, return fn->Call(context, undefined, argc, argv); } +MaybeLocal BuiltinLoader::LookupAndCompile( + Local context, + const char* id, + std::vector>* parameters, + Realm* optional_realm) { + return LookupAndCompileInternal(context, id, parameters, optional_realm); +} + bool BuiltinLoader::CompileAllBuiltinsAndCopyCodeCache( Local context, const std::vector& eager_builtins, diff --git a/src/node_builtins.h b/src/node_builtins.h index 75a7f3dd89e096..1cb85b9058d065 100644 --- a/src/node_builtins.h +++ b/src/node_builtins.h @@ -97,6 +97,12 @@ class NODE_EXTERN_PRIVATE BuiltinLoader { const char* id, Realm* optional_realm); + v8::MaybeLocal LookupAndCompile( + v8::Local context, + const char* id, + std::vector>* parameters, + Realm* optional_realm); + v8::MaybeLocal CompileAndCall(v8::Local context, const char* id, int argc, diff --git a/src/node_dotenv.cc b/src/node_dotenv.cc index cd761aab70cd52..9e0205b4e6249f 100644 --- a/src/node_dotenv.cc +++ b/src/node_dotenv.cc @@ -129,6 +129,7 @@ void Dotenv::ParseContent(const std::string_view input) { key = content.substr(0, equal); content.remove_prefix(equal + 1); key = trim_spaces(key); + content = trim_spaces(content); if (key.empty()) { break; diff --git a/src/node_errors.h b/src/node_errors.h index 0a74373cf5d333..8d70680171b1a8 100644 --- a/src/node_errors.h +++ b/src/node_errors.h @@ -70,6 +70,13 @@ void OOMErrorHandler(const char* location, const v8::OOMDetails& details); V(ERR_DLOPEN_FAILED, Error) \ V(ERR_ENCODING_INVALID_ENCODED_DATA, TypeError) \ V(ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE, Error) \ + V(ERR_FS_CP_EINVAL, Error) \ + V(ERR_FS_CP_DIR_TO_NON_DIR, Error) \ + V(ERR_FS_CP_NON_DIR_TO_DIR, Error) \ + V(ERR_FS_EISDIR, Error) \ + V(ERR_FS_CP_SOCKET, Error) \ + V(ERR_FS_CP_FIFO_PIPE, Error) \ + V(ERR_FS_CP_UNKNOWN, Error) \ V(ERR_ILLEGAL_CONSTRUCTOR, Error) \ V(ERR_INVALID_ADDRESS, Error) \ V(ERR_INVALID_ARG_VALUE, TypeError) \ diff --git a/src/node_file-inl.h b/src/node_file-inl.h index 6c059add3bfc02..36c2f8067c6e49 100644 --- a/src/node_file-inl.h +++ b/src/node_file-inl.h @@ -221,9 +221,15 @@ void FSReqPromise::Reject(v8::Local reject) { finished_ = true; v8::HandleScope scope(env()->isolate()); InternalCallbackScope callback_scope(this); - v8::Local value = - object()->Get(env()->context(), - env()->promise_string()).ToLocalChecked(); + v8::Local value; + if (!object() + ->Get(env()->context(), env()->promise_string()) + .ToLocal(&value)) { + // If we hit this, getting the value from the object failed and + // an error was likely scheduled. We could try to reject the promise + // but let's just allow the error to propagate. + return; + } v8::Local resolver = value.As(); USE(resolver->Reject(env()->context(), reject).FromJust()); } @@ -233,9 +239,13 @@ void FSReqPromise::Resolve(v8::Local value) { finished_ = true; v8::HandleScope scope(env()->isolate()); InternalCallbackScope callback_scope(this); - v8::Local val = - object()->Get(env()->context(), - env()->promise_string()).ToLocalChecked(); + v8::Local val; + if (!object()->Get(env()->context(), env()->promise_string()).ToLocal(&val)) { + // If we hit this, getting the value from the object failed and + // an error was likely scheduled. We could try to reject the promise + // but let's just allow the error to propagate. + return; + } v8::Local resolver = val.As(); USE(resolver->Resolve(env()->context(), value).FromJust()); } @@ -255,9 +265,13 @@ void FSReqPromise::ResolveStatFs(const uv_statfs_t* stat) { template void FSReqPromise::SetReturnValue( const v8::FunctionCallbackInfo& args) { - v8::Local val = - object()->Get(env()->context(), - env()->promise_string()).ToLocalChecked(); + v8::Local val; + if (!object()->Get(env()->context(), env()->promise_string()).ToLocal(&val)) { + // If we hit this, getting the value from the object failed and + // an error was likely scheduled. We could try to reject the promise + // but let's just allow the error to propagate. + return; + } v8::Local resolver = val.As(); args.GetReturnValue().Set(resolver->GetPromise()); } diff --git a/src/node_file.cc b/src/node_file.cc index c59235b51cca9f..c13c364665f4bc 100644 --- a/src/node_file.cc +++ b/src/node_file.cc @@ -437,7 +437,8 @@ MaybeLocal FileHandle::ClosePromise() { auto maybe_resolver = Promise::Resolver::New(context); CHECK(!maybe_resolver.IsEmpty()); - Local resolver = maybe_resolver.ToLocalChecked(); + Local resolver; + if (!maybe_resolver.ToLocal(&resolver)) return {}; Local promise = resolver.As(); Local close_req_obj; @@ -844,10 +845,12 @@ void AfterStringPath(uv_fs_t* req) { req->path, req_wrap->encoding(), &error); - if (link.IsEmpty()) + if (link.IsEmpty()) { req_wrap->Reject(error); - else - req_wrap->Resolve(link.ToLocalChecked()); + } else { + Local val; + if (link.ToLocal(&val)) req_wrap->Resolve(val); + } } } @@ -864,10 +867,12 @@ void AfterStringPtr(uv_fs_t* req) { static_cast(req->ptr), req_wrap->encoding(), &error); - if (link.IsEmpty()) + if (link.IsEmpty()) { req_wrap->Reject(error); - else - req_wrap->Resolve(link.ToLocalChecked()); + } else { + Local val; + if (link.ToLocal(&val)) req_wrap->Resolve(val); + } } } @@ -2237,7 +2242,8 @@ static void WriteBuffers(const FunctionCallbackInfo& args) { MaybeStackBuffer iovs(chunks->Length()); for (uint32_t i = 0; i < iovs.length(); i++) { - Local chunk = chunks->Get(env->context(), i).ToLocalChecked(); + Local chunk; + if (!chunks->Get(env->context(), i).ToLocal(&chunk)) return; CHECK(Buffer::HasInstance(chunk)); iovs[i] = uv_buf_init(Buffer::Data(chunk), Buffer::Length(chunk)); } @@ -2577,8 +2583,12 @@ static void ReadFileUtf8(const FunctionCallbackInfo& args) { } FS_SYNC_TRACE_END(read); - args.GetReturnValue().Set( - ToV8Value(env->context(), result, isolate).ToLocalChecked()); + Local val; + if (!ToV8Value(env->context(), result, isolate).ToLocal(&val)) { + return; + } + + args.GetReturnValue().Set(val); } // Wrapper for readv(2). @@ -2606,7 +2616,8 @@ static void ReadBuffers(const FunctionCallbackInfo& args) { // Init uv buffers from ArrayBufferViews for (uint32_t i = 0; i < iovs.length(); i++) { - Local buffer = buffers->Get(env->context(), i).ToLocalChecked(); + Local buffer; + if (!buffers->Get(env->context(), i).ToLocal(&buffer)) return; CHECK(Buffer::HasInstance(buffer)); iovs[i] = uv_buf_init(Buffer::Data(buffer), Buffer::Length(buffer)); } @@ -3005,6 +3016,130 @@ static void GetFormatOfExtensionlessFile( return args.GetReturnValue().Set(EXTENSIONLESS_FORMAT_JAVASCRIPT); } +static void CpSyncCheckPaths(const FunctionCallbackInfo& args) { + Environment* env = Environment::GetCurrent(args); + Isolate* isolate = env->isolate(); + + CHECK_EQ(args.Length(), 4); // src, dest, dereference, recursive + + BufferValue src(isolate, args[0]); + CHECK_NOT_NULL(*src); + ToNamespacedPath(env, &src); + THROW_IF_INSUFFICIENT_PERMISSIONS( + env, permission::PermissionScope::kFileSystemRead, src.ToStringView()); + auto src_path = std::filesystem::path(src.ToStringView()); + + BufferValue dest(isolate, args[1]); + CHECK_NOT_NULL(*dest); + ToNamespacedPath(env, &dest); + THROW_IF_INSUFFICIENT_PERMISSIONS( + env, permission::PermissionScope::kFileSystemWrite, dest.ToStringView()); + auto dest_path = std::filesystem::path(dest.ToStringView()); + + bool dereference = args[2]->IsTrue(); + bool recursive = args[3]->IsTrue(); + + std::error_code error_code; + auto src_status = dereference + ? std::filesystem::symlink_status(src_path, error_code) + : std::filesystem::status(src_path, error_code); + if (error_code) { + return env->ThrowUVException(EEXIST, "lstat", nullptr, src.out()); + } + auto dest_status = + dereference ? std::filesystem::symlink_status(dest_path, error_code) + : std::filesystem::status(dest_path, error_code); + + bool dest_exists = !error_code && dest_status.type() != + std::filesystem::file_type::not_found; + bool src_is_dir = src_status.type() == std::filesystem::file_type::directory; + + if (!error_code) { + // Check if src and dest are identical. + if (std::filesystem::equivalent(src_path, dest_path)) { + std::string message = + "src and dest cannot be the same " + dest_path.string(); + return THROW_ERR_FS_CP_EINVAL(env, message.c_str()); + } + + const bool dest_is_dir = + dest_status.type() == std::filesystem::file_type::directory; + + if (src_is_dir && !dest_is_dir) { + std::string message = "Cannot overwrite non-directory " + + src_path.string() + " with directory " + + dest_path.string(); + return THROW_ERR_FS_CP_DIR_TO_NON_DIR(env, message.c_str()); + } + + if (!src_is_dir && dest_is_dir) { + std::string message = "Cannot overwrite directory " + dest_path.string() + + " with non-directory " + src_path.string(); + return THROW_ERR_FS_CP_NON_DIR_TO_DIR(env, message.c_str()); + } + } + + std::string dest_path_str = dest_path.string(); + // Check if dest_path is a subdirectory of src_path. + if (src_is_dir && dest_path_str.starts_with(src_path.string())) { + std::string message = "Cannot copy " + src_path.string() + + " to a subdirectory of self " + dest_path.string(); + return THROW_ERR_FS_CP_EINVAL(env, message.c_str()); + } + + auto dest_parent = dest_path.parent_path(); + // "/" parent is itself. Therefore, we need to check if the parent is the same + // as itself. + while (src_path.parent_path() != dest_parent && + dest_parent.has_parent_path() && + dest_parent.parent_path() != dest_parent) { + if (std::filesystem::equivalent( + src_path, dest_path.parent_path(), error_code)) { + std::string message = "Cannot copy " + src_path.string() + + " to a subdirectory of self " + dest_path.string(); + return THROW_ERR_FS_CP_EINVAL(env, message.c_str()); + } + + // If equivalent fails, it's highly likely that dest_parent does not exist + if (error_code) { + break; + } + + dest_parent = dest_parent.parent_path(); + } + + if (src_is_dir && !recursive) { + std::string message = + "Recursive option not enabled, cannot copy a directory: " + + src_path.string(); + return THROW_ERR_FS_EISDIR(env, message.c_str()); + } + + switch (src_status.type()) { + case std::filesystem::file_type::socket: { + std::string message = "Cannot copy a socket file: " + dest_path.string(); + return THROW_ERR_FS_CP_SOCKET(env, message.c_str()); + } + case std::filesystem::file_type::fifo: { + std::string message = "Cannot copy a FIFO pipe: " + dest_path.string(); + return THROW_ERR_FS_CP_FIFO_PIPE(env, message.c_str()); + } + case std::filesystem::file_type::unknown: { + std::string message = + "Cannot copy an unknown file type: " + dest_path.string(); + return THROW_ERR_FS_CP_UNKNOWN(env, message.c_str()); + } + default: + break; + } + + // Optimization opportunity: Check if this "exists" call is good for + // performance. + if (!dest_exists || !std::filesystem::exists(dest_path.parent_path())) { + std::filesystem::create_directories(dest_path.parent_path(), error_code); + } +} + BindingData::FilePathIsFileReturnType BindingData::FilePathIsFile( Environment* env, const std::string& file_path) { THROW_IF_INSUFFICIENT_PERMISSIONS( @@ -3072,6 +3207,8 @@ void BindingData::LegacyMainResolve(const FunctionCallbackInfo& args) { return; } + std::string package_initial_file = ""; + ada::result file_path_url; std::optional initial_file_path; std::string file_path; @@ -3094,6 +3231,8 @@ void BindingData::LegacyMainResolve(const FunctionCallbackInfo& args) { FromNamespacedPath(&initial_file_path.value()); + package_initial_file = *initial_file_path; + for (int i = 0; i < legacy_main_extensions_with_main_end; i++) { file_path = *initial_file_path + std::string(legacy_main_extensions[i]); @@ -3149,13 +3288,10 @@ void BindingData::LegacyMainResolve(const FunctionCallbackInfo& args) { } } - std::optional module_path = - node::url::FileURLToPath(env, *package_json_url); - std::optional module_base; + if (package_initial_file == "") + package_initial_file = *initial_file_path + ".js"; - if (!module_path.has_value()) { - return; - } + std::optional module_base; if (args.Length() >= 3 && args[2]->IsString()) { Utf8Value utf8_base_path(isolate, args[2]); @@ -3180,7 +3316,7 @@ void BindingData::LegacyMainResolve(const FunctionCallbackInfo& args) { THROW_ERR_MODULE_NOT_FOUND(isolate, "Cannot find package '%s' imported from %s", - *module_path, + package_initial_file, *module_base); } @@ -3352,6 +3488,8 @@ static void CreatePerIsolateProperties(IsolateData* isolate_data, SetMethod(isolate, target, "mkdtemp", Mkdtemp); + SetMethod(isolate, target, "cpSyncCheckPaths", CpSyncCheckPaths); + StatWatcher::CreatePerIsolateProperties(isolate_data, target); BindingData::CreatePerIsolateProperties(isolate_data, target); @@ -3461,6 +3599,8 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) { registry->Register(RealPath); registry->Register(CopyFile); + registry->Register(CpSyncCheckPaths); + registry->Register(Chmod); registry->Register(FChmod); diff --git a/src/node_http2.cc b/src/node_http2.cc index 50636d24763078..a07d3ce40d9ac8 100644 --- a/src/node_http2.cc +++ b/src/node_http2.cc @@ -1652,11 +1652,12 @@ void Http2Session::HandleSettingsFrame(const nghttp2_frame* frame) { int32_t settings_id = iv[i].settings_id; if (settings_id >= IDX_SETTINGS_COUNT) { // unsupported, additional settings + auto iv_value = iv[i].value; for (size_t j = 0; j < numsettings; ++j) { if ((remote_custom_settings_.entries[j].settings_id & 0xFFFF) == settings_id) { remote_custom_settings_.entries[j].settings_id = settings_id; - remote_custom_settings_.entries[j].value = iv[i].value; + remote_custom_settings_.entries[j].value = iv_value; break; } } diff --git a/src/node_metadata.cc b/src/node_metadata.cc index 56d99f529f7a93..823a548e87219e 100644 --- a/src/node_metadata.cc +++ b/src/node_metadata.cc @@ -1,6 +1,7 @@ #include "node_metadata.h" #include "acorn_version.h" #include "ada.h" +#include "amaro_version.h" #include "ares.h" #include "brotli/encode.h" #include "cjs_module_lexer_version.h" @@ -25,12 +26,13 @@ #if HAVE_OPENSSL #include +#include "ncrypto.h" #if NODE_OPENSSL_HAS_QUIC #include #endif #endif // HAVE_OPENSSL -#ifdef OPENSSL_INFO_QUIC +#ifdef NODE_OPENSSL_HAS_QUIC #include #include #endif @@ -115,9 +117,11 @@ Metadata::Versions::Versions() { acorn = ACORN_VERSION; cjs_module_lexer = CJS_MODULE_LEXER_VERSION; uvwasi = UVWASI_VERSION_STRING; + amaro = AMARO_VERSION; #if HAVE_OPENSSL openssl = GetOpenSSLVersion(); + ncrypto = NCRYPTO_VERSION; #endif #ifdef NODE_HAVE_I18N_SUPPORT @@ -125,7 +129,7 @@ Metadata::Versions::Versions() { unicode = U_UNICODE_VERSION; #endif // NODE_HAVE_I18N_SUPPORT -#ifdef OPENSSL_INFO_QUIC +#ifdef NODE_OPENSSL_HAS_QUIC ngtcp2 = NGTCP2_VERSION; nghttp3 = NGHTTP3_VERSION; #endif diff --git a/src/node_metadata.h b/src/node_metadata.h index 90c7dbf22c8e85..5502c9696cc474 100644 --- a/src/node_metadata.h +++ b/src/node_metadata.h @@ -51,11 +51,12 @@ namespace node { V(sqlite) \ V(ada) \ V(nbytes) \ + V(amaro) \ NODE_VERSIONS_KEY_UNDICI(V) \ V(cjs_module_lexer) #if HAVE_OPENSSL -#define NODE_VERSIONS_KEY_CRYPTO(V) V(openssl) +#define NODE_VERSIONS_KEY_CRYPTO(V) V(openssl) V(ncrypto) #else #define NODE_VERSIONS_KEY_CRYPTO(V) #endif diff --git a/src/node_options.cc b/src/node_options.cc index 8557cbac2ae1a3..b288dfe2a81edf 100644 --- a/src/node_options.cc +++ b/src/node_options.cc @@ -447,10 +447,6 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() { kAllowedInEnvvar); AddAlias("--loader", "--experimental-loader"); AddOption("--experimental-modules", "", NoOp{}, kAllowedInEnvvar); - AddOption("--experimental-network-imports", - "experimental https: support for the ES Module loader", - &EnvironmentOptions::experimental_https_modules, - kAllowedInEnvvar); AddOption("--experimental-wasm-modules", "experimental ES Module support for webassembly modules", &EnvironmentOptions::experimental_wasm_modules, @@ -607,6 +603,9 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() { "Directory where the V8 profiles generated by --cpu-prof will be " "placed. Does not affect --prof.", &EnvironmentOptions::cpu_prof_dir); + AddOption("--experimental-network-inspection", + "experimental network inspection support", + &EnvironmentOptions::experimental_network_inspection); AddOption( "--heap-prof", "Start the V8 heap profiler on start up, and write the heap profile " @@ -797,6 +796,11 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() { "ES module to preload (option can be repeated)", &EnvironmentOptions::preload_esm_modules, kAllowedInEnvvar); + AddOption("--experimental-strip-types", + "Experimental type-stripping for TypeScript files.", + &EnvironmentOptions::experimental_strip_types, + kAllowedInEnvvar); + Implies("--experimental-strip-types", "--experimental-detect-module"); AddOption("--interactive", "always enter the REPL even if stdin does not appear " "to be a terminal", diff --git a/src/node_options.h b/src/node_options.h index b8a2f6b6dd21d8..4225ef85fddac5 100644 --- a/src/node_options.h +++ b/src/node_options.h @@ -124,7 +124,6 @@ class EnvironmentOptions : public Options { bool experimental_global_customevent = true; bool experimental_global_navigator = true; bool experimental_global_web_crypto = true; - bool experimental_https_modules = false; bool experimental_wasm_modules = false; bool experimental_import_meta_resolve = false; std::string input_type; // Value of --input-type @@ -163,6 +162,7 @@ class EnvironmentOptions : public Options { uint64_t cpu_prof_interval = kDefaultCpuProfInterval; std::string cpu_prof_name; bool cpu_prof = false; + bool experimental_network_inspection = false; std::string heap_prof_dir; std::string heap_prof_name; static const uint64_t kDefaultHeapProfInterval = 512 * 1024; @@ -234,6 +234,8 @@ class EnvironmentOptions : public Options { std::vector preload_esm_modules; + bool experimental_strip_types = false; + std::vector user_argv; bool report_exclude_network = false; diff --git a/src/node_sqlite.cc b/src/node_sqlite.cc index cb7855a2ad1707..1d94363bf08907 100644 --- a/src/node_sqlite.cc +++ b/src/node_sqlite.cc @@ -370,12 +370,21 @@ bool StatementSync::BindValue(const Local& value, const int index) { Local StatementSync::ColumnToValue(const int column) { switch (sqlite3_column_type(statement_, column)) { - case SQLITE_INTEGER: + case SQLITE_INTEGER: { + sqlite3_int64 value = sqlite3_column_int64(statement_, column); if (use_big_ints_) { - return BigInt::New(env()->isolate(), - sqlite3_column_int64(statement_, column)); + return BigInt::New(env()->isolate(), value); + } else if (std::abs(value) <= kMaxSafeJsInteger) { + return Number::New(env()->isolate(), value); + } else { + THROW_ERR_OUT_OF_RANGE(env()->isolate(), + "The value of column %d is too large to be " + "represented as a JavaScript number: %" PRId64, + column, + value); + return Local(); } - // Fall through. + } case SQLITE_FLOAT: return Number::New(env()->isolate(), sqlite3_column_double(statement_, column)); @@ -441,7 +450,9 @@ void StatementSync::All(const FunctionCallbackInfo& args) { for (int i = 0; i < num_cols; ++i) { Local key = stmt->ColumnNameToValue(i); + if (key.IsEmpty()) return; Local val = stmt->ColumnToValue(i); + if (val.IsEmpty()) return; if (row->Set(env->context(), key, val).IsNothing()) { return; @@ -469,7 +480,8 @@ void StatementSync::Get(const FunctionCallbackInfo& args) { auto reset = OnScopeLeave([&]() { sqlite3_reset(stmt->statement_); }); r = sqlite3_step(stmt->statement_); - if (r != SQLITE_ROW && r != SQLITE_DONE) { + if (r == SQLITE_DONE) return; + if (r != SQLITE_ROW) { THROW_ERR_SQLITE_ERROR(env->isolate(), stmt->db_); return; } @@ -483,7 +495,9 @@ void StatementSync::Get(const FunctionCallbackInfo& args) { for (int i = 0; i < num_cols; ++i) { Local key = stmt->ColumnNameToValue(i); + if (key.IsEmpty()) return; Local val = stmt->ColumnToValue(i); + if (val.IsEmpty()) return; if (result->Set(env->context(), key, val).IsNothing()) { return; diff --git a/src/node_trace_events.cc b/src/node_trace_events.cc index a0f8f4de67dabb..9787b14352753c 100644 --- a/src/node_trace_events.cc +++ b/src/node_trace_events.cc @@ -16,6 +16,8 @@ namespace node { class ExternalReferenceRegistry; using v8::Array; +using v8::ArrayBuffer; +using v8::BackingStore; using v8::Context; using v8::Function; using v8::FunctionCallbackInfo; @@ -25,6 +27,7 @@ using v8::Local; using v8::NewStringType; using v8::Object; using v8::String; +using v8::Uint8Array; using v8::Value; class NodeCategorySet : public BaseObject { @@ -120,6 +123,27 @@ static void SetTraceCategoryStateUpdateHandler( env->set_trace_category_state_function(args[0].As()); } +static void GetCategoryEnabledBuffer(const FunctionCallbackInfo& args) { + CHECK(args[0]->IsString()); + + Isolate* isolate = args.GetIsolate(); + node::Utf8Value category_name(isolate, args[0]); + + const uint8_t* enabled_pointer = + TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category_name.out()); + uint8_t* enabled_pointer_cast = const_cast(enabled_pointer); + + std::unique_ptr bs = ArrayBuffer::NewBackingStore( + enabled_pointer_cast, + sizeof(*enabled_pointer_cast), + [](void*, size_t, void*) {}, + nullptr); + auto ab = ArrayBuffer::New(isolate, std::move(bs)); + v8::Local u8 = v8::Uint8Array::New(ab, 0, 1); + + args.GetReturnValue().Set(u8); +} + void NodeCategorySet::Initialize(Local target, Local unused, Local context, @@ -132,6 +156,8 @@ void NodeCategorySet::Initialize(Local target, target, "setTraceCategoryStateUpdateHandler", SetTraceCategoryStateUpdateHandler); + SetMethod( + context, target, "getCategoryEnabledBuffer", GetCategoryEnabledBuffer); Local category_set = NewFunctionTemplate(isolate, NodeCategorySet::New); @@ -160,6 +186,7 @@ void NodeCategorySet::RegisterExternalReferences( ExternalReferenceRegistry* registry) { registry->Register(GetEnabledCategories); registry->Register(SetTraceCategoryStateUpdateHandler); + registry->Register(GetCategoryEnabledBuffer); registry->Register(NodeCategorySet::New); registry->Register(NodeCategorySet::Enable); registry->Register(NodeCategorySet::Disable); diff --git a/src/node_version.h b/src/node_version.h index 9ddda54d1cd91b..499171daaf993f 100644 --- a/src/node_version.h +++ b/src/node_version.h @@ -23,13 +23,13 @@ #define SRC_NODE_VERSION_H_ #define NODE_MAJOR_VERSION 22 -#define NODE_MINOR_VERSION 5 -#define NODE_PATCH_VERSION 2 +#define NODE_MINOR_VERSION 6 +#define NODE_PATCH_VERSION 0 #define NODE_VERSION_IS_LTS 0 #define NODE_VERSION_LTS_CODENAME "" -#define NODE_VERSION_IS_RELEASE 0 +#define NODE_VERSION_IS_RELEASE 1 #ifndef NODE_STRINGIFY #define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n) diff --git a/src/node_webstorage.cc b/src/node_webstorage.cc index 798a07c5b7a5b6..15d142e3d8f6e6 100644 --- a/src/node_webstorage.cc +++ b/src/node_webstorage.cc @@ -6,6 +6,7 @@ #include "node.h" #include "node_errors.h" #include "node_mem-inl.h" +#include "path.h" #include "sqlite3.h" #include "util-inl.h" @@ -29,7 +30,6 @@ using v8::Maybe; using v8::MaybeLocal; using v8::Name; using v8::NamedPropertyHandlerConfiguration; -using v8::Null; using v8::Object; using v8::PropertyAttribute; using v8::PropertyCallbackInfo; @@ -40,7 +40,7 @@ using v8::Uint32; using v8::Value; #define THROW_SQLITE_ERROR(env, r) \ - node::THROW_ERR_INVALID_STATE((env), sqlite3_errstr((r))) + THROW_ERR_INVALID_STATE((env), sqlite3_errstr((r))) #define CHECK_ERROR_OR_THROW(env, expr, expected, ret) \ do { \ @@ -77,13 +77,14 @@ static void ThrowQuotaExceededException(Local context) { isolate->ThrowException(exception); } -Storage::Storage(Environment* env, Local object, Local location) +Storage::Storage(Environment* env, + Local object, + std::string_view location) : BaseObject(env, object) { MakeWeak(); - node::Utf8Value utf8_location(env->isolate(), location); symbols_.Reset(env->isolate(), Map::New(env->isolate())); db_ = nullptr; - location_ = utf8_location.ToString(); + location_ = std::string(location); } Storage::~Storage() { @@ -97,9 +98,9 @@ void Storage::MemoryInfo(MemoryTracker* tracker) const { bool Storage::Open() { static const int kCurrentSchemaVersion = 1; - static const char get_schema_version_sql[] = + static constexpr std::string_view get_schema_version_sql = "SELECT schema_version FROM nodejs_webstorage_state"; - static const char init_sql_v0[] = + static constexpr std::string_view init_sql_v0 = "PRAGMA encoding = 'UTF-16le';" "PRAGMA busy_timeout = 3000;" "PRAGMA journal_mode = WAL;" @@ -165,13 +166,14 @@ bool Storage::Open() { int r = sqlite3_open(location_.c_str(), &db); CHECK_ERROR_OR_THROW(env(), r, SQLITE_OK, false); - r = sqlite3_exec(db, init_sql_v0, 0, 0, nullptr); + r = sqlite3_exec(db, init_sql_v0.data(), 0, 0, nullptr); CHECK_ERROR_OR_THROW(env(), r, SQLITE_OK, false); // Get the current schema version, used to determine schema migrations. sqlite3_stmt* s = nullptr; - r = sqlite3_prepare_v2(db, get_schema_version_sql, -1, &s, 0); - r = sqlite3_exec(db, init_sql_v0, 0, 0, nullptr); + r = sqlite3_prepare_v2( + db, get_schema_version_sql.data(), get_schema_version_sql.size(), &s, 0); + r = sqlite3_exec(db, init_sql_v0.data(), 0, 0, nullptr); CHECK_ERROR_OR_THROW(env(), r, SQLITE_OK, false); auto stmt = stmt_unique_ptr(s); CHECK_ERROR_OR_THROW(env(), sqlite3_step(stmt.get()), SQLITE_ROW, false); @@ -180,7 +182,7 @@ bool Storage::Open() { stmt = nullptr; // Force finalization. if (schema_version > kCurrentSchemaVersion) { - node::THROW_ERR_INVALID_STATE( + THROW_ERR_INVALID_STATE( env(), "localStorage was created with a newer version of Node.js"); return false; } @@ -209,7 +211,15 @@ void Storage::New(const FunctionCallbackInfo& args) { CHECK(args.IsConstructCall()); CHECK(args[1]->IsString()); - new Storage(env, args.This(), args[1].As()); + + BufferValue location(env->isolate(), args[1]); + CHECK_NOT_NULL(*location); + // Only call namespaced path if the location is not "in memory". + if (location.ToStringView() != kInMemoryPath) { + ToNamespacedPath(env, &location); + } + + new Storage(env, args.This(), location.ToStringView()); } void Storage::Clear() { @@ -217,10 +227,13 @@ void Storage::Clear() { return; } - static const char sql[] = "DELETE FROM nodejs_webstorage"; + static constexpr std::string_view sql = "DELETE FROM nodejs_webstorage"; sqlite3_stmt* s = nullptr; CHECK_ERROR_OR_THROW( - env(), sqlite3_prepare_v2(db_.get(), sql, -1, &s, 0), SQLITE_OK, void()); + env(), + sqlite3_prepare_v2(db_.get(), sql.data(), sql.size(), &s, 0), + SQLITE_OK, + void()); auto stmt = stmt_unique_ptr(s); CHECK_ERROR_OR_THROW(env(), sqlite3_step(stmt.get()), SQLITE_DONE, void()); } @@ -230,22 +243,25 @@ Local Storage::Enumerate() { return Local(); } - static const char sql[] = "SELECT key FROM nodejs_webstorage"; + static constexpr std::string_view sql = "SELECT key FROM nodejs_webstorage"; sqlite3_stmt* s = nullptr; - int r = sqlite3_prepare_v2(db_.get(), sql, -1, &s, 0); + int r = sqlite3_prepare_v2(db_.get(), sql.data(), sql.size(), &s, 0); CHECK_ERROR_OR_THROW(env(), r, SQLITE_OK, Local()); auto stmt = stmt_unique_ptr(s); std::vector> values; + Local value; while ((r = sqlite3_step(stmt.get())) == SQLITE_ROW) { CHECK(sqlite3_column_type(stmt.get(), 0) == SQLITE_BLOB); auto size = sqlite3_column_bytes(stmt.get(), 0) / sizeof(uint16_t); - values.emplace_back( - String::NewFromTwoByte(env()->isolate(), - reinterpret_cast( - sqlite3_column_blob(stmt.get(), 0)), - v8::NewStringType::kNormal, - size) - .ToLocalChecked()); + if (!String::NewFromTwoByte(env()->isolate(), + reinterpret_cast( + sqlite3_column_blob(stmt.get(), 0)), + v8::NewStringType::kNormal, + size) + .ToLocal(&value)) { + return Local(); + } + values.emplace_back(value); } CHECK_ERROR_OR_THROW(env(), r, SQLITE_DONE, Local()); return Array::New(env()->isolate(), values.data(), values.size()); @@ -253,12 +269,13 @@ Local Storage::Enumerate() { Local Storage::Length() { if (!Open()) { - return Local(); + return {}; } - static const char sql[] = "SELECT count(*) FROM nodejs_webstorage"; + static constexpr std::string_view sql = + "SELECT count(*) FROM nodejs_webstorage"; sqlite3_stmt* s = nullptr; - int r = sqlite3_prepare_v2(db_.get(), sql, -1, &s, 0); + int r = sqlite3_prepare_v2(db_.get(), sql.data(), sql.size(), &s, 0); CHECK_ERROR_OR_THROW(env(), r, SQLITE_OK, Local()); auto stmt = stmt_unique_ptr(s); CHECK_ERROR_OR_THROW( @@ -276,16 +293,16 @@ Local Storage::Load(Local key) { } if (!Open()) { - return Local(); + return {}; } - static const char sql[] = + static constexpr std::string_view sql = "SELECT value FROM nodejs_webstorage WHERE key = ? LIMIT 1"; sqlite3_stmt* s = nullptr; - int r = sqlite3_prepare_v2(db_.get(), sql, -1, &s, 0); + int r = sqlite3_prepare_v2(db_.get(), sql.data(), sql.size(), &s, 0); CHECK_ERROR_OR_THROW(env(), r, SQLITE_OK, Local()); auto stmt = stmt_unique_ptr(s); - node::TwoByteValue utf16key(env()->isolate(), key); + TwoByteValue utf16key(env()->isolate(), key); auto key_size = utf16key.length() * sizeof(uint16_t); r = sqlite3_bind_blob(stmt.get(), 1, utf16key.out(), key_size, SQLITE_STATIC); CHECK_ERROR_OR_THROW(env(), r, SQLITE_OK, Local()); @@ -294,12 +311,14 @@ Local Storage::Load(Local key) { if (r == SQLITE_ROW) { CHECK(sqlite3_column_type(stmt.get(), 0) == SQLITE_BLOB); auto size = sqlite3_column_bytes(stmt.get(), 0) / sizeof(uint16_t); - value = String::NewFromTwoByte(env()->isolate(), - reinterpret_cast( - sqlite3_column_blob(stmt.get(), 0)), - v8::NewStringType::kNormal, - size) - .ToLocalChecked(); + if (!String::NewFromTwoByte(env()->isolate(), + reinterpret_cast( + sqlite3_column_blob(stmt.get(), 0)), + v8::NewStringType::kNormal, + size) + .ToLocal(&value)) { + return {}; + } } else if (r != SQLITE_DONE) { THROW_SQLITE_ERROR(env(), r); } @@ -309,13 +328,13 @@ Local Storage::Load(Local key) { Local Storage::LoadKey(const int index) { if (!Open()) { - return Local(); + return {}; } - static const char sql[] = + static constexpr std::string_view sql = "SELECT key FROM nodejs_webstorage LIMIT 1 OFFSET ?"; sqlite3_stmt* s = nullptr; - int r = sqlite3_prepare_v2(db_.get(), sql, -1, &s, 0); + int r = sqlite3_prepare_v2(db_.get(), sql.data(), sql.size(), &s, 0); CHECK_ERROR_OR_THROW(env(), r, SQLITE_OK, Local()); auto stmt = stmt_unique_ptr(s); r = sqlite3_bind_int(stmt.get(), 1, index); @@ -326,12 +345,14 @@ Local Storage::LoadKey(const int index) { if (r == SQLITE_ROW) { CHECK(sqlite3_column_type(stmt.get(), 0) == SQLITE_BLOB); auto size = sqlite3_column_bytes(stmt.get(), 0) / sizeof(uint16_t); - value = String::NewFromTwoByte(env()->isolate(), - reinterpret_cast( - sqlite3_column_blob(stmt.get(), 0)), - v8::NewStringType::kNormal, - size) - .ToLocalChecked(); + if (!String::NewFromTwoByte(env()->isolate(), + reinterpret_cast( + sqlite3_column_blob(stmt.get(), 0)), + v8::NewStringType::kNormal, + size) + .ToLocal(&value)) { + return {}; + } } else if (r != SQLITE_DONE) { THROW_SQLITE_ERROR(env(), r); } @@ -350,12 +371,13 @@ bool Storage::Remove(Local key) { return false; } - static const char sql[] = "DELETE FROM nodejs_webstorage WHERE key = ?"; + static constexpr std::string_view sql = + "DELETE FROM nodejs_webstorage WHERE key = ?"; sqlite3_stmt* s = nullptr; - int r = sqlite3_prepare_v2(db_.get(), sql, -1, &s, 0); + int r = sqlite3_prepare_v2(db_.get(), sql.data(), sql.size(), &s, 0); CHECK_ERROR_OR_THROW(env(), r, SQLITE_OK, false); auto stmt = stmt_unique_ptr(s); - node::TwoByteValue utf16key(env()->isolate(), key); + TwoByteValue utf16key(env()->isolate(), key); auto key_size = utf16key.length() * sizeof(uint16_t); r = sqlite3_bind_blob(stmt.get(), 1, utf16key.out(), key_size, SQLITE_STATIC); CHECK_ERROR_OR_THROW(env(), r, SQLITE_OK, false); @@ -379,14 +401,14 @@ bool Storage::Store(Local key, Local value) { return false; } - static const char sql[] = + static constexpr std::string_view sql = "INSERT INTO nodejs_webstorage (key, value) VALUES (?, ?)" " ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value" " WHERE EXCLUDED.key = key"; sqlite3_stmt* s = nullptr; - node::TwoByteValue utf16key(env()->isolate(), key); - node::TwoByteValue utf16val(env()->isolate(), val); - int r = sqlite3_prepare_v2(db_.get(), sql, -1, &s, 0); + TwoByteValue utf16key(env()->isolate(), key); + TwoByteValue utf16val(env()->isolate(), val); + int r = sqlite3_prepare_v2(db_.get(), sql.data(), sql.size(), &s, 0); CHECK_ERROR_OR_THROW(env(), r, SQLITE_OK, false); auto stmt = stmt_unique_ptr(s); auto key_size = utf16key.length() * sizeof(uint16_t); @@ -406,10 +428,8 @@ bool Storage::Store(Local key, Local value) { return true; } -static Local Uint32ToName(Local context, uint32_t index) { - return Uint32::New(context->GetIsolate(), index) - ->ToString(context) - .ToLocalChecked(); +static MaybeLocal Uint32ToName(Local context, uint32_t index) { + return Uint32::New(context->GetIsolate(), index)->ToString(context); } static void Clear(const FunctionCallbackInfo& info) { @@ -435,7 +455,7 @@ static void GetItem(const FunctionCallbackInfo& info) { Local result = storage->Load(prop); if (result.IsEmpty()) { - info.GetReturnValue().Set(Null(env->isolate())); + info.GetReturnValue().SetNull(); } else { info.GetReturnValue().Set(result); } @@ -457,13 +477,13 @@ static void Key(const FunctionCallbackInfo& info) { } if (index < 0) { - info.GetReturnValue().Set(Null(env->isolate())); + info.GetReturnValue().SetNull(); return; } Local result = storage->LoadKey(index); if (result.IsEmpty()) { - info.GetReturnValue().Set(Null(env->isolate())); + info.GetReturnValue().SetNull(); } else { info.GetReturnValue().Set(result); } @@ -610,33 +630,68 @@ static Intercepted StorageDefiner(Local property, static Intercepted IndexedGetter(uint32_t index, const PropertyCallbackInfo& info) { Environment* env = Environment::GetCurrent(info); - return StorageGetter(Uint32ToName(env->context(), index), info); + Local name; + if (!Uint32ToName(env->context(), index).ToLocal(&name)) { + // There was an error converting the index to a name. + // We aren't going to return a result but let's indicate + // that we intercepted the operation. + return Intercepted::kYes; + } + return StorageGetter(name, info); } static Intercepted IndexedSetter(uint32_t index, Local value, const PropertyCallbackInfo& info) { Environment* env = Environment::GetCurrent(info); - return StorageSetter(Uint32ToName(env->context(), index), value, info); + Local name; + if (!Uint32ToName(env->context(), index).ToLocal(&name)) { + // There was an error converting the index to a name. + // We aren't going to return a result but let's indicate + // that we intercepted the operation. + return Intercepted::kYes; + } + return StorageSetter(name, value, info); } static Intercepted IndexedQuery(uint32_t index, const PropertyCallbackInfo& info) { Environment* env = Environment::GetCurrent(info); - return StorageQuery(Uint32ToName(env->context(), index), info); + Local name; + if (!Uint32ToName(env->context(), index).ToLocal(&name)) { + // There was an error converting the index to a name. + // We aren't going to return a result but let's indicate + // that we intercepted the operation. + return Intercepted::kYes; + } + return StorageQuery(name, info); } static Intercepted IndexedDeleter(uint32_t index, const PropertyCallbackInfo& info) { Environment* env = Environment::GetCurrent(info); - return StorageDeleter(Uint32ToName(env->context(), index), info); + Local name; + if (!Uint32ToName(env->context(), index).ToLocal(&name)) { + // There was an error converting the index to a name. + // We aren't going to return a result but let's indicate + // that we intercepted the operation. + return Intercepted::kYes; + } + return StorageDeleter(name, info); } static Intercepted IndexedDefiner(uint32_t index, const PropertyDescriptor& desc, const PropertyCallbackInfo& info) { Environment* env = Environment::GetCurrent(info); - return StorageDefiner(Uint32ToName(env->context(), index), desc, info); + Local name; + if (!Uint32ToName(env->context(), index).ToLocal(&name)) { + // There was an error converting the index to a name. + // We aren't going to return a result but let's indicate + // that we intercepted the operation. + return Intercepted::kYes; + } + return StorageDefiner(name, desc, info); } static void StorageLengthGetter(const FunctionCallbackInfo& info) { diff --git a/src/node_webstorage.h b/src/node_webstorage.h index 2ccc35b10c4d2c..2c0c3ab688cae5 100644 --- a/src/node_webstorage.h +++ b/src/node_webstorage.h @@ -23,11 +23,13 @@ struct stmt_deleter { }; using stmt_unique_ptr = std::unique_ptr; +static constexpr std::string_view kInMemoryPath = ":memory:"; + class Storage : public BaseObject { public: Storage(Environment* env, v8::Local object, - v8::Local location); + std::string_view location); void MemoryInfo(MemoryTracker* tracker) const override; static void New(const v8::FunctionCallbackInfo& args); diff --git a/src/quic/cid.cc b/src/quic/cid.cc index 404b98c47d6c19..f6eb9301a9215c 100644 --- a/src/quic/cid.cc +++ b/src/quic/cid.cc @@ -5,6 +5,7 @@ #include #include #include "nbytes.h" +#include "ncrypto.h" #include "quic/defs.h" namespace node { @@ -132,7 +133,7 @@ class RandomCIDFactory : public CID::Factory { // a CID of the requested size, we regenerate the pool // and reset it to zero. if (pos_ + length_hint > kPoolSize) { - CHECK(crypto::CSPRNG(pool_, kPoolSize).is_ok()); + CHECK(ncrypto::CSPRNG(pool_, kPoolSize)); pos_ = 0; } } diff --git a/src/quic/endpoint.cc b/src/quic/endpoint.cc index 7ac50c317c93e8..4c89ecdd91803e 100644 --- a/src/quic/endpoint.cc +++ b/src/quic/endpoint.cc @@ -19,6 +19,7 @@ #include "application.h" #include "bindingdata.h" #include "defs.h" +#include "ncrypto.h" namespace node { @@ -87,7 +88,7 @@ namespace { bool is_diagnostic_packet_loss(double probability) { if (LIKELY(probability == 0.0)) return false; unsigned char c = 255; - CHECK(crypto::CSPRNG(&c, 1).is_ok()); + CHECK(ncrypto::CSPRNG(&c, 1)); return (static_cast(c) / 255) < probability; } #endif // DEBUG diff --git a/src/quic/packet.cc b/src/quic/packet.cc index c43ac99b2442cd..1311f4828bd835 100644 --- a/src/quic/packet.cc +++ b/src/quic/packet.cc @@ -14,6 +14,7 @@ #include "bindingdata.h" #include "cid.h" #include "defs.h" +#include "ncrypto.h" #include "tokens.h" namespace node { @@ -331,7 +332,7 @@ Packet* Packet::CreateStatelessResetPacket( StatelessResetToken token(token_secret, path_descriptor.dcid); uint8_t random[kRandlen]; - CHECK(crypto::CSPRNG(random, kRandlen).is_ok()); + CHECK(ncrypto::CSPRNG(random, kRandlen)); auto packet = Create(env, listener, diff --git a/src/quic/session.cc b/src/quic/session.cc index 6476688e072924..ec54a67588d9b2 100644 --- a/src/quic/session.cc +++ b/src/quic/session.cc @@ -24,6 +24,7 @@ #include "defs.h" #include "endpoint.h" #include "logstream.h" +#include "ncrypto.h" #include "packet.h" #include "preferredaddress.h" #include "sessionticket.h" @@ -2163,7 +2164,7 @@ struct Session::Impl { static void on_rand(uint8_t* dest, size_t destlen, const ngtcp2_rand_ctx* rand_ctx) { - CHECK(crypto::CSPRNG(dest, destlen).is_ok()); + CHECK(ncrypto::CSPRNG(dest, destlen)); } static int on_early_data_rejected(ngtcp2_conn* conn, void* user_data) { diff --git a/src/quic/tokens.cc b/src/quic/tokens.cc index e2c03d49c1b32f..fcb2a24ca3b6f8 100644 --- a/src/quic/tokens.cc +++ b/src/quic/tokens.cc @@ -8,6 +8,7 @@ #include #include #include "nbytes.h" +#include "ncrypto.h" namespace node { namespace quic { @@ -22,7 +23,7 @@ TokenSecret::TokenSecret() : buf_() { // If someone manages to get visibility into that cache then they would know // the secrets for a larger number of tokens, which could be bad. For now, // generating on each call is safer, even if less performant. - CHECK(crypto::CSPRNG(buf_, QUIC_TOKENSECRET_LEN).is_ok()); + CHECK(ncrypto::CSPRNG(buf_, QUIC_TOKENSECRET_LEN)); } TokenSecret::TokenSecret(const uint8_t* secret) : buf_() { diff --git a/src/util.h b/src/util.h index 93a79f8761ee65..a3fa79f749d94e 100644 --- a/src/util.h +++ b/src/util.h @@ -144,9 +144,9 @@ void DumpJavaScriptBacktrace(FILE* fp); do { \ /* Make sure that this struct does not end up in inline code, but */ \ /* rather in a read-only data section when modifying this code. */ \ - static const node::AssertionInfo args = { \ + static const node::AssertionInfo error_and_abort_args = { \ __FILE__ ":" STRINGIFY(__LINE__), #expr, PRETTY_FUNCTION_NAME}; \ - node::Assert(args); \ + node::Assert(error_and_abort_args); \ /* `node::Assert` doesn't return. Add an [[noreturn]] abort() here to */ \ /* make the compiler happy about no return value in the caller */ \ /* function when calling ERROR_AND_ABORT. */ \ diff --git a/test/common/README.md b/test/common/README.md index a322242138740c..6d74d6c4f455ec 100644 --- a/test/common/README.md +++ b/test/common/README.md @@ -2,7 +2,7 @@ This directory contains modules used to test the Node.js implementation. -## Table of Contents +## Table of contents * [ArrayStream module](#arraystream-module) * [Benchmark module](#benchmark-module) @@ -12,7 +12,6 @@ This directory contains modules used to test the Node.js implementation. * [CPU Profiler module](#cpu-profiler-module) * [Debugger module](#debugger-module) * [DNS module](#dns-module) -* [Duplex pair helper](#duplex-pair-helper) * [Environment variables](#environment-variables) * [Fixtures module](#fixtures-module) * [Heap dump checker module](#heap-dump-checker-module) @@ -20,13 +19,14 @@ This directory contains modules used to test the Node.js implementation. * [HTTP2 module](#http2-module) * [Internet module](#internet-module) * [ongc module](#ongc-module) +* [process-exit-code-test-cases module](#process-exit-code-test-cases-module) * [Report module](#report-module) * [tick module](#tick-module) * [tmpdir module](#tmpdir-module) * [UDP pair helper](#udp-pair-helper) * [WPT module](#wpt-module) -## Benchmark Module +## Benchmark module The `benchmark` module is used by tests to run benchmarks. @@ -36,7 +36,7 @@ The `benchmark` module is used by tests to run benchmarks. * `env` [\][] Environment variables to be applied during the run. -## Child Process Module +## Child Process module The `child_process` module is used by tests that launch child processes. @@ -80,7 +80,7 @@ Similar to `expectSyncExit()` with the `status` expected to be 0 and Similar to `spawnSyncAndExitWithoutError()`, but with an additional `expectations` parameter. -## Common Module API +## Common module API The `common` module is used by tests for consistency across repeated tasks. @@ -489,7 +489,7 @@ was compiled with a pointer size smaller than 64 bits. Skip the rest of the tests in the current file when not running on a main thread. -## ArrayStream Module +## ArrayStream module The `ArrayStream` module provides a simple `Stream` that pushes elements from a given array. @@ -504,7 +504,7 @@ stream.run(['a', 'b', 'c']); It can be used within tests as a simple mock stream. -## Countdown Module +## Countdown module The `Countdown` module provides a simple countdown mechanism for tests that require a particular action to be taken after a given number of completed @@ -608,7 +608,7 @@ used to interact with the `node inspect` CLI. These functions are: * `stepCommand()` * `quit()` -## `DNS` Module +## `DNS` module The `DNS` module provides utilities related to the `dns` built-in module. @@ -669,14 +669,6 @@ Reads a Domain String and returns a Buffer containing the domain. Takes in a parsed Object and writes its fields to a DNS packet as a Buffer object. -## Duplex pair helper - -The `common/duplexpair` module exports a single function `makeDuplexPair`, -which returns an object `{ clientSide, serverSide }` where each side is a -`Duplex` stream connected to the other side. - -There is no difference between client or server side beyond their names. - ## Environment variables The behavior of the Node.js test suite can be altered using the following @@ -707,7 +699,7 @@ A comma-separated list of variables names that are appended to the global variable allowlist. Alternatively, if `NODE_TEST_KNOWN_GLOBALS` is set to `'0'`, global leak detection is disabled. -## Fixtures Module +## Fixtures module The `common/fixtures` module provides convenience methods for working with files in the `test/fixtures` directory. @@ -782,7 +774,7 @@ validateSnapshotNodes('TLSWRAP', [ ]); ``` -## hijackstdio Module +## hijackstdio module The `hijackstdio` module provides utility functions for temporarily redirecting `stdout` and `stderr` output. @@ -830,7 +822,7 @@ original state after calling [`hijackstdio.hijackStdErr()`][]. Restore the original `process.stdout.write()`. Used to restore `stdout` to its original state after calling [`hijackstdio.hijackStdOut()`][]. -## HTTP/2 Module +## HTTP/2 module The http2.js module provides a handful of utilities for creating mock HTTP/2 frames for testing of HTTP/2 endpoints @@ -949,7 +941,7 @@ upon initial establishment of a connection. socket.write(http2.kClientMagic); ``` -## Internet Module +## Internet module The `common/internet` module provides utilities for working with internet-related tests. @@ -983,7 +975,7 @@ via `NODE_TEST_*` environment variables. For example, to configure `internet.addresses.INET_HOST`, set the environment variable `NODE_TEST_INET_HOST` to a specified host. -## ongc Module +## ongc module The `ongc` module allows a garbage collection listener to be installed. The module exports a single `onGC()` function. @@ -1011,7 +1003,28 @@ a full `setImmediate()` invocation passes. `listener` is an object to make it easier to use a closure; the target object should not be in scope when `listener.ongc()` is created. -## Report Module +## process-exit-code-test-cases module + +The `process-exit-code-test-cases` module provides a set of shared test cases +for testing the exit codes of the `process` object. The test cases are shared +between `test/parallel/test-process-exit-code.js` and +`test/parallel/test-worker-exit-code.js`. + +### `getTestCases(isWorker)` + +* `isWorker` [\][] +* return [\][] + +Returns an array of test cases for testing the exit codes of the `process`. Each +test case is an object with a `func` property that is a function that runs the +test case, a `result` property that is the expected exit code, and sometimes an +`error` property that is a regular expression that the error message should +match when the test case is run in a worker thread. + +The `isWorker` parameter is used to adjust the test cases for worker threads. +The default value is `false`. + +## Report module The `report` module provides helper functions for testing diagnostic reporting functionality. @@ -1060,7 +1073,7 @@ into `targetExecutable` and sign it if necessary. If `verifyWorkflow` is false (default) and any of the steps fails, it skips the tests. Otherwise, an error is thrown. -## tick Module +## tick module The `tick` module provides a helper function that can be used to call a callback after a given number of event loop "ticks". @@ -1070,7 +1083,7 @@ after a given number of event loop "ticks". * `x` [\][] Number of event loop "ticks". * `cb` [\][] A callback function. -## tmpdir Module +## tmpdir module The `tmpdir` module supports the use of a temporary directory for testing. @@ -1138,7 +1151,7 @@ is an `FakeUDPWrap` connected to the other side. There is no difference between client or server side beyond their names. -## WPT Module +## WPT module ### `harness` diff --git a/test/common/assertSnapshot.js b/test/common/assertSnapshot.js index c4a30a5bae5db7..a22455160bd9f7 100644 --- a/test/common/assertSnapshot.js +++ b/test/common/assertSnapshot.js @@ -78,8 +78,11 @@ async function spawnAndAssert(filename, transform = (x) => x, { tty = false, ... return; } const flags = common.parseTestFlags(filename); - const executable = tty ? path.join(__dirname, '../..', 'tools/pseudo-tty.py') : process.execPath; - const args = tty ? [process.execPath, ...flags, filename] : [...flags, filename]; + const executable = tty ? (process.env.PYTHON || 'python3') : process.execPath; + const args = + tty ? + [path.join(__dirname, '../..', 'tools/pseudo-tty.py'), process.execPath, ...flags, filename] : + [...flags, filename]; const { stdout, stderr } = await common.spawnPromisified(executable, args, options); await assertSnapshot(transform(`${stdout}${stderr}`), filename); } diff --git a/test/common/duplexpair.js b/test/common/duplexpair.js deleted file mode 100644 index 1f41ed32f1b9e9..00000000000000 --- a/test/common/duplexpair.js +++ /dev/null @@ -1,48 +0,0 @@ -'use strict'; -const { Duplex } = require('stream'); -const assert = require('assert'); - -const kCallback = Symbol('Callback'); -const kOtherSide = Symbol('Other'); - -class DuplexSocket extends Duplex { - constructor() { - super(); - this[kCallback] = null; - this[kOtherSide] = null; - } - - _read() { - const callback = this[kCallback]; - if (callback) { - this[kCallback] = null; - callback(); - } - } - - _write(chunk, encoding, callback) { - assert.notStrictEqual(this[kOtherSide], null); - assert.strictEqual(this[kOtherSide][kCallback], null); - if (chunk.length === 0) { - process.nextTick(callback); - } else { - this[kOtherSide].push(chunk); - this[kOtherSide][kCallback] = callback; - } - } - - _final(callback) { - this[kOtherSide].on('end', callback); - this[kOtherSide].push(null); - } -} - -function makeDuplexPair() { - const clientSide = new DuplexSocket(); - const serverSide = new DuplexSocket(); - clientSide[kOtherSide] = serverSide; - serverSide[kOtherSide] = clientSide; - return { clientSide, serverSide }; -} - -module.exports = makeDuplexPair; diff --git a/test/fixtures/process-exit-code-cases.js b/test/common/process-exit-code-cases.js similarity index 88% rename from test/fixtures/process-exit-code-cases.js rename to test/common/process-exit-code-cases.js index 05b01afd8f4630..54cfe2655b2058 100644 --- a/test/fixtures/process-exit-code-cases.js +++ b/test/common/process-exit-code-cases.js @@ -36,7 +36,7 @@ function getTestCases(isWorker = false) { function exitWithOneOnUncaught() { process.exitCode = 99; process.on('exit', (code) => { - // cannot use assert because it will be uncaughtException -> 1 exit code + // Cannot use assert because it will be uncaughtException -> 1 exit code // that will render this test useless if (code !== 1 || process.exitCode !== 1) { console.log('wrong code! expected 1 for uncaughtException'); @@ -62,23 +62,25 @@ function getTestCases(isWorker = false) { cases.push({ func: changeCodeInsideExit, result: 99 }); function zeroExitWithUncaughtHandler() { + const noop = () => { }; process.on('exit', (code) => { - assert.strictEqual(process.exitCode, 0); + process.off('uncaughtException', noop); + assert.strictEqual(process.exitCode, undefined); assert.strictEqual(code, 0); }); - process.on('uncaughtException', () => { }); + process.on('uncaughtException', noop); throw new Error('ok'); } cases.push({ func: zeroExitWithUncaughtHandler, result: 0 }); function changeCodeInUncaughtHandler() { + const modifyExitCode = () => { process.exitCode = 97; }; process.on('exit', (code) => { + process.off('uncaughtException', modifyExitCode); assert.strictEqual(process.exitCode, 97); assert.strictEqual(code, 97); }); - process.on('uncaughtException', () => { - process.exitCode = 97; - }); + process.on('uncaughtException', modifyExitCode); throw new Error('ok'); } cases.push({ func: changeCodeInUncaughtHandler, result: 97 }); @@ -113,7 +115,7 @@ function getTestCases(isWorker = false) { function exitWithThrowInUncaughtHandler() { process.on('uncaughtException', () => { - throw new Error('ok') + throw new Error('ok'); }); throw new Error('bad'); } diff --git a/test/common/sea.js b/test/common/sea.js index 863047ab36ff48..53bfd93d927842 100644 --- a/test/common/sea.js +++ b/test/common/sea.js @@ -5,7 +5,7 @@ const fixtures = require('../common/fixtures'); const tmpdir = require('../common/tmpdir'); const { inspect } = require('util'); -const { readFileSync, copyFileSync } = require('fs'); +const { readFileSync, copyFileSync, statSync } = require('fs'); const { spawnSyncAndExitWithoutError, } = require('../common/child_process'); @@ -50,12 +50,23 @@ function skipIfSingleExecutableIsNotSupported() { common.skip('UndefinedBehavior Sanitizer is not supported'); } + try { + readFileSync(process.execPath); + } catch (e) { + if (e.code === 'ERR_FS_FILE_TOO_LARGE') { + common.skip('The Node.js binary is too large to be supported by postject'); + } + } + tmpdir.refresh(); // The SEA tests involve making a copy of the executable and writing some fixtures - // to the tmpdir. To be safe, ensure that at least 120MB disk space is available. - if (!tmpdir.hasEnoughSpace(120 * 1024 * 1024)) { - common.skip('Available disk space < 120MB'); + // to the tmpdir. To be safe, ensure that the disk space has at least a copy of the + // executable and some extra space for blobs and configs is available. + const stat = statSync(process.execPath); + const expectedSpace = stat.size + 10 * 1024 * 1024; + if (!tmpdir.hasEnoughSpace(expectedSpace)) { + common.skip(`Available disk space < ${Math.floor(expectedSpace / 1024 / 1024)} MB`); } } diff --git a/test/es-module/test-cjs-legacyMainResolve.js b/test/es-module/test-cjs-legacyMainResolve.js index 1dc7d8faafe6eb..0bfeb567a22b1f 100644 --- a/test/es-module/test-cjs-legacyMainResolve.js +++ b/test/es-module/test-cjs-legacyMainResolve.js @@ -129,7 +129,7 @@ describe('legacyMainResolve', () => { ); assert.throws( () => legacyMainResolve(packageJsonUrl, { main: null }, packageJsonUrl), - { code: 'ERR_MODULE_NOT_FOUND' }, + { message: /index\.js/, code: 'ERR_MODULE_NOT_FOUND' }, ); }); @@ -137,7 +137,20 @@ describe('legacyMainResolve', () => { const packageJsonUrl = pathToFileURL('/c/file%20with%20percents/package.json'); assert.throws( () => legacyMainResolve(packageJsonUrl, { main: null }, packageJsonUrl), - { code: 'ERR_MODULE_NOT_FOUND' }, + { message: /index\.js/, code: 'ERR_MODULE_NOT_FOUND' }, + ); + }); + + it('should report main file on error message when not found', () => { + const packageJsonUrl = pathToFileURL( + path.resolve( + fixtures.path('/es-modules/legacy-main-resolver'), + 'package.json' + ) + ); + assert.throws( + () => legacyMainResolve(packageJsonUrl, { main: './index.node' }, packageJsonUrl), + { message: /index\.node/, code: 'ERR_MODULE_NOT_FOUND' }, ); }); diff --git a/test/es-module/test-esm-experimental-warnings.mjs b/test/es-module/test-esm-experimental-warnings.mjs index b4946e8f225750..902583c6db77fa 100644 --- a/test/es-module/test-esm-experimental-warnings.mjs +++ b/test/es-module/test-esm-experimental-warnings.mjs @@ -30,7 +30,6 @@ describe('ESM: warn for obsolete hooks provided', { concurrency: !process.env.TE '--experimental-loader', fileURL('es-module-loaders', 'hooks-custom.mjs'), ], - [/Network Imports/, '--experimental-network-imports'], ] ) { it(`should print for ${experiment.toString().replaceAll('/', '')}`, async () => { diff --git a/test/es-module/test-http-imports-cli.mjs b/test/es-module/test-http-imports-cli.mjs deleted file mode 100644 index b8bf5e21236572..00000000000000 --- a/test/es-module/test-http-imports-cli.mjs +++ /dev/null @@ -1,48 +0,0 @@ -import { mustCall, spawnPromisified } from '../common/index.mjs'; -import { ok, match, notStrictEqual } from 'node:assert'; -import { spawn as spawnAsync } from 'node:child_process'; -import { execPath } from 'node:process'; -import { describe, it } from 'node:test'; - - -describe('ESM: http import via CLI', { concurrency: !process.env.TEST_PARALLEL }, () => { - const disallowedSpecifier = 'http://example.com'; - - it('should throw disallowed error for insecure protocol', async () => { - const { code, stderr } = await spawnPromisified(execPath, [ - '--experimental-network-imports', - '--input-type=module', - '--eval', - `import ${JSON.stringify(disallowedSpecifier)}`, - ]); - - notStrictEqual(code, 0); - - // [ERR_NETWORK_IMPORT_DISALLOWED]: import of 'http://example.com/' by - // …/[eval1] is not supported: http can only be used to load local - // resources (use https instead). - match(stderr, /ERR_NETWORK_IMPORT_DISALLOWED/); - ok(stderr.includes(disallowedSpecifier)); - }); - - it('should throw disallowed error for insecure protocol in REPL', () => { - const child = spawnAsync(execPath, [ - '--experimental-network-imports', - '--input-type=module', - ]); - child.stdin.end(`import ${JSON.stringify(disallowedSpecifier)}`); - - let stderr = ''; - child.stderr.setEncoding('utf8'); - child.stderr.on('data', (data) => stderr += data); - child.on('close', mustCall((code, _signal) => { - notStrictEqual(code, 0); - - // [ERR_NETWORK_IMPORT_DISALLOWED]: import of 'http://example.com/' by - // …/[stdin] is not supported: http can only be used to load local - // resources (use https instead). - match(stderr, /\[ERR_NETWORK_IMPORT_DISALLOWED\]/); - ok(stderr.includes(disallowedSpecifier)); - })); - }); -}); diff --git a/test/es-module/test-http-imports.mjs b/test/es-module/test-http-imports.mjs deleted file mode 100644 index 90d60e359ffd16..00000000000000 --- a/test/es-module/test-http-imports.mjs +++ /dev/null @@ -1,311 +0,0 @@ -// Flags: --experimental-network-imports --dns-result-order=ipv4first -import * as common from '../common/index.mjs'; -import * as fixtures from '../common/fixtures.mjs'; -import tmpdir from '../common/tmpdir.js'; -import assert from 'assert'; -import http from 'http'; -import os from 'os'; -import util from 'util'; -import { describe, it } from 'node:test'; - -if (!common.hasCrypto) { - common.skip('missing crypto'); -} -tmpdir.refresh(); - -const https = (await import('https')).default; - -const createHTTPServer = http.createServer; - -// Needed to deal w/ test certs -process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'; -const options = { - key: fixtures.readKey('agent1-key.pem'), - cert: fixtures.readKey('agent1-cert.pem') -}; - -const createHTTPSServer = https.createServer.bind(null, options); - - -const testListeningOptions = [ - { - hostname: 'localhost', - listenOptions: { - host: '127.0.0.1' - } - }, -]; - -const internalInterfaces = Object.values(os.networkInterfaces()).flat().filter( - (iface) => iface?.internal && iface.address && !iface.scopeid -); -for (const iface of internalInterfaces) { - testListeningOptions.push({ - hostname: iface?.family === 'IPv6' ? `[${iface?.address}]` : iface?.address, - listenOptions: { - host: iface?.address, - ipv6Only: iface?.family === 'IPv6' - } - }); -} - -for (const { protocol, createServer } of [ - { protocol: 'http:', createServer: createHTTPServer }, - { protocol: 'https:', createServer: createHTTPSServer }, -]) { - const body = ` - export default (a) => () => a; - export let url = import.meta.url; - `; - - const base = 'http://127.0.0.1'; - for (const { hostname, listenOptions } of testListeningOptions) { - const host = new URL(base); - host.protocol = protocol; - host.hostname = hostname; - // /not-found is a 404 - // ?redirect causes a redirect, no body. JSON.parse({status:number,location:string}) - // ?mime sets the content-type, string - // ?body sets the body, string - const server = createServer(function(_req, res) { - const url = new URL(_req.url, host); - const redirect = url.searchParams.get('redirect'); - - if (url.pathname === 'json') { - common.mustCall(() => assert.strictEqual(_req.header.content, 'application/json,*/*;charset=utf-8;q=0.5')); - } - - if (url.pathname === '/not-found') { - res.writeHead(404); - res.end(); - return; - } - if (redirect) { - const { status, location } = JSON.parse(redirect); - res.writeHead(status, { - location - }); - res.end(); - return; - } - res.writeHead(200, { - 'content-type': url.searchParams.get('mime') || 'text/javascript' - }); - res.end(url.searchParams.get('body') || body); - }); - - const listen = util.promisify(server.listen.bind(server)); - await listen({ - ...listenOptions, - port: 0 - }); - const url = new URL(host); - url.port = server?.address()?.port; - - const ns = await import(url.href); - assert.strict.deepStrictEqual(Object.keys(ns), ['default', 'url']); - const obj = {}; - assert.strict.equal(ns.default(obj)(), obj); - assert.strict.equal(ns.url, url.href); - - // Redirects have same import.meta.url but different cache - // entry on Web - const redirect = new URL(url.href); - redirect.searchParams.set('redirect', JSON.stringify({ - status: 302, - location: url.href - })); - const redirectedNS = await import(redirect.href); - assert.strict.deepStrictEqual( - Object.keys(redirectedNS), - ['default', 'url'] - ); - assert.strict.notEqual(redirectedNS.default, ns.default); - assert.strict.equal(redirectedNS.url, url.href); - - // Redirects have the same import.meta.url but different cache - // entry on Web - const relativeAfterRedirect = new URL(url.href + 'foo/index.js'); - const redirected = new URL(url.href + 'bar/index.js'); - redirected.searchParams.set('body', 'export let relativeDepURL = (await import("./baz.js")).url'); - relativeAfterRedirect.searchParams.set('redirect', JSON.stringify({ - status: 302, - location: redirected.href - })); - const relativeAfterRedirectedNS = await import(relativeAfterRedirect.href); - assert.strict.equal( - relativeAfterRedirectedNS.relativeDepURL, - url.href + 'bar/baz.js' - ); - - const unsupportedMIME = new URL(url.href); - unsupportedMIME.searchParams.set('mime', 'application/node'); - unsupportedMIME.searchParams.set('body', ''); - await assert.rejects( - import(unsupportedMIME.href), - { code: 'ERR_UNKNOWN_MODULE_FORMAT' } - ); - - const notFound = new URL(url.href); - notFound.pathname = '/not-found'; - await assert.rejects( - import(notFound.href), - { code: 'ERR_MODULE_NOT_FOUND' }, - ); - - const jsonUrl = new URL(url.href + 'json'); - jsonUrl.searchParams.set('mime', 'application/json'); - jsonUrl.searchParams.set('body', '{"x": 1}'); - const json = await import(jsonUrl.href, { with: { type: 'json' } }); - assert.deepStrictEqual(Object.keys(json), ['default']); - assert.strictEqual(json.default.x, 1); - - await describe('guarantee data url will not bypass import restriction', () => { - it('should not be bypassed by cross protocol redirect', async () => { - const crossProtocolRedirect = new URL(url.href); - crossProtocolRedirect.searchParams.set('redirect', JSON.stringify({ - status: 302, - location: 'data:text/javascript,' - })); - await assert.rejects( - import(crossProtocolRedirect.href), - { code: 'ERR_NETWORK_IMPORT_DISALLOWED' } - ); - }); - - it('should not be bypassed by data URL', async () => { - const deps = new URL(url.href); - deps.searchParams.set('body', ` - export {data} from 'data:text/javascript,export let data = 1'; - import * as http from ${JSON.stringify(url.href)}; - export {http}; - `); - await assert.rejects( - import(deps.href), - { code: 'ERR_NETWORK_IMPORT_DISALLOWED' } - ); - }); - - it('should not be bypassed by encodedURI import', async () => { - const deepDataImport = new URL(url.href); - deepDataImport.searchParams.set('body', ` - import 'data:text/javascript,import${encodeURIComponent(JSON.stringify('data:text/javascript,import "os"'))}'; - `); - await assert.rejects( - import(deepDataImport.href), - { code: 'ERR_NETWORK_IMPORT_DISALLOWED' } - ); - }); - - it('should not be bypassed by relative deps import', async () => { - const relativeDeps = new URL(url.href); - relativeDeps.searchParams.set('body', ` - import * as http from "./"; - export {http}; - `); - const relativeDepsNS = await import(relativeDeps.href); - assert.strict.deepStrictEqual(Object.keys(relativeDepsNS), ['http']); - assert.strict.equal(relativeDepsNS.http, ns); - }); - - it('should not be bypassed by file dependency import', async () => { - const fileDep = new URL(url.href); - const { href } = fixtures.fileURL('/es-modules/message.mjs'); - fileDep.searchParams.set('body', ` - import ${JSON.stringify(href)}; - export default 1;`); - await assert.rejects( - import(fileDep.href), - { code: 'ERR_NETWORK_IMPORT_DISALLOWED' } - ); - }); - - it('should not be bypassed by builtin dependency import', async () => { - const builtinDep = new URL(url.href); - builtinDep.searchParams.set('body', ` - import 'node:fs'; - export default 1; - `); - await assert.rejects( - import(builtinDep.href), - { code: 'ERR_NETWORK_IMPORT_DISALLOWED' } - ); - }); - - - it('should not be bypassed by unprefixed builtin dependency import', async () => { - const unprefixedBuiltinDep = new URL(url.href); - unprefixedBuiltinDep.searchParams.set('body', ` - import 'fs'; - export default 1; - `); - await assert.rejects( - import(unprefixedBuiltinDep.href), - { code: 'ERR_NETWORK_IMPORT_DISALLOWED' } - ); - }); - - it('should not be bypassed by indirect network import', async () => { - const indirect = new URL(url.href); - indirect.searchParams.set('body', ` - import childProcess from 'data:text/javascript,export { default } from "node:child_process"' - export {childProcess}; - `); - await assert.rejects( - import(indirect.href), - { code: 'ERR_NETWORK_IMPORT_DISALLOWED' } - ); - }); - - it('data: URL can always import other data:', async () => { - const data = new URL('data:text/javascript,'); - data.searchParams.set('body', - 'import \'data:text/javascript,import \'data:\'' - ); - // doesn't throw - const empty = await import(data.href); - assert.ok(empty); - }); - - it('data: URL cannot import file: or builtin', async () => { - const data1 = new URL(url.href); - data1.searchParams.set('body', - 'import \'file:///some/file.js\'' - ); - await assert.rejects( - import(data1.href), - { code: 'ERR_NETWORK_IMPORT_DISALLOWED' } - ); - - const data2 = new URL(url.href); - data2.searchParams.set('body', - 'import \'node:fs\'' - ); - await assert.rejects( - import(data2.href), - { code: 'ERR_NETWORK_IMPORT_DISALLOWED' } - ); - }); - - it('data: URL cannot import HTTP URLs', async () => { - const module = fixtures.fileURL('/es-modules/import-data-url.mjs'); - try { - await import(module); - } catch (err) { - // We only want the module to load, we don't care if the module throws an - // error as long as the loader does not. - assert.notStrictEqual(err?.code, 'ERR_MODULE_NOT_FOUND'); - } - const data1 = new URL(url.href); - const dataURL = 'data:text/javascript;export * from "node:os"'; - data1.searchParams.set('body', `export * from ${JSON.stringify(dataURL)};`); - await assert.rejects( - import(data1), - { code: 'ERR_NETWORK_IMPORT_DISALLOWED' } - ); - }); - }); - - server.close(); - } -} diff --git a/test/es-module/test-require-module-special-import.js b/test/es-module/test-require-module-special-import.js deleted file mode 100644 index 3ff03d08e8d1d0..00000000000000 --- a/test/es-module/test-require-module-special-import.js +++ /dev/null @@ -1,11 +0,0 @@ -// Flags: --experimental-require-module -'use strict'; - -require('../common'); -const assert = require('assert'); - -assert.throws(() => { - require('../fixtures/es-modules/network-import.mjs'); -}, { - code: 'ERR_NETWORK_IMPORT_DISALLOWED' -}); diff --git a/test/es-module/test-typescript-commonjs.mjs b/test/es-module/test-typescript-commonjs.mjs new file mode 100644 index 00000000000000..f65d7281010ab7 --- /dev/null +++ b/test/es-module/test-typescript-commonjs.mjs @@ -0,0 +1,177 @@ +import { spawnPromisified } from '../common/index.mjs'; +import * as fixtures from '../common/fixtures.mjs'; +import { match, strictEqual } from 'node:assert'; +import { test } from 'node:test'; + +test('require a .ts file with explicit extension succeeds', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--eval', + 'require("./test-typescript.ts")', + '--no-warnings', + ], { + cwd: fixtures.path('typescript/ts'), + }); + + strictEqual(result.stderr, ''); + strictEqual(result.stdout, 'Hello, TypeScript!\n'); + strictEqual(result.code, 0); +}); + +test('eval require a .ts file with implicit extension fails', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--eval', + 'require("./test-typescript")', + '--no-warnings', + ], { + cwd: fixtures.path('typescript/ts'), + }); + + strictEqual(result.stdout, ''); + match(result.stderr, /Error: Cannot find module/); + strictEqual(result.code, 1); +}); + +test('eval require a .cts file with implicit extension fails', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--eval', + 'require("./test-cts-typescript")', + '--no-warnings', + ], { + cwd: fixtures.path('typescript/ts'), + }); + + strictEqual(result.stdout, ''); + match(result.stderr, /Error: Cannot find module/); + strictEqual(result.code, 1); +}); + +test('require a .ts file with implicit extension fails', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/cts/test-extensionless-require.ts'), + ]); + + strictEqual(result.stdout, ''); + match(result.stderr, /Error: Cannot find module/); + strictEqual(result.code, 1); +}); + +test('expect failure of an .mts file with CommonJS syntax', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/cts/test-cts-but-module-syntax.cts'), + ]); + + strictEqual(result.stdout, ''); + match(result.stderr, /To load an ES module, set "type": "module" in the package\.json or use the \.mjs extension\./); + strictEqual(result.code, 1); +}); + +test('execute a .cts file importing a .cts file', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/cts/test-require-commonjs.cts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a .cts file importing a .ts file export', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/cts/test-require-ts-file.cts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a .cts file importing a .mts file export', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/cts/test-require-mts-module.cts'), + ]); + + strictEqual(result.stdout, ''); + match(result.stderr, /Error \[ERR_REQUIRE_ESM\]: require\(\) of ES Module/); + strictEqual(result.code, 1); +}); + +test('execute a .cts file importing a .mts file export', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-require-module', + fixtures.path('typescript/cts/test-require-mts-module.cts'), + ]); + + match(result.stderr, /Support for loading ES Module in require\(\) is an experimental feature and might change at any time/); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a .cts file with default type module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-default-type=module', // Keeps working with commonjs + '--no-warnings', + fixtures.path('typescript/cts/test-require-commonjs.cts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('expect failure of a .cts file in node_modules', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/cts/test-cts-node_modules.cts'), + ]); + + strictEqual(result.stdout, ''); + match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + strictEqual(result.code, 1); +}); + +test('expect failure of a .ts file in node_modules', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/cts/test-ts-node_modules.cts'), + ]); + + strictEqual(result.stdout, ''); + match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + strictEqual(result.code, 1); +}); + +test('expect failure of a .cts requiring esm without default type module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/cts/test-mts-node_modules.cts'), + ]); + + strictEqual(result.stdout, ''); + match(result.stderr, /ERR_REQUIRE_ESM/); + strictEqual(result.code, 1); +}); + +test('expect failure of a .cts file requiring esm in node_modules', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-require-module', + fixtures.path('typescript/cts/test-mts-node_modules.cts'), + ]); + + strictEqual(result.stdout, ''); + match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + strictEqual(result.code, 1); +}); diff --git a/test/es-module/test-typescript-eval.mjs b/test/es-module/test-typescript-eval.mjs new file mode 100644 index 00000000000000..218e5b66c64988 --- /dev/null +++ b/test/es-module/test-typescript-eval.mjs @@ -0,0 +1,110 @@ +import { spawnPromisified } from '../common/index.mjs'; +import { match, strictEqual } from 'node:assert'; +import { test } from 'node:test'; + +test('eval TypeScript ESM syntax', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--eval', + `import util from 'node:util' + const text: string = 'Hello, TypeScript!' + console.log(util.styleText('red', text));`]); + + match(result.stderr, /Type Stripping is an experimental feature and might change at any time/); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('eval TypeScript ESM syntax with input-type module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--input-type=module', + '--eval', + `import util from 'node:util' + const text: string = 'Hello, TypeScript!' + console.log(util.styleText('red', text));`]); + + match(result.stderr, /Type Stripping is an experimental feature and might change at any time/); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('eval TypeScript CommonJS syntax', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--eval', + `const util = require('node:util'); + const text: string = 'Hello, TypeScript!' + console.log(util.styleText('red', text));`, + '--no-warnings']); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.stderr, ''); + strictEqual(result.code, 0); +}); + +test('eval TypeScript CommonJS syntax with input-type commonjs', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--input-type=commonjs', + '--eval', + `const util = require('node:util'); + const text: string = 'Hello, TypeScript!' + console.log(util.styleText('red', text));`, + '--no-warnings']); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.stderr, ''); + strictEqual(result.code, 0); +}); + +test('eval TypeScript CommonJS syntax by default', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--eval', + `const util = require('node:util'); + const text: string = 'Hello, TypeScript!' + console.log(util.styleText('red', text));`, + '--no-warnings']); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('TypeScript ESM syntax not specified', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--eval', + `import util from 'node:util' + const text: string = 'Hello, TypeScript!' + console.log(text);`]); + match(result.stderr, /ExperimentalWarning: Type Stripping is an experimental/); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('expect fail eval TypeScript CommonJS syntax with input-type module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--input-type=module', + '--eval', + `const util = require('node:util'); + const text: string = 'Hello, TypeScript!' + console.log(util.styleText('red', text));`]); + + strictEqual(result.stdout, ''); + match(result.stderr, /require is not defined in ES module scope, you can use import instead/); + strictEqual(result.code, 1); +}); + +test('expect fail eval TypeScript CommonJS syntax with input-type module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--input-type=commonjs', + '--eval', + `import util from 'node:util' + const text: string = 'Hello, TypeScript!' + console.log(util.styleText('red', text));`]); + strictEqual(result.stdout, ''); + match(result.stderr, /Cannot use import statement outside a module/); + strictEqual(result.code, 1); +}); diff --git a/test/es-module/test-typescript-module.mjs b/test/es-module/test-typescript-module.mjs new file mode 100644 index 00000000000000..e1137e8d524622 --- /dev/null +++ b/test/es-module/test-typescript-module.mjs @@ -0,0 +1,132 @@ +import { spawnPromisified } from '../common/index.mjs'; +import * as fixtures from '../common/fixtures.mjs'; +import { match, strictEqual } from 'node:assert'; +import { test } from 'node:test'; + +test('expect failure of a .mts file with CommonJS syntax', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/mts/test-mts-but-commonjs-syntax.mts'), + ]); + + strictEqual(result.stdout, ''); + match(result.stderr, /require is not defined in ES module scope, you can use import instead/); + strictEqual(result.code, 1); +}); + +test('execute an .mts file importing an .mts file', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/mts/test-import-module.mts'), + ]); + + match(result.stderr, /Type Stripping is an experimental feature and might change at any time/); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute an .mts file importing a .ts file', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/mts/test-import-ts-file.mts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute an .mts file importing a .ts file with default-type module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-default-type=module', + '--no-warnings', + fixtures.path('typescript/mts/test-import-ts-file.mts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute an .mts file importing a .cts file', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/mts/test-import-commonjs.mts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute an .mts file with wrong default module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-default-type=commonjs', + fixtures.path('typescript/mts/test-import-module.mts'), + ]); + + strictEqual(result.stdout, ''); + match(result.stderr, /Error \[ERR_REQUIRE_ESM\]: require\(\) of ES Module/); + strictEqual(result.code, 1); +}); + +test('execute an .mts file from node_modules', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/mts/test-mts-node_modules.mts'), + ]); + + match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + strictEqual(result.stdout, ''); + strictEqual(result.code, 1); +}); + +test('execute a .cts file from node_modules', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/mts/test-cts-node_modules.mts'), + ]); + + match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + strictEqual(result.stdout, ''); + strictEqual(result.code, 1); +}); + +test('execute a .ts file from node_modules', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/mts/test-ts-node_modules.mts'), + ]); + + match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + strictEqual(result.stdout, ''); + strictEqual(result.code, 1); +}); + +test('execute an empty .ts file', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/ts/test-empty-file.ts'), + ]); + + strictEqual(result.stderr, ''); + strictEqual(result.stdout, ''); + strictEqual(result.code, 0); +}); + +test('execute .ts file importing a module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/ts/test-import-fs.ts'), + ]); + + strictEqual(result.stderr, ''); + strictEqual(result.stdout, 'Hello, TypeScript!\n'); + strictEqual(result.code, 0); +}); diff --git a/test/es-module/test-typescript.mjs b/test/es-module/test-typescript.mjs new file mode 100644 index 00000000000000..23f65b286735bc --- /dev/null +++ b/test/es-module/test-typescript.mjs @@ -0,0 +1,313 @@ +import { spawnPromisified } from '../common/index.mjs'; +import * as fixtures from '../common/fixtures.mjs'; +import { match, strictEqual } from 'node:assert'; +import { test } from 'node:test'; + +test('execute a TypeScript file', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/ts/test-typescript.ts'), + ]); + + match(result.stderr, /Type Stripping is an experimental feature and might change at any time/); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a TypeScript file with imports', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/ts/test-import-foo.ts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a TypeScript file with imports with default-type module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-default-type=module', + '--no-warnings', + fixtures.path('typescript/ts/test-import-foo.ts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a TypeScript file with node_modules', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/ts/test-typescript-node-modules.ts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a TypeScript file with node_modules with default-type module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-default-type=module', + '--no-warnings', + fixtures.path('typescript/ts/test-typescript-node-modules.ts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('expect error when executing a TypeScript file with imports with no extensions', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/ts/test-import-no-extension.ts'), + ]); + + match(result.stderr, /Error \[ERR_MODULE_NOT_FOUND\]:/); + strictEqual(result.stdout, ''); + strictEqual(result.code, 1); +}); + +test('expect error when executing a TypeScript file with imports with no extensions with default-type module', + async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-default-type=module', + fixtures.path('typescript/ts/test-import-no-extension.ts'), + ]); + + match(result.stderr, /Error \[ERR_MODULE_NOT_FOUND\]:/); + strictEqual(result.stdout, ''); + strictEqual(result.code, 1); + }); + +test('expect error when executing a TypeScript file with enum', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/ts/test-enums.ts'), + ]); + + // This error should be thrown during transformation + match(result.stderr, /TypeScript enum is not supported in strip-only mode/); + strictEqual(result.stdout, ''); + strictEqual(result.code, 1); +}); + +test('expect error when executing a TypeScript file with experimental decorators', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/ts/test-experimental-decorators.ts'), + ]); + // This error should be thrown at runtime + match(result.stderr, /Invalid or unexpected token/); + strictEqual(result.stdout, ''); + strictEqual(result.code, 1); +}); + +test('expect error when executing a TypeScript file with namespaces', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/ts/test-namespaces.ts'), + ]); + // This error should be thrown during transformation + match(result.stderr, /TypeScript namespace declaration is not supported in strip-only mode/); + strictEqual(result.stdout, ''); + strictEqual(result.code, 1); +}); + +test('execute a TypeScript file with type definition', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/ts/test-import-types.ts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a TypeScript file with type definition but no type keyword', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/ts/test-import-no-type-keyword.ts'), + ]); + + match(result.stderr, /does not provide an export named 'MyType'/); + strictEqual(result.stdout, ''); + strictEqual(result.code, 1); +}); + +test('execute a TypeScript file with type definition but no type keyword with default-type modue', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-default-type=module', + fixtures.path('typescript/ts/test-import-no-type-keyword.ts'), + ]); + + match(result.stderr, /does not provide an export named 'MyType'/); + strictEqual(result.stdout, ''); + strictEqual(result.code, 1); +}); + +test('execute a TypeScript file with CommonJS syntax', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/ts/test-commonjs-parsing.ts'), + ]); + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a TypeScript file with ES module syntax', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/ts/test-module-typescript.ts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a TypeScript file with ES module syntax with default-type module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-default-type=module', + '--no-warnings', + fixtures.path('typescript/ts/test-module-typescript.ts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('expect failure of a TypeScript file requiring ES module syntax', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-require-module', + fixtures.path('typescript/ts/test-require-module.ts'), + ]); + + match(result.stderr, /Support for loading ES Module in require\(\) is an experimental feature and might change at any time/); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('expect stack trace of a TypeScript file to be correct', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/ts/test-whitespacing.ts'), + ]); + + strictEqual(result.stdout, ''); + match(result.stderr, /test-whitespacing\.ts:5:7/); + strictEqual(result.code, 1); +}); + +test('execute CommonJS TypeScript file from node_modules with require-module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/ts/test-import-ts-node-modules.ts'), + ]); + + match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + strictEqual(result.stdout, ''); + strictEqual(result.code, 1); +}); + +test('execute CommonJS TypeScript file from node_modules with require-module and default-type module', + async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-default-type=module', + fixtures.path('typescript/ts/test-import-ts-node-modules.ts'), + ]); + + match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/); + strictEqual(result.stdout, ''); + strictEqual(result.code, 1); + }); + +test('execute a TypeScript file with CommonJS syntax but default type module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-default-type=module', + fixtures.path('typescript/ts/test-commonjs-parsing.ts'), + ]); + strictEqual(result.stdout, ''); + match(result.stderr, /require is not defined in ES module scope, you can use import instead/); + strictEqual(result.code, 1); +}); + +test('execute a TypeScript file with CommonJS syntax requiring .cts', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/ts/test-require-cts.ts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a TypeScript file with CommonJS syntax requiring .mts', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + fixtures.path('typescript/ts/test-require-mts.ts'), + ]); + + strictEqual(result.stdout, ''); + match(result.stderr, /Error \[ERR_REQUIRE_ESM\]: require\(\) of ES Module/); + strictEqual(result.code, 1); +}); + +test('execute a TypeScript file with CommonJS syntax requiring .mts with require-module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-require-module', + fixtures.path('typescript/ts/test-require-mts.ts'), + ]); + + match(result.stderr, /Support for loading ES Module in require\(\) is an experimental feature and might change at any time/); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a TypeScript file with CommonJS syntax requiring .mts with require-module', async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--no-warnings', + fixtures.path('typescript/ts/test-require-cts.ts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); +}); + +test('execute a TypeScript file with CommonJS syntax requiring .mts with require-module with default-type commonjs', + async () => { + const result = await spawnPromisified(process.execPath, [ + '--experimental-strip-types', + '--experimental-default-type=commonjs', + '--no-warnings', + fixtures.path('typescript/ts/test-require-cts.ts'), + ]); + + strictEqual(result.stderr, ''); + match(result.stdout, /Hello, TypeScript!/); + strictEqual(result.code, 0); + }); diff --git a/test/fixtures/dotenv/valid.env b/test/fixtures/dotenv/valid.env index 963c4c848a4225..120488d57917e0 100644 --- a/test/fixtures/dotenv/valid.env +++ b/test/fixtures/dotenv/valid.env @@ -38,6 +38,7 @@ RETAIN_INNER_QUOTES={"foo": "bar"} RETAIN_INNER_QUOTES_AS_STRING='{"foo": "bar"}' RETAIN_INNER_QUOTES_AS_BACKTICKS=`{"foo": "bar's"}` TRIM_SPACE_FROM_UNQUOTED= some spaced out string +SPACE_BEFORE_DOUBLE_QUOTES= "space before double quotes" EMAIL=therealnerdybeast@example.tld SPACED_KEY = parsed EDGE_CASE_INLINE_COMMENTS="VALUE1" # or "VALUE2" or "VALUE3" diff --git a/test/fixtures/es-modules/network-import.mjs b/test/fixtures/es-modules/network-import.mjs deleted file mode 100644 index 529d563b4d982f..00000000000000 --- a/test/fixtures/es-modules/network-import.mjs +++ /dev/null @@ -1 +0,0 @@ -import 'http://example.com/foo.js'; diff --git a/test/fixtures/permission/fs-read.js b/test/fixtures/permission/fs-read.js index 92e53c0b046124..0ce7d65b21be1a 100644 --- a/test/fixtures/permission/fs-read.js +++ b/test/fixtures/permission/fs-read.js @@ -161,23 +161,21 @@ const regularFile = __filename; }, common.expectsError({ code: 'ERR_ACCESS_DENIED', permission: 'FileSystemRead', - // cpSync calls lstatSync before reading blockedFile - resource: blockedFile, + resource: path.toNamespacedPath(blockedFile), })); assert.throws(() => { fs.cpSync(blockedFileURL, path.join(blockedFolder, 'any-other-file')); }, common.expectsError({ code: 'ERR_ACCESS_DENIED', permission: 'FileSystemRead', - // cpSync calls lstatSync before reading blockedFile - resource: blockedFile, + resource: path.toNamespacedPath(blockedFile), })); assert.throws(() => { fs.cpSync(blockedFile, path.join(__dirname, 'any-other-file')); }, common.expectsError({ code: 'ERR_ACCESS_DENIED', permission: 'FileSystemRead', - resource: blockedFile, + resource: path.toNamespacedPath(blockedFile), })); } diff --git a/test/fixtures/source-map/output/source_map_throw_async_stack_trace.mjs b/test/fixtures/source-map/output/source_map_throw_async_stack_trace.mjs new file mode 100644 index 00000000000000..8e3fefbebe4d5d --- /dev/null +++ b/test/fixtures/source-map/output/source_map_throw_async_stack_trace.mjs @@ -0,0 +1,13 @@ +// Flags: --enable-source-maps +import '../../../common/index.mjs'; +async function Throw() { + await 0; + throw new Error('message'); +} +(async function main() { + await Promise.all([0, 1, 2, Throw()]); +})(); +// To recreate: +// +// npx --package typescript tsc --module nodenext --target esnext --outDir test/fixtures/source-map/output --sourceMap test/fixtures/source-map/output/source_map_throw_async_stack_trace.mts +//# sourceMappingURL=source_map_throw_async_stack_trace.mjs.map \ No newline at end of file diff --git a/test/fixtures/source-map/output/source_map_throw_async_stack_trace.mjs.map b/test/fixtures/source-map/output/source_map_throw_async_stack_trace.mjs.map new file mode 100644 index 00000000000000..728e8c20291a9b --- /dev/null +++ b/test/fixtures/source-map/output/source_map_throw_async_stack_trace.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"source_map_throw_async_stack_trace.mjs","sourceRoot":"","sources":["source_map_throw_async_stack_trace.mts"],"names":[],"mappings":"AAAA,+BAA+B;AAE/B,OAAO,2BAA2B,CAAC;AAQnC,KAAK,UAAU,KAAK;IAClB,MAAM,CAAC,CAAC;IACR,MAAM,IAAI,KAAK,CAAC,SAAS,CAAC,CAAA;AAC5B,CAAC;AAED,CAAC,KAAK,UAAU,IAAI;IAClB,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;AACxC,CAAC,CAAC,EAAE,CAAA;AAEJ,eAAe;AACf,EAAE;AACF,6LAA6L"} \ No newline at end of file diff --git a/test/fixtures/source-map/output/source_map_throw_async_stack_trace.mts b/test/fixtures/source-map/output/source_map_throw_async_stack_trace.mts new file mode 100644 index 00000000000000..718f617928d5ce --- /dev/null +++ b/test/fixtures/source-map/output/source_map_throw_async_stack_trace.mts @@ -0,0 +1,22 @@ +// Flags: --enable-source-maps + +import '../../../common/index.mjs'; + +interface Foo { + /** line + * + * blocks */ +} + +async function Throw() { + await 0; + throw new Error('message') +} + +(async function main() { + await Promise.all([0, 1, 2, Throw()]); +})() + +// To recreate: +// +// npx --package typescript tsc --module nodenext --target esnext --outDir test/fixtures/source-map/output --sourceMap test/fixtures/source-map/output/source_map_throw_async_stack_trace.mts diff --git a/test/fixtures/source-map/output/source_map_throw_async_stack_trace.snapshot b/test/fixtures/source-map/output/source_map_throw_async_stack_trace.snapshot new file mode 100644 index 00000000000000..8f7f0490587585 --- /dev/null +++ b/test/fixtures/source-map/output/source_map_throw_async_stack_trace.snapshot @@ -0,0 +1,11 @@ +*output*source_map_throw_async_stack_trace.mts:13 + throw new Error('message') + ^ + + +Error: message + at Throw (*output*source_map_throw_async_stack_trace.mts:13:9) + at async Promise.all (index 3) + at async main (*output*source_map_throw_async_stack_trace.mts:17:3) + +Node.js * diff --git a/test/fixtures/source-map/output/source_map_throw_construct.mjs b/test/fixtures/source-map/output/source_map_throw_construct.mjs new file mode 100644 index 00000000000000..24361da883da7c --- /dev/null +++ b/test/fixtures/source-map/output/source_map_throw_construct.mjs @@ -0,0 +1,12 @@ +// Flags: --enable-source-maps +import '../../../common/index.mjs'; +class Foo { + constructor() { + throw new Error('message'); + } +} +new Foo(); +// To recreate: +// +// npx --package typescript tsc --module nodenext --target esnext --outDir test/fixtures/source-map/output --sourceMap test/fixtures/source-map/output/source_map_throw_construct.mts +//# sourceMappingURL=source_map_throw_construct.mjs.map \ No newline at end of file diff --git a/test/fixtures/source-map/output/source_map_throw_construct.mjs.map b/test/fixtures/source-map/output/source_map_throw_construct.mjs.map new file mode 100644 index 00000000000000..2bf39629caf627 --- /dev/null +++ b/test/fixtures/source-map/output/source_map_throw_construct.mjs.map @@ -0,0 +1 @@ +{"version":3,"file":"source_map_throw_construct.mjs","sourceRoot":"","sources":["source_map_throw_construct.mts"],"names":[],"mappings":"AAAA,+BAA+B;AAE/B,OAAO,2BAA2B,CAAC;AAQnC,MAAM,GAAG;IACP;QACE,MAAM,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC;IAC7B,CAAC;CACF;AAED,IAAI,GAAG,EAAE,CAAC;AAEV,eAAe;AACf,EAAE;AACF,qLAAqL"} \ No newline at end of file diff --git a/test/fixtures/source-map/output/source_map_throw_construct.mts b/test/fixtures/source-map/output/source_map_throw_construct.mts new file mode 100644 index 00000000000000..38f2dee88a652e --- /dev/null +++ b/test/fixtures/source-map/output/source_map_throw_construct.mts @@ -0,0 +1,21 @@ +// Flags: --enable-source-maps + +import '../../../common/index.mjs'; + +interface Block { + /** line + * + * blocks */ +} + +class Foo { + constructor() { + throw new Error('message'); + } +} + +new Foo(); + +// To recreate: +// +// npx --package typescript tsc --module nodenext --target esnext --outDir test/fixtures/source-map/output --sourceMap test/fixtures/source-map/output/source_map_throw_construct.mts diff --git a/test/fixtures/source-map/output/source_map_throw_construct.snapshot b/test/fixtures/source-map/output/source_map_throw_construct.snapshot new file mode 100644 index 00000000000000..8618d4b51a46ec --- /dev/null +++ b/test/fixtures/source-map/output/source_map_throw_construct.snapshot @@ -0,0 +1,13 @@ +*output*source_map_throw_construct.mts:13 + throw new Error('message'); + ^ + + +Error: message + at new Foo (*output*source_map_throw_construct.mts:13:11) + at (*output*source_map_throw_construct.mts:17:1) + * + * + * + +Node.js * diff --git a/test/fixtures/source-map/output/source_map_throw_set_immediate.snapshot b/test/fixtures/source-map/output/source_map_throw_set_immediate.snapshot index d2d838ca35a3de..ec9f1346ca5e0c 100644 --- a/test/fixtures/source-map/output/source_map_throw_set_immediate.snapshot +++ b/test/fixtures/source-map/output/source_map_throw_set_immediate.snapshot @@ -6,6 +6,6 @@ Error: goodbye at Hello (*uglify-throw-original.js:5:9) at Immediate. (*uglify-throw-original.js:9:3) - at process.processImmediate (node:internal*timers:483:21) + * Node.js * diff --git a/test/fixtures/spawn-worker-with-copied-env.js b/test/fixtures/spawn-worker-with-copied-env.js index 51e64bd8755b6d..f33f86fcc6fe7c 100644 --- a/test/fixtures/spawn-worker-with-copied-env.js +++ b/test/fixtures/spawn-worker-with-copied-env.js @@ -2,7 +2,7 @@ // This test is meant to be spawned with NODE_OPTIONS=--title=foo const assert = require('assert'); -if (process.platform !== 'sunos') { // --title is unsupported on SmartOS. +if (process.platform !== 'sunos' && process.platform !== 'os400') { // --title is unsupported on SmartOS and IBM i. assert.strictEqual(process.title, 'foo'); } diff --git a/test/fixtures/test-runner-watch.mjs b/test/fixtures/test-runner-watch.mjs new file mode 100644 index 00000000000000..6780b31c541690 --- /dev/null +++ b/test/fixtures/test-runner-watch.mjs @@ -0,0 +1,24 @@ +import { run } from 'node:test'; +import { tap } from 'node:test/reporters'; +import { parseArgs } from 'node:util'; + +const options = { + file: { + type: 'string', + }, +}; +const { + values, + positionals, +} = parseArgs({ args: process.argv.slice(2), options }); + +let files; + +if (values.file) { + files = [values.file]; +} + +run({ + files, + watch: true +}).compose(tap).pipe(process.stdout); diff --git a/test/fixtures/test-runner/output/dot_output_custom_columns.js b/test/fixtures/test-runner/output/dot_output_custom_columns.js index 875ead9efc22a5..72a734f1e13361 100644 --- a/test/fixtures/test-runner/output/dot_output_custom_columns.js +++ b/test/fixtures/test-runner/output/dot_output_custom_columns.js @@ -1,6 +1,9 @@ // Flags: --test-reporter=dot 'use strict'; process.stdout.columns = 30; +process.env.FORCE_COLOR = '1'; +delete process.env.NODE_DISABLE_COLORS; +delete process.env.NO_COLOR; const test = require('node:test'); const { setTimeout } = require('timers/promises'); diff --git a/test/fixtures/test-runner/output/dot_output_custom_columns.snapshot b/test/fixtures/test-runner/output/dot_output_custom_columns.snapshot index 1aaaf3eb243ae4..b315dd77465a37 100644 --- a/test/fixtures/test-runner/output/dot_output_custom_columns.snapshot +++ b/test/fixtures/test-runner/output/dot_output_custom_columns.snapshot @@ -1,3 +1,3 @@ -.............................. -......................................... -............................. +[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c +[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c +[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c[32m.c diff --git a/test/fixtures/test-runner/snapshots/imported-tests.js b/test/fixtures/test-runner/snapshots/imported-tests.js new file mode 100644 index 00000000000000..85833bc86ec7c3 --- /dev/null +++ b/test/fixtures/test-runner/snapshots/imported-tests.js @@ -0,0 +1,8 @@ +'use strict'; +const { suite, test } = require('node:test'); + +suite('imported suite', () => { + test('imported test', (t) => { + t.assert.snapshot({ foo: 1, bar: 2 }); + }); +}); diff --git a/test/fixtures/test-runner/snapshots/unit.js b/test/fixtures/test-runner/snapshots/unit.js index 889b47f379a805..0ec7018c261c13 100644 --- a/test/fixtures/test-runner/snapshots/unit.js +++ b/test/fixtures/test-runner/snapshots/unit.js @@ -26,3 +26,5 @@ test('`${foo}`', async (t) => { test('escapes in `\\${foo}`\n', async (t) => { t.assert.snapshot('`\\${foo}`\n'); }); + +require('./imported-tests'); diff --git a/test/fixtures/typescript/cts/node_modules/bar/bar.ts b/test/fixtures/typescript/cts/node_modules/bar/bar.ts new file mode 100644 index 00000000000000..e0716bfd567a70 --- /dev/null +++ b/test/fixtures/typescript/cts/node_modules/bar/bar.ts @@ -0,0 +1,5 @@ +const bar: string = "Hello, TypeScript!"; + +module.exports = { + bar, +}; diff --git a/test/fixtures/typescript/cts/node_modules/bar/package.json b/test/fixtures/typescript/cts/node_modules/bar/package.json new file mode 100644 index 00000000000000..18ef424398b114 --- /dev/null +++ b/test/fixtures/typescript/cts/node_modules/bar/package.json @@ -0,0 +1,13 @@ +{ + "name": "bar", + "version": "1.0.0", + "main": "bar.ts", + "devDependencies": {}, + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [], + "author": "", + "license": "ISC", + "description": "" +} \ No newline at end of file diff --git a/test/fixtures/typescript/cts/node_modules/baz/baz.mts b/test/fixtures/typescript/cts/node_modules/baz/baz.mts new file mode 100644 index 00000000000000..746109acf8cede --- /dev/null +++ b/test/fixtures/typescript/cts/node_modules/baz/baz.mts @@ -0,0 +1 @@ +export const baz: string = 'Hello, TypeScript!'; diff --git a/test/fixtures/typescript/cts/node_modules/baz/package.json b/test/fixtures/typescript/cts/node_modules/baz/package.json new file mode 100644 index 00000000000000..5260f9a33d8156 --- /dev/null +++ b/test/fixtures/typescript/cts/node_modules/baz/package.json @@ -0,0 +1,14 @@ +{ + "name": "baz", + "version": "1.0.0", + "type": "module", + "main": "baz.mts", + "devDependencies": {}, + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [], + "author": "", + "license": "ISC", + "description": "" +} \ No newline at end of file diff --git a/test/fixtures/typescript/cts/node_modules/foo/foo.cts b/test/fixtures/typescript/cts/node_modules/foo/foo.cts new file mode 100644 index 00000000000000..c7dbc8680aa5a1 --- /dev/null +++ b/test/fixtures/typescript/cts/node_modules/foo/foo.cts @@ -0,0 +1,5 @@ +const foo: string = 'Hello, TypeScript!'; + +module.exports = { + foo +}; diff --git a/test/fixtures/typescript/cts/node_modules/foo/package.json b/test/fixtures/typescript/cts/node_modules/foo/package.json new file mode 100644 index 00000000000000..3036e618506c3b --- /dev/null +++ b/test/fixtures/typescript/cts/node_modules/foo/package.json @@ -0,0 +1,14 @@ +{ + "name": "foo", + "version": "1.0.0", + "type": "commonjs", + "main": "foo.cts", + "devDependencies": {}, + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [], + "author": "", + "license": "ISC", + "description": "" +} \ No newline at end of file diff --git a/test/fixtures/typescript/cts/test-commonjs-export.ts b/test/fixtures/typescript/cts/test-commonjs-export.ts new file mode 100644 index 00000000000000..27d36ea1fe4347 --- /dev/null +++ b/test/fixtures/typescript/cts/test-commonjs-export.ts @@ -0,0 +1,3 @@ +const foo: string = 'Hello, TypeScript!'; + +module.exports = { foo }; diff --git a/test/fixtures/typescript/cts/test-cts-but-module-syntax.cts b/test/fixtures/typescript/cts/test-cts-but-module-syntax.cts new file mode 100644 index 00000000000000..87c784633d267e --- /dev/null +++ b/test/fixtures/typescript/cts/test-cts-but-module-syntax.cts @@ -0,0 +1,5 @@ +import util from 'node:util'; + +export const text: string = 'Hello, TypeScript!'; + +console.log(util.styleText(['bold', 'red'], text)); diff --git a/test/fixtures/typescript/cts/test-cts-export-foo.cts b/test/fixtures/typescript/cts/test-cts-export-foo.cts new file mode 100644 index 00000000000000..27d36ea1fe4347 --- /dev/null +++ b/test/fixtures/typescript/cts/test-cts-export-foo.cts @@ -0,0 +1,3 @@ +const foo: string = 'Hello, TypeScript!'; + +module.exports = { foo }; diff --git a/test/fixtures/typescript/cts/test-cts-node_modules.cts b/test/fixtures/typescript/cts/test-cts-node_modules.cts new file mode 100644 index 00000000000000..d27bb40c6d6419 --- /dev/null +++ b/test/fixtures/typescript/cts/test-cts-node_modules.cts @@ -0,0 +1,5 @@ +const { foo } = require('foo'); + +interface Foo {}; + +console.log(foo); diff --git a/test/fixtures/typescript/cts/test-extensionless-require.ts b/test/fixtures/typescript/cts/test-extensionless-require.ts new file mode 100644 index 00000000000000..20e2ffdc7cfef4 --- /dev/null +++ b/test/fixtures/typescript/cts/test-extensionless-require.ts @@ -0,0 +1,3 @@ +const { foo } = require('./test-commonjs-export'); + +console.log(foo); diff --git a/test/fixtures/typescript/cts/test-mts-node_modules.cts b/test/fixtures/typescript/cts/test-mts-node_modules.cts new file mode 100644 index 00000000000000..125d98571adff1 --- /dev/null +++ b/test/fixtures/typescript/cts/test-mts-node_modules.cts @@ -0,0 +1,5 @@ +const { baz } = require('baz'); + +interface Foo { }; + +console.log(baz); diff --git a/test/fixtures/typescript/cts/test-require-commonjs.cts b/test/fixtures/typescript/cts/test-require-commonjs.cts new file mode 100644 index 00000000000000..ee0f4410d76a8c --- /dev/null +++ b/test/fixtures/typescript/cts/test-require-commonjs.cts @@ -0,0 +1,5 @@ +const { foo } = require('./test-cts-export-foo.cts'); + +interface Foo {}; + +console.log(foo); diff --git a/test/fixtures/typescript/cts/test-require-mts-module.cts b/test/fixtures/typescript/cts/test-require-mts-module.cts new file mode 100644 index 00000000000000..0b40b3b566bd13 --- /dev/null +++ b/test/fixtures/typescript/cts/test-require-mts-module.cts @@ -0,0 +1,5 @@ +const { foo } = require('../mts/test-mts-export-foo.mts'); + +interface Foo {}; + +console.log(foo); diff --git a/test/fixtures/typescript/cts/test-require-ts-file.cts b/test/fixtures/typescript/cts/test-require-ts-file.cts new file mode 100644 index 00000000000000..08015a6cdcb2fc --- /dev/null +++ b/test/fixtures/typescript/cts/test-require-ts-file.cts @@ -0,0 +1,5 @@ +const { foo } = require('./test-commonjs-export.ts'); + +interface Foo {}; + +console.log(foo); diff --git a/test/fixtures/typescript/cts/test-ts-node_modules.cts b/test/fixtures/typescript/cts/test-ts-node_modules.cts new file mode 100644 index 00000000000000..c565a00a9b57e5 --- /dev/null +++ b/test/fixtures/typescript/cts/test-ts-node_modules.cts @@ -0,0 +1,5 @@ +const { bar } = require('bar'); + +interface Foo { }; + +console.log(bar); diff --git a/test/fixtures/typescript/mts/node_modules/bar/bar.ts b/test/fixtures/typescript/mts/node_modules/bar/bar.ts new file mode 100644 index 00000000000000..a0f11c62ba8950 --- /dev/null +++ b/test/fixtures/typescript/mts/node_modules/bar/bar.ts @@ -0,0 +1,5 @@ +const bar: string = 'Hello, TypeScript!' + +module.exports = { + bar +}; diff --git a/test/fixtures/typescript/mts/node_modules/bar/package.json b/test/fixtures/typescript/mts/node_modules/bar/package.json new file mode 100644 index 00000000000000..18ef424398b114 --- /dev/null +++ b/test/fixtures/typescript/mts/node_modules/bar/package.json @@ -0,0 +1,13 @@ +{ + "name": "bar", + "version": "1.0.0", + "main": "bar.ts", + "devDependencies": {}, + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [], + "author": "", + "license": "ISC", + "description": "" +} \ No newline at end of file diff --git a/test/fixtures/typescript/mts/node_modules/baz/baz.mts b/test/fixtures/typescript/mts/node_modules/baz/baz.mts new file mode 100644 index 00000000000000..746109acf8cede --- /dev/null +++ b/test/fixtures/typescript/mts/node_modules/baz/baz.mts @@ -0,0 +1 @@ +export const baz: string = 'Hello, TypeScript!'; diff --git a/test/fixtures/typescript/mts/node_modules/baz/package.json b/test/fixtures/typescript/mts/node_modules/baz/package.json new file mode 100644 index 00000000000000..e44b74aa1824ca --- /dev/null +++ b/test/fixtures/typescript/mts/node_modules/baz/package.json @@ -0,0 +1,13 @@ +{ + "name": "baz", + "version": "1.0.0", + "main": "baz.mts", + "devDependencies": {}, + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [], + "author": "", + "license": "ISC", + "description": "" +} \ No newline at end of file diff --git a/test/fixtures/typescript/mts/node_modules/foo/foo.cts b/test/fixtures/typescript/mts/node_modules/foo/foo.cts new file mode 100644 index 00000000000000..c7dbc8680aa5a1 --- /dev/null +++ b/test/fixtures/typescript/mts/node_modules/foo/foo.cts @@ -0,0 +1,5 @@ +const foo: string = 'Hello, TypeScript!'; + +module.exports = { + foo +}; diff --git a/test/fixtures/typescript/mts/node_modules/foo/package.json b/test/fixtures/typescript/mts/node_modules/foo/package.json new file mode 100644 index 00000000000000..3036e618506c3b --- /dev/null +++ b/test/fixtures/typescript/mts/node_modules/foo/package.json @@ -0,0 +1,14 @@ +{ + "name": "foo", + "version": "1.0.0", + "type": "commonjs", + "main": "foo.cts", + "devDependencies": {}, + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [], + "author": "", + "license": "ISC", + "description": "" +} \ No newline at end of file diff --git a/test/fixtures/typescript/mts/test-cts-node_modules.mts b/test/fixtures/typescript/mts/test-cts-node_modules.mts new file mode 100644 index 00000000000000..410daa11b6881a --- /dev/null +++ b/test/fixtures/typescript/mts/test-cts-node_modules.mts @@ -0,0 +1,5 @@ +import { foo } from 'foo'; + +interface Foo { }; + +console.log(foo); diff --git a/test/fixtures/typescript/mts/test-import-commonjs.mts b/test/fixtures/typescript/mts/test-import-commonjs.mts new file mode 100644 index 00000000000000..1a18d4f4d93885 --- /dev/null +++ b/test/fixtures/typescript/mts/test-import-commonjs.mts @@ -0,0 +1,5 @@ +import { foo } from '../cts/test-cts-export-foo.cts'; + +interface Foo {}; + +console.log(foo); diff --git a/test/fixtures/typescript/mts/test-import-module.mts b/test/fixtures/typescript/mts/test-import-module.mts new file mode 100644 index 00000000000000..24e15fedae4edb --- /dev/null +++ b/test/fixtures/typescript/mts/test-import-module.mts @@ -0,0 +1,5 @@ +import { foo } from './test-mts-export-foo.mts'; + +interface Foo {}; + +console.log(foo); diff --git a/test/fixtures/typescript/mts/test-import-ts-file.mts b/test/fixtures/typescript/mts/test-import-ts-file.mts new file mode 100644 index 00000000000000..2cfc1a9156dccc --- /dev/null +++ b/test/fixtures/typescript/mts/test-import-ts-file.mts @@ -0,0 +1,5 @@ +import { foo } from './test-module-export.ts'; + +interface Foo {}; + +console.log(foo); diff --git a/test/fixtures/typescript/mts/test-module-export.ts b/test/fixtures/typescript/mts/test-module-export.ts new file mode 100644 index 00000000000000..4ed5c6cfde6867 --- /dev/null +++ b/test/fixtures/typescript/mts/test-module-export.ts @@ -0,0 +1 @@ +export const foo: string = 'Hello, TypeScript!'; diff --git a/test/fixtures/typescript/mts/test-mts-but-commonjs-syntax.mts b/test/fixtures/typescript/mts/test-mts-but-commonjs-syntax.mts new file mode 100644 index 00000000000000..bb2973190dd616 --- /dev/null +++ b/test/fixtures/typescript/mts/test-mts-but-commonjs-syntax.mts @@ -0,0 +1,9 @@ +const util = require('node:util'); + +const text: string = 'Hello, TypeScript!'; + +console.log(util.styleText(['bold', 'red'], text)); + +module.exports = { + text +}; diff --git a/test/fixtures/typescript/mts/test-mts-export-foo.mts b/test/fixtures/typescript/mts/test-mts-export-foo.mts new file mode 100644 index 00000000000000..4ed5c6cfde6867 --- /dev/null +++ b/test/fixtures/typescript/mts/test-mts-export-foo.mts @@ -0,0 +1 @@ +export const foo: string = 'Hello, TypeScript!'; diff --git a/test/fixtures/typescript/mts/test-mts-node_modules.mts b/test/fixtures/typescript/mts/test-mts-node_modules.mts new file mode 100644 index 00000000000000..8c49583f2046f0 --- /dev/null +++ b/test/fixtures/typescript/mts/test-mts-node_modules.mts @@ -0,0 +1,5 @@ +import { baz } from 'baz'; + +interface Foo {}; + +console.log(baz); diff --git a/test/fixtures/typescript/mts/test-ts-node_modules.mts b/test/fixtures/typescript/mts/test-ts-node_modules.mts new file mode 100644 index 00000000000000..fe4f3b743478de --- /dev/null +++ b/test/fixtures/typescript/mts/test-ts-node_modules.mts @@ -0,0 +1,5 @@ +import { bar } from 'bar'; + +interface Foo {}; + +console.log(bar); diff --git a/test/fixtures/typescript/ts/node_modules/bar/bar.ts b/test/fixtures/typescript/ts/node_modules/bar/bar.ts new file mode 100644 index 00000000000000..7e3a197411ce7e --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/bar/bar.ts @@ -0,0 +1,3 @@ +const bar: string = 'Hello, TypeScript!'; + +module.exports = { bar }; \ No newline at end of file diff --git a/test/fixtures/typescript/ts/node_modules/bar/package.json b/test/fixtures/typescript/ts/node_modules/bar/package.json new file mode 100644 index 00000000000000..ff1ab7524e4743 --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/bar/package.json @@ -0,0 +1,13 @@ +{ + "name": "bar", + "version": "1.0.0", + "main": "bar.ts", + "devDependencies": {}, + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [], + "author": "", + "license": "ISC", + "description": "" +} diff --git a/test/fixtures/typescript/ts/node_modules/foo/foo.js b/test/fixtures/typescript/ts/node_modules/foo/foo.js new file mode 100644 index 00000000000000..a4b27706c7b6e9 --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/foo/foo.js @@ -0,0 +1 @@ +export const foo = "Hello, TypeScript!" diff --git a/test/fixtures/typescript/ts/node_modules/foo/package.json b/test/fixtures/typescript/ts/node_modules/foo/package.json new file mode 100644 index 00000000000000..7182125d8b0e14 --- /dev/null +++ b/test/fixtures/typescript/ts/node_modules/foo/package.json @@ -0,0 +1,14 @@ +{ + "name": "foo", + "version": "1.0.0", + "type": "module", + "main": "foo.js", + "devDependencies": {}, + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [], + "author": "", + "license": "ISC", + "description": "" +} diff --git a/test/fixtures/typescript/ts/test-commonjs-parsing.ts b/test/fixtures/typescript/ts/test-commonjs-parsing.ts new file mode 100644 index 00000000000000..bb2973190dd616 --- /dev/null +++ b/test/fixtures/typescript/ts/test-commonjs-parsing.ts @@ -0,0 +1,9 @@ +const util = require('node:util'); + +const text: string = 'Hello, TypeScript!'; + +console.log(util.styleText(['bold', 'red'], text)); + +module.exports = { + text +}; diff --git a/test/fixtures/typescript/ts/test-cts-typescript.cts b/test/fixtures/typescript/ts/test-cts-typescript.cts new file mode 100644 index 00000000000000..45d056b9c94e3a --- /dev/null +++ b/test/fixtures/typescript/ts/test-cts-typescript.cts @@ -0,0 +1,5 @@ +const str: string = "Hello, TypeScript!"; +interface Foo { + bar: string; +} +console.log(str); diff --git a/test/fixtures/typescript/ts/test-empty-file.ts b/test/fixtures/typescript/ts/test-empty-file.ts new file mode 100644 index 00000000000000..8b137891791fe9 --- /dev/null +++ b/test/fixtures/typescript/ts/test-empty-file.ts @@ -0,0 +1 @@ + diff --git a/test/fixtures/typescript/ts/test-enums.ts b/test/fixtures/typescript/ts/test-enums.ts new file mode 100644 index 00000000000000..52fc4cfebd54e1 --- /dev/null +++ b/test/fixtures/typescript/ts/test-enums.ts @@ -0,0 +1,13 @@ +enum Color { + Red, + Green, + Blue, +} + +console.log(Color.Red); +console.log(Color.Green); +console.log(Color.Blue); + +console.log(Color[0]); +console.log(Color[1]); +console.log(Color[2]); diff --git a/test/fixtures/typescript/ts/test-experimental-decorators.ts b/test/fixtures/typescript/ts/test-experimental-decorators.ts new file mode 100644 index 00000000000000..073ceb0fbb1ff6 --- /dev/null +++ b/test/fixtures/typescript/ts/test-experimental-decorators.ts @@ -0,0 +1,14 @@ +function sealed(constructor: Function) { + Object.seal(constructor); + Object.seal(constructor.prototype); +} + +@sealed +class BugReport { + type = "report"; + title: string; + + constructor(t: string) { + this.title = t; + } +} diff --git a/test/fixtures/typescript/ts/test-export-foo.ts b/test/fixtures/typescript/ts/test-export-foo.ts new file mode 100644 index 00000000000000..3b94da93c43461 --- /dev/null +++ b/test/fixtures/typescript/ts/test-export-foo.ts @@ -0,0 +1 @@ +export const foo: string = "Hello, TypeScript!"; diff --git a/test/fixtures/typescript/ts/test-import-foo.ts b/test/fixtures/typescript/ts/test-import-foo.ts new file mode 100644 index 00000000000000..da66e19ef20e3b --- /dev/null +++ b/test/fixtures/typescript/ts/test-import-foo.ts @@ -0,0 +1,5 @@ +import { foo } from './test-export-foo.ts'; + +interface Foo {}; + +console.log(foo); diff --git a/test/fixtures/typescript/ts/test-import-fs.ts b/test/fixtures/typescript/ts/test-import-fs.ts new file mode 100644 index 00000000000000..032a93fa52eee5 --- /dev/null +++ b/test/fixtures/typescript/ts/test-import-fs.ts @@ -0,0 +1,2 @@ +import fs from 'fs'; +console.log('Hello, TypeScript!'); diff --git a/test/fixtures/typescript/ts/test-import-no-extension.ts b/test/fixtures/typescript/ts/test-import-no-extension.ts new file mode 100644 index 00000000000000..738ceddbaade44 --- /dev/null +++ b/test/fixtures/typescript/ts/test-import-no-extension.ts @@ -0,0 +1,5 @@ +import { foo } from './test-no-extensions'; + +interface Foo {}; + +console.log(foo); diff --git a/test/fixtures/typescript/ts/test-import-no-type-keyword.ts b/test/fixtures/typescript/ts/test-import-no-type-keyword.ts new file mode 100644 index 00000000000000..278eb3e032931f --- /dev/null +++ b/test/fixtures/typescript/ts/test-import-no-type-keyword.ts @@ -0,0 +1,7 @@ +import { MyType } from './test-types.d.ts'; + +const myVar: MyType = { + foo: 'Hello, TypeScript!' +}; + +console.log(myVar.foo); diff --git a/test/fixtures/typescript/ts/test-import-ts-node-modules.ts b/test/fixtures/typescript/ts/test-import-ts-node-modules.ts new file mode 100644 index 00000000000000..864987c7cf0f60 --- /dev/null +++ b/test/fixtures/typescript/ts/test-import-ts-node-modules.ts @@ -0,0 +1,5 @@ +import { bar } from 'bar'; + +interface Bar {}; + +console.log(bar); diff --git a/test/fixtures/typescript/ts/test-import-types.ts b/test/fixtures/typescript/ts/test-import-types.ts new file mode 100644 index 00000000000000..ec32b315636a73 --- /dev/null +++ b/test/fixtures/typescript/ts/test-import-types.ts @@ -0,0 +1,7 @@ +import type { MyType } from './test-types.d.ts'; + +const myVar: MyType = { + foo: 'Hello, TypeScript!' +}; + +console.log(myVar.foo); diff --git a/test/fixtures/typescript/ts/test-module-typescript.ts b/test/fixtures/typescript/ts/test-module-typescript.ts new file mode 100644 index 00000000000000..145910853cbdfa --- /dev/null +++ b/test/fixtures/typescript/ts/test-module-typescript.ts @@ -0,0 +1,5 @@ +import util from 'node:util'; + +export const text: string = 'Hello, TypeScript!'; + +console.log(util.styleText("red", text)); diff --git a/test/fixtures/typescript/ts/test-namespaces.ts b/test/fixtures/typescript/ts/test-namespaces.ts new file mode 100644 index 00000000000000..eb4e4b3961402c --- /dev/null +++ b/test/fixtures/typescript/ts/test-namespaces.ts @@ -0,0 +1,9 @@ +/// +namespace Validation { + const lettersRegexp = /^[A-Za-z]+$/; + export class LettersOnlyValidator { + isAcceptable(s: string) { + return lettersRegexp.test(s); + } + } +} diff --git a/test/fixtures/typescript/ts/test-no-extensions.ts b/test/fixtures/typescript/ts/test-no-extensions.ts new file mode 100644 index 00000000000000..4ed5c6cfde6867 --- /dev/null +++ b/test/fixtures/typescript/ts/test-no-extensions.ts @@ -0,0 +1 @@ +export const foo: string = 'Hello, TypeScript!'; diff --git a/test/fixtures/typescript/ts/test-require-cts.ts b/test/fixtures/typescript/ts/test-require-cts.ts new file mode 100644 index 00000000000000..46efff06169fe8 --- /dev/null +++ b/test/fixtures/typescript/ts/test-require-cts.ts @@ -0,0 +1,5 @@ +const { foo } = require('../cts/test-cts-export-foo.cts'); + +interface Foo {}; + +console.log(foo); diff --git a/test/fixtures/typescript/ts/test-require-module.ts b/test/fixtures/typescript/ts/test-require-module.ts new file mode 100644 index 00000000000000..52dc9d4c631e35 --- /dev/null +++ b/test/fixtures/typescript/ts/test-require-module.ts @@ -0,0 +1,3 @@ +const { foo } = require('../mts/test-mts-export-foo.mts'); + +console.log(foo); diff --git a/test/fixtures/typescript/ts/test-require-mts.ts b/test/fixtures/typescript/ts/test-require-mts.ts new file mode 100644 index 00000000000000..2048760b78b68e --- /dev/null +++ b/test/fixtures/typescript/ts/test-require-mts.ts @@ -0,0 +1,5 @@ +const { foo } = require('../mts/test-mts-export-foo.mts'); + +interface Foo { }; + +console.log(foo); diff --git a/test/fixtures/typescript/ts/test-types.d.ts b/test/fixtures/typescript/ts/test-types.d.ts new file mode 100644 index 00000000000000..d048d12d1fdb62 --- /dev/null +++ b/test/fixtures/typescript/ts/test-types.d.ts @@ -0,0 +1,3 @@ +export type MyType = { + foo: string; +}; diff --git a/test/fixtures/typescript/ts/test-typescript-node-modules.ts b/test/fixtures/typescript/ts/test-typescript-node-modules.ts new file mode 100644 index 00000000000000..8c16fd8873029e --- /dev/null +++ b/test/fixtures/typescript/ts/test-typescript-node-modules.ts @@ -0,0 +1,3 @@ +import { foo } from 'foo'; + +console.log(foo); diff --git a/test/fixtures/typescript/ts/test-typescript.ts b/test/fixtures/typescript/ts/test-typescript.ts new file mode 100644 index 00000000000000..41338c9845eba6 --- /dev/null +++ b/test/fixtures/typescript/ts/test-typescript.ts @@ -0,0 +1,5 @@ +const str: string = "Hello, TypeScript!"; +interface Foo { + bar: string; +} +console.log(str); diff --git a/test/fixtures/typescript/ts/test-whitespacing.ts b/test/fixtures/typescript/ts/test-whitespacing.ts new file mode 100644 index 00000000000000..63bdd1648f9303 --- /dev/null +++ b/test/fixtures/typescript/ts/test-whitespacing.ts @@ -0,0 +1,5 @@ +interface Foo { + bar: string; +} + +throw new Error("Whitespacing"); diff --git a/test/js-native-api/common.h b/test/js-native-api/common.h index 1308088e7872fb..49cdc066ea6f34 100644 --- a/test/js-native-api/common.h +++ b/test/js-native-api/common.h @@ -23,7 +23,7 @@ } \ } while (0) -// The nogc version of GET_AND_THROW_LAST_ERROR. We cannot access any +// The basic version of GET_AND_THROW_LAST_ERROR. We cannot access any // exceptions and we cannot fail by way of JS exception, so we abort. #define FATALLY_FAIL_WITH_LAST_ERROR(env) \ do { \ @@ -47,7 +47,7 @@ } \ } while (0) -#define NODE_API_NOGC_ASSERT_BASE(assertion, message, ret_val) \ +#define NODE_API_BASIC_ASSERT_BASE(assertion, message, ret_val) \ do { \ if (!(assertion)) { \ fprintf(stderr, "assertion (" #assertion ") failed: " message); \ @@ -66,8 +66,8 @@ #define NODE_API_ASSERT_RETURN_VOID(env, assertion, message) \ NODE_API_ASSERT_BASE(env, assertion, message, NODE_API_RETVAL_NOTHING) -#define NODE_API_NOGC_ASSERT_RETURN_VOID(assertion, message) \ - NODE_API_NOGC_ASSERT_BASE(assertion, message, NODE_API_RETVAL_NOTHING) +#define NODE_API_BASIC_ASSERT_RETURN_VOID(assertion, message) \ + NODE_API_BASIC_ASSERT_BASE(assertion, message, NODE_API_RETVAL_NOTHING) #define NODE_API_CALL_BASE(env, the_call, ret_val) \ do { \ @@ -77,7 +77,7 @@ } \ } while (0) -#define NODE_API_NOGC_CALL_BASE(env, the_call, ret_val) \ +#define NODE_API_BASIC_CALL_BASE(env, the_call, ret_val) \ do { \ if ((the_call) != napi_ok) { \ FATALLY_FAIL_WITH_LAST_ERROR((env)); \ @@ -93,8 +93,8 @@ #define NODE_API_CALL_RETURN_VOID(env, the_call) \ NODE_API_CALL_BASE(env, the_call, NODE_API_RETVAL_NOTHING) -#define NODE_API_NOGC_CALL_RETURN_VOID(env, the_call) \ - NODE_API_NOGC_CALL_BASE(env, the_call, NODE_API_RETVAL_NOTHING) +#define NODE_API_BASIC_CALL_RETURN_VOID(env, the_call) \ + NODE_API_BASIC_CALL_BASE(env, the_call, NODE_API_RETVAL_NOTHING) #define NODE_API_CHECK_STATUS(the_call) \ do { \ diff --git a/test/js-native-api/test_cannot_run_js/test_cannot_run_js.c b/test/js-native-api/test_cannot_run_js/test_cannot_run_js.c index 813e59918e7b3a..9a4b9547493505 100644 --- a/test/js-native-api/test_cannot_run_js/test_cannot_run_js.c +++ b/test/js-native-api/test_cannot_run_js/test_cannot_run_js.c @@ -7,10 +7,10 @@ static void Finalize(napi_env env, void* data, void* hint) { napi_value global, set_timeout; napi_ref* ref = data; - NODE_API_NOGC_ASSERT_RETURN_VOID( + NODE_API_BASIC_ASSERT_RETURN_VOID( napi_delete_reference(env, *ref) == napi_ok, "deleting reference in finalizer should succeed"); - NODE_API_NOGC_ASSERT_RETURN_VOID( + NODE_API_BASIC_ASSERT_RETURN_VOID( napi_get_global(env, &global) == napi_ok, "getting global reference in finalizer should succeed"); napi_status result = @@ -23,12 +23,12 @@ static void Finalize(napi_env env, void* data, void* hint) { // the point of view of the addon. #ifdef NAPI_EXPERIMENTAL - NODE_API_NOGC_ASSERT_RETURN_VOID( + NODE_API_BASIC_ASSERT_RETURN_VOID( result == napi_cannot_run_js || result == napi_ok, "getting named property from global in finalizer should succeed " "or return napi_cannot_run_js"); #else - NODE_API_NOGC_ASSERT_RETURN_VOID( + NODE_API_BASIC_ASSERT_RETURN_VOID( result == napi_pending_exception || result == napi_ok, "getting named property from global in finalizer should succeed " "or return napi_pending_exception"); @@ -36,9 +36,9 @@ static void Finalize(napi_env env, void* data, void* hint) { free(ref); } -static void NogcFinalize(node_api_nogc_env env, void* data, void* hint) { +static void BasicFinalize(node_api_basic_env env, void* data, void* hint) { #ifdef NAPI_EXPERIMENTAL - NODE_API_NOGC_CALL_RETURN_VOID( + NODE_API_BASIC_CALL_RETURN_VOID( env, node_api_post_finalizer(env, Finalize, data, hint)); #else Finalize(env, data, hint); @@ -55,7 +55,8 @@ static napi_value CreateRef(napi_env env, napi_callback_info info) { NODE_API_CALL(env, napi_typeof(env, cb, &value_type)); NODE_API_ASSERT( env, value_type == napi_function, "argument must be function"); - NODE_API_CALL(env, napi_add_finalizer(env, cb, ref, NogcFinalize, NULL, ref)); + NODE_API_CALL(env, + napi_add_finalizer(env, cb, ref, BasicFinalize, NULL, ref)); return cb; } diff --git a/test/js-native-api/test_finalizer/test_finalizer.c b/test/js-native-api/test_finalizer/test_finalizer.c index b9b046484a5288..721ca12c7bb9dc 100644 --- a/test/js-native-api/test_finalizer/test_finalizer.c +++ b/test/js-native-api/test_finalizer/test_finalizer.c @@ -11,17 +11,17 @@ typedef struct { napi_ref js_func; } FinalizerData; -static void finalizerOnlyCallback(node_api_nogc_env env, +static void finalizerOnlyCallback(node_api_basic_env env, void* finalize_data, void* finalize_hint) { FinalizerData* data = (FinalizerData*)finalize_data; int32_t count = ++data->finalize_count; // It is safe to access instance data - NODE_API_NOGC_CALL_RETURN_VOID(env, - napi_get_instance_data(env, (void**)&data)); - NODE_API_NOGC_ASSERT_RETURN_VOID(count = data->finalize_count, - "Expected to be the same FinalizerData"); + NODE_API_BASIC_CALL_RETURN_VOID(env, + napi_get_instance_data(env, (void**)&data)); + NODE_API_BASIC_ASSERT_RETURN_VOID(count = data->finalize_count, + "Expected to be the same FinalizerData"); } static void finalizerCallingJSCallback(napi_env env, @@ -40,20 +40,20 @@ static void finalizerCallingJSCallback(napi_env env, } // Schedule async finalizer to run JavaScript-touching code. -static void finalizerWithJSCallback(node_api_nogc_env env, +static void finalizerWithJSCallback(node_api_basic_env env, void* finalize_data, void* finalize_hint) { - NODE_API_NOGC_CALL_RETURN_VOID( + NODE_API_BASIC_CALL_RETURN_VOID( env, node_api_post_finalizer( env, finalizerCallingJSCallback, finalize_data, finalize_hint)); } -static void finalizerWithFailedJSCallback(node_api_nogc_env nogc_env, +static void finalizerWithFailedJSCallback(node_api_basic_env basic_env, void* finalize_data, void* finalize_hint) { // Intentionally cast to a napi_env to test the fatal failure. - napi_env env = (napi_env)nogc_env; + napi_env env = (napi_env)basic_env; napi_value obj; FinalizerData* data = (FinalizerData*)finalize_data; ++data->finalize_count; diff --git a/test/js-native-api/test_string/test_string.c b/test/js-native-api/test_string/test_string.c index 48d70bedde554b..57353b9f6303f2 100644 --- a/test/js-native-api/test_string/test_string.c +++ b/test/js-native-api/test_string/test_string.c @@ -87,7 +87,7 @@ static napi_value TestTwoByteImpl(napi_env env, return output; } -static void free_string(node_api_nogc_env env, void* data, void* hint) { +static void free_string(node_api_basic_env env, void* data, void* hint) { free(data); } diff --git a/test/node-api/test_reference_by_node_api_version/test_reference_by_node_api_version.c b/test/node-api/test_reference_by_node_api_version/test_reference_by_node_api_version.c index f9110303d2ded4..d1a871949951b2 100644 --- a/test/node-api/test_reference_by_node_api_version/test_reference_by_node_api_version.c +++ b/test/node-api/test_reference_by_node_api_version/test_reference_by_node_api_version.c @@ -4,12 +4,12 @@ static uint32_t finalizeCount = 0; -static void FreeData(node_api_nogc_env env, void* data, void* hint) { - NODE_API_NOGC_ASSERT_RETURN_VOID(data != NULL, "Expects non-NULL data."); +static void FreeData(node_api_basic_env env, void* data, void* hint) { + NODE_API_BASIC_ASSERT_RETURN_VOID(data != NULL, "Expects non-NULL data."); free(data); } -static void Finalize(node_api_nogc_env env, void* data, void* hint) { +static void Finalize(node_api_basic_env env, void* data, void* hint) { ++finalizeCount; } diff --git a/test/parallel/parallel.status b/test/parallel/parallel.status index e30209a1c36794..831f543f8e01d2 100644 --- a/test/parallel/parallel.status +++ b/test/parallel/parallel.status @@ -19,6 +19,9 @@ test-fs-read-stream-concurrent-reads: PASS, FLAKY # https://github.com/nodejs/node/issues/52630 test-error-serdes: PASS, FLAKY +# https://github.com/nodejs/node/issues/54006 +test-sqlite: PASS, FLAKY + [$system==win32] # Windows on x86 @@ -47,6 +50,8 @@ test-inspector-async-stack-traces-set-interval: PASS, FLAKY # https://github.com/nodejs/node/pull/31178 test-crypto-dh-stateless: SKIP test-crypto-keygen: SKIP +# https://github.com/nodejs/node/issues/52963 +test-pipe-file-to-http: PASS, FLAKY [$system==solaris] # Also applies to SmartOS # https://github.com/nodejs/node/issues/43457 diff --git a/test/parallel/test-assert-esm-cjs-message-verify.js b/test/parallel/test-assert-esm-cjs-message-verify.js index 9a66d83abd9c4b..23c48800923e87 100644 --- a/test/parallel/test-assert-esm-cjs-message-verify.js +++ b/test/parallel/test-assert-esm-cjs-message-verify.js @@ -1,51 +1,31 @@ 'use strict'; const { spawnPromisified } = require('../common'); -const tmpdir = require('../common/tmpdir'); -const assert = require('assert'); -const { writeFileSync, unlink } = require('fs'); -const { describe, after, it } = require('node:test'); - -tmpdir.refresh(); +const assert = require('node:assert'); +const { describe, it } = require('node:test'); const fileImports = { - cjs: 'const assert = require("assert");', - mjs: 'import assert from "assert";', + commonjs: 'const assert = require("assert");', + module: 'import assert from "assert";', }; -const fileNames = []; - -for (const [ext, header] of Object.entries(fileImports)) { - const fileName = `test-file.${ext}`; - // Store the generated filesnames in an array - fileNames.push(`${tmpdir.path}/${fileName}`); - - writeFileSync(tmpdir.resolve(fileName), `${header}\nassert.ok(0 === 2);`); -} - describe('ensure the assert.ok throwing similar error messages for esm and cjs files', () => { - const nodejsPath = `${process.execPath}`; - const errorsMessages = []; - it('should return code 1 for each command', async () => { - for (const fileName of fileNames) { - const { stderr, code } = await spawnPromisified(nodejsPath, [fileName]); + const errorsMessages = []; + for (const [inputType, header] of Object.entries(fileImports)) { + const { stderr, code } = await spawnPromisified(process.execPath, [ + '--input-type', + inputType, + '--eval', + `${header}\nassert.ok(0 === 2);\n`, + ]); assert.strictEqual(code, 1); // For each error message, filter the lines which will starts with AssertionError errorsMessages.push( stderr.split('\n').find((s) => s.startsWith('AssertionError')) ); } - }); - - after(() => { assert.strictEqual(errorsMessages.length, 2); assert.deepStrictEqual(errorsMessages[0], errorsMessages[1]); - - for (const fileName of fileNames) { - unlink(fileName, () => {}); - } - - tmpdir.refresh(); }); }); diff --git a/test/parallel/test-assert.js b/test/parallel/test-assert.js index 2964a475c81436..1679edb2941808 100644 --- a/test/parallel/test-assert.js +++ b/test/parallel/test-assert.js @@ -55,6 +55,16 @@ assert.throws(() => a.ok(false), a.AssertionError, 'ok(false)'); assert.ok(threw, 'Error: ok(false)'); } +// Errors created in different contexts are handled as any other custom error +{ + const context = vm.createContext(); + const error = vm.runInContext('new SyntaxError("custom error")', context); + + assert.throws(() => assert(false, error), { + message: 'custom error', + name: 'SyntaxError' + }); +} a(true); a('test', 'ok(\'test\')'); diff --git a/test/parallel/test-blob-file-backed.js b/test/parallel/test-blob-file-backed.js index 0532bda07b6e80..2e143e6936f748 100644 --- a/test/parallel/test-blob-file-backed.js +++ b/test/parallel/test-blob-file-backed.js @@ -21,13 +21,17 @@ const tmpdir = require('../common/tmpdir'); const testfile = tmpdir.resolve('test-file-backed-blob.txt'); const testfile2 = tmpdir.resolve('test-file-backed-blob2.txt'); const testfile3 = tmpdir.resolve('test-file-backed-blob3.txt'); +const testfile4 = tmpdir.resolve('test-file-backed-blob4.txt'); +const testfile5 = tmpdir.resolve('test-file-backed-blob5.txt'); tmpdir.refresh(); const data = `${'a'.repeat(1000)}${'b'.repeat(2000)}`; writeFileSync(testfile, data); -writeFileSync(testfile2, data.repeat(100)); -writeFileSync(testfile3, ''); +writeFileSync(testfile2, data); +writeFileSync(testfile3, data.repeat(100)); +writeFileSync(testfile4, ''); +writeFileSync(testfile5, ''); (async () => { const blob = await openAsBlob(testfile); @@ -69,7 +73,7 @@ writeFileSync(testfile3, ''); (async () => { // Refs: https://github.com/nodejs/node/issues/47683 - const blob = await openAsBlob(testfile); + const blob = await openAsBlob(testfile2); const res = blob.slice(10, 20); const ab = await res.arrayBuffer(); strictEqual(res.size, ab.byteLength); @@ -82,39 +86,51 @@ writeFileSync(testfile3, ''); const res1 = blob.slice(995, 1005); strictEqual(await res1.text(), data.slice(995, 1005)); + + // Refs: https://github.com/nodejs/node/issues/53908 + for (const res2 of [ + blob.slice(995, 1005).slice(), + blob.slice(995).slice(0, 10), + blob.slice(0, 1005).slice(995), + ]) { + strictEqual(await res2.text(), data.slice(995, 1005)); + } + + await unlink(testfile2); })().then(common.mustCall()); (async () => { - const blob = await openAsBlob(testfile2); + const blob = await openAsBlob(testfile3); const stream = blob.stream(); const read = async () => { // eslint-disable-next-line no-unused-vars for await (const _ of stream) { - writeFileSync(testfile2, data + 'abc'); + writeFileSync(testfile3, data + 'abc'); } }; await rejects(read(), { name: 'NotReadableError' }); - await unlink(testfile2); + await unlink(testfile3); })().then(common.mustCall()); (async () => { - const blob = await openAsBlob(testfile3); + const blob = await openAsBlob(testfile4); strictEqual(blob.size, 0); strictEqual(await blob.text(), ''); - writeFileSync(testfile3, 'abc'); + writeFileSync(testfile4, 'abc'); await rejects(blob.text(), { name: 'NotReadableError' }); - await unlink(testfile3); + await unlink(testfile4); })().then(common.mustCall()); (async () => { - const blob = await openAsBlob(testfile3); + const blob = await openAsBlob(testfile5); strictEqual(blob.size, 0); - writeFileSync(testfile3, 'abc'); + writeFileSync(testfile5, 'abc'); const stream = blob.stream(); const reader = stream.getReader(); await rejects(() => reader.read(), { name: 'NotReadableError' }); + await unlink(testfile5); })().then(common.mustCall()); (async () => { diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js index a8846913101e12..db59734207a7d8 100644 --- a/test/parallel/test-bootstrap-modules.js +++ b/test/parallel/test-bootstrap-modules.js @@ -128,6 +128,7 @@ if (common.isMainThread) { 'NativeModule internal/streams/compose', 'NativeModule internal/streams/destroy', 'NativeModule internal/streams/duplex', + 'NativeModule internal/streams/duplexpair', 'NativeModule internal/streams/end-of-stream', 'NativeModule internal/streams/from', 'NativeModule internal/streams/legacy', diff --git a/test/parallel/test-child-process-cwd.js b/test/parallel/test-child-process-cwd.js index b527b7f9ea8012..e876361b167ffb 100644 --- a/test/parallel/test-child-process-cwd.js +++ b/test/parallel/test-child-process-cwd.js @@ -52,7 +52,14 @@ function testCwd(options, expectPidType, expectCode = 0, expectData) { }); child.on('close', common.mustCall(function() { - expectData && assert.strictEqual(data.trim(), expectData); + if (expectData) { + // In Windows, compare without considering case + if (common.isWindows) { + assert.strictEqual(data.trim().toLowerCase(), expectData.toLowerCase()); + } else { + assert.strictEqual(data.trim(), expectData); + } + } })); return child; diff --git a/test/parallel/test-child-process-prototype-tampering.mjs b/test/parallel/test-child-process-prototype-tampering.mjs index 5657458f911521..d94c4bdbc61621 100644 --- a/test/parallel/test-child-process-prototype-tampering.mjs +++ b/test/parallel/test-child-process-prototype-tampering.mjs @@ -1,7 +1,7 @@ import * as common from '../common/index.mjs'; import * as fixtures from '../common/fixtures.mjs'; import { EOL } from 'node:os'; -import { strictEqual } from 'node:assert'; +import { strictEqual, notStrictEqual, throws } from 'node:assert'; import cp from 'node:child_process'; // TODO(LiviaMedeiros): test on different platforms @@ -57,3 +57,35 @@ for (const tamperedUID of [0, 1, 999, 1000, 0n, 'gwak']) { delete Object.prototype.execPath; } + +for (const shellCommandArgument of ['-L && echo "tampered"']) { + Object.prototype.shell = true; + const cmd = 'pwd'; + let cmdExitCode = ''; + + const program = cp.spawn(cmd, [shellCommandArgument], { cwd: expectedCWD }); + program.stderr.on('data', common.mustCall()); + program.stdout.on('data', common.mustNotCall()); + + program.on('exit', common.mustCall((code) => { + notStrictEqual(code, 0); + })); + + cp.execFile(cmd, [shellCommandArgument], { cwd: expectedCWD }, + common.mustCall((err) => { + notStrictEqual(err.code, 0); + }) + ); + + throws(() => { + cp.execFileSync(cmd, [shellCommandArgument], { cwd: expectedCWD }); + }, (e) => { + notStrictEqual(e.status, 0); + return true; + }); + + cmdExitCode = cp.spawnSync(cmd, [shellCommandArgument], { cwd: expectedCWD }).status; + notStrictEqual(cmdExitCode, 0); + + delete Object.prototype.shell; +} diff --git a/test/parallel/test-console-with-frozen-intrinsics.js b/test/parallel/test-console-with-frozen-intrinsics.js new file mode 100644 index 00000000000000..1da2a6a5fb9eaa --- /dev/null +++ b/test/parallel/test-console-with-frozen-intrinsics.js @@ -0,0 +1,30 @@ +// flags: --frozen-intrinsics +'use strict'; +require('../common'); +console.clear(); + +const consoleMethods = ['log', 'info', 'warn', 'error', 'debug', 'trace']; + +for (const method of consoleMethods) { + console[method]('foo'); + console[method]('foo', 'bar'); + console[method]('%s %s', 'foo', 'bar', 'hop'); +} + +console.dir({ slashes: '\\\\' }); +console.dirxml({ slashes: '\\\\' }); + +console.time('label'); +console.timeLog('label', 'hi'); +console.timeEnd('label'); + +console.assert(true, 'true'); + +console.count('label'); +console.countReset('label'); + +console.group('label'); +console.groupCollapsed('label'); +console.groupEnd(); + +console.table([{ a: 1, b: 2 }, { a: 'foo', b: 'bar' }]); diff --git a/test/parallel/test-crypto-prime.js b/test/parallel/test-crypto-prime.js index f0ec4efaf611c8..209c8251f78053 100644 --- a/test/parallel/test-crypto-prime.js +++ b/test/parallel/test-crypto-prime.js @@ -1,3 +1,4 @@ +// Flags: --expose-internals 'use strict'; const common = require('../common'); diff --git a/test/parallel/test-diagnostics-channel-http.js b/test/parallel/test-diagnostics-channel-http.js index c2e84444e2866e..e134b9ac05a85d 100644 --- a/test/parallel/test-diagnostics-channel-http.js +++ b/test/parallel/test-diagnostics-channel-http.js @@ -1,5 +1,6 @@ 'use strict'; const common = require('../common'); +const { addresses } = require('../common/internet'); const assert = require('assert'); const http = require('http'); const net = require('net'); @@ -9,9 +10,15 @@ const isHTTPServer = (server) => server instanceof http.Server; const isIncomingMessage = (object) => object instanceof http.IncomingMessage; const isOutgoingMessage = (object) => object instanceof http.OutgoingMessage; const isNetSocket = (socket) => socket instanceof net.Socket; +const isError = (error) => error instanceof Error; dc.subscribe('http.client.request.start', common.mustCall(({ request }) => { assert.strictEqual(isOutgoingMessage(request), true); +}, 2)); + +dc.subscribe('http.client.request.error', common.mustCall(({ request, error }) => { + assert.strictEqual(isOutgoingMessage(request), true); + assert.strictEqual(isError(error), true); })); dc.subscribe('http.client.response.finish', common.mustCall(({ @@ -50,8 +57,14 @@ const server = http.createServer(common.mustCall((req, res) => { res.end('done'); })); -server.listen(() => { +server.listen(async () => { const { port } = server.address(); + const invalidRequest = http.get({ + host: addresses.INVALID_HOST, + }); + await new Promise((resolve) => { + invalidRequest.on('error', resolve); + }); http.get(`http://localhost:${port}`, (res) => { res.resume(); res.on('end', () => { diff --git a/test/parallel/test-diagnostics-channel-tracing-channel-has-subscribers.js b/test/parallel/test-diagnostics-channel-tracing-channel-has-subscribers.js new file mode 100644 index 00000000000000..2ae25d9848c82c --- /dev/null +++ b/test/parallel/test-diagnostics-channel-tracing-channel-has-subscribers.js @@ -0,0 +1,51 @@ +'use strict'; + +const common = require('../common'); +const dc = require('diagnostics_channel'); +const assert = require('assert'); + +const handler = common.mustNotCall(); + +{ + const handlers = { + start: common.mustNotCall() + }; + + const channel = dc.tracingChannel('test'); + + assert.strictEqual(channel.hasSubscribers, false); + + channel.subscribe(handlers); + assert.strictEqual(channel.hasSubscribers, true); + + channel.unsubscribe(handlers); + assert.strictEqual(channel.hasSubscribers, false); + + channel.start.subscribe(handler); + assert.strictEqual(channel.hasSubscribers, true); + + channel.start.unsubscribe(handler); + assert.strictEqual(channel.hasSubscribers, false); +} + +{ + const handlers = { + asyncEnd: common.mustNotCall() + }; + + const channel = dc.tracingChannel('test'); + + assert.strictEqual(channel.hasSubscribers, false); + + channel.subscribe(handlers); + assert.strictEqual(channel.hasSubscribers, true); + + channel.unsubscribe(handlers); + assert.strictEqual(channel.hasSubscribers, false); + + channel.asyncEnd.subscribe(handler); + assert.strictEqual(channel.hasSubscribers, true); + + channel.asyncEnd.unsubscribe(handler); + assert.strictEqual(channel.hasSubscribers, false); +} diff --git a/test/parallel/test-dotenv.js b/test/parallel/test-dotenv.js index 88afd58b5d766e..3c81bf98782a97 100644 --- a/test/parallel/test-dotenv.js +++ b/test/parallel/test-dotenv.js @@ -80,3 +80,5 @@ assert.strictEqual(process.env.DONT_EXPAND_UNQUOTED, 'dontexpand\\nnewlines'); assert.strictEqual(process.env.DONT_EXPAND_SQUOTED, 'dontexpand\\nnewlines'); // Ignore export before key assert.strictEqual(process.env.EXPORT_EXAMPLE, 'ignore export'); +// Ignore spaces before double quotes to avoid quoted strings as value +assert.strictEqual(process.env.SPACE_BEFORE_DOUBLE_QUOTES, 'space before double quotes'); diff --git a/test/parallel/test-fs-glob.mjs b/test/parallel/test-fs-glob.mjs index 7dcb8ecc8373a3..4038c0e165eb69 100644 --- a/test/parallel/test-fs-glob.mjs +++ b/test/parallel/test-fs-glob.mjs @@ -342,7 +342,11 @@ describe('glob - withFileTypes', function() { const promisified = promisify(glob); for (const [pattern, expected] of Object.entries(patterns)) { test(pattern, async () => { - const actual = await promisified(pattern, { cwd: fixtureDir, withFileTypes: true }); + const actual = await promisified(pattern, { + cwd: fixtureDir, + withFileTypes: true, + exclude: (dirent) => assert.ok(dirent instanceof Dirent), + }); assertDirents(actual); const normalized = expected.filter(Boolean).map((item) => basename(item)).sort(); assert.deepStrictEqual(actual.map((dirent) => dirent.name).sort(), normalized.sort()); @@ -353,7 +357,11 @@ describe('glob - withFileTypes', function() { describe('globSync - withFileTypes', function() { for (const [pattern, expected] of Object.entries(patterns)) { test(pattern, () => { - const actual = globSync(pattern, { cwd: fixtureDir, withFileTypes: true }); + const actual = globSync(pattern, { + cwd: fixtureDir, + withFileTypes: true, + exclude: (dirent) => assert.ok(dirent instanceof Dirent), + }); assertDirents(actual); const normalized = expected.filter(Boolean).map((item) => basename(item)).sort(); assert.deepStrictEqual(actual.map((dirent) => dirent.name).sort(), normalized.sort()); @@ -365,7 +373,11 @@ describe('fsPromises glob - withFileTypes', function() { for (const [pattern, expected] of Object.entries(patterns)) { test(pattern, async () => { const actual = []; - for await (const item of asyncGlob(pattern, { cwd: fixtureDir, withFileTypes: true })) actual.push(item); + for await (const item of asyncGlob(pattern, { + cwd: fixtureDir, + withFileTypes: true, + exclude: (dirent) => assert.ok(dirent instanceof Dirent), + })) actual.push(item); assertDirents(actual); const normalized = expected.filter(Boolean).map((item) => basename(item)).sort(); assert.deepStrictEqual(actual.map((dirent) => dirent.name).sort(), normalized.sort()); diff --git a/test/parallel/test-gc-tls-external-memory.js b/test/parallel/test-gc-tls-external-memory.js index 2b584dd93dcf5b..752986019e0362 100644 --- a/test/parallel/test-gc-tls-external-memory.js +++ b/test/parallel/test-gc-tls-external-memory.js @@ -8,7 +8,7 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); const onGC = require('../common/ongc'); const assert = require('assert'); const tls = require('tls'); @@ -37,7 +37,7 @@ function connect() { return; } - const { clientSide, serverSide } = makeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); const tlsSocket = tls.connect({ socket: clientSide }); tlsSocket.on('error', common.mustCall(connect)); diff --git a/test/parallel/test-http-agent-domain-reused-gc.js b/test/parallel/test-http-agent-domain-reused-gc.js index b63c2d20210c37..35146ee688eb9b 100644 --- a/test/parallel/test-http-agent-domain-reused-gc.js +++ b/test/parallel/test-http-agent-domain-reused-gc.js @@ -3,7 +3,7 @@ const common = require('../common'); const http = require('http'); const async_hooks = require('async_hooks'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); // Regression test for https://github.com/nodejs/node/issues/30122 // When a domain is attached to an http Agent’s ReusedHandle object, that @@ -36,7 +36,7 @@ async_hooks.createHook({ // attached to too many objects that use strong references (timers, the network // socket handle, etc.) and wrap the client side in a JSStreamSocket so we don’t // have to implement the whole _handle API ourselves. -const { serverSide, clientSide } = makeDuplexPair(); +const [ serverSide, clientSide ] = duplexPair(); const JSStreamSocket = require('internal/js_stream_socket'); const wrappedClientSide = new JSStreamSocket(clientSide); diff --git a/test/parallel/test-http-generic-streams.js b/test/parallel/test-http-generic-streams.js index 706cba7b385957..1b2bc209c97121 100644 --- a/test/parallel/test-http-generic-streams.js +++ b/test/parallel/test-http-generic-streams.js @@ -2,7 +2,7 @@ const common = require('../common'); const assert = require('assert'); const http = require('http'); -const MakeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); // Test 1: Simple HTTP test, no keep-alive. { @@ -13,7 +13,7 @@ const MakeDuplexPair = require('../common/duplexpair'); res.end(testData); })); - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); server.emit('connection', serverSide); const req = http.request({ @@ -37,7 +37,7 @@ const MakeDuplexPair = require('../common/duplexpair'); res.end(testData); }, 2)); - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); server.emit('connection', serverSide); function doRequest(cb) { @@ -77,7 +77,7 @@ const MakeDuplexPair = require('../common/duplexpair'); }); })); - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); server.emit('connection', serverSide); clientSide.on('end', common.mustCall()); serverSide.on('end', common.mustCall()); @@ -117,7 +117,7 @@ const MakeDuplexPair = require('../common/duplexpair'); })); - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); server.emit('connection', serverSide); clientSide.on('end', common.mustCall()); serverSide.on('end', common.mustCall()); @@ -143,7 +143,7 @@ const MakeDuplexPair = require('../common/duplexpair'); { const server = http.createServer(common.mustNotCall()); - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); server.emit('connection', serverSide); server.on('clientError', common.mustCall()); diff --git a/test/parallel/test-http-insecure-parser-per-stream.js b/test/parallel/test-http-insecure-parser-per-stream.js index daee5811724eb6..5024b93af3d194 100644 --- a/test/parallel/test-http-insecure-parser-per-stream.js +++ b/test/parallel/test-http-insecure-parser-per-stream.js @@ -2,13 +2,13 @@ const common = require('../common'); const assert = require('assert'); const http = require('http'); -const MakeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); // Test that setting the `maxHeaderSize` option works on a per-stream-basis. // Test 1: The server sends an invalid header. { - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); const req = http.request({ createConnection: common.mustCall(() => clientSide), @@ -30,7 +30,7 @@ const MakeDuplexPair = require('../common/duplexpair'); // Test 2: The same as Test 1 except without the option, to make sure it fails. { - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); const req = http.request({ createConnection: common.mustCall(() => clientSide) @@ -59,7 +59,7 @@ const MakeDuplexPair = require('../common/duplexpair'); server.on('clientError', common.mustNotCall()); - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); serverSide.server = server; server.emit('connection', serverSide); @@ -75,7 +75,7 @@ const MakeDuplexPair = require('../common/duplexpair'); server.on('clientError', common.mustCall()); - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); serverSide.server = server; server.emit('connection', serverSide); diff --git a/test/parallel/test-http-max-header-size-per-stream.js b/test/parallel/test-http-max-header-size-per-stream.js index c043fce21a8425..9ef794e718389e 100644 --- a/test/parallel/test-http-max-header-size-per-stream.js +++ b/test/parallel/test-http-max-header-size-per-stream.js @@ -2,13 +2,13 @@ const common = require('../common'); const assert = require('assert'); const http = require('http'); -const MakeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); // Test that setting the `maxHeaderSize` option works on a per-stream-basis. // Test 1: The server sends larger headers than what would otherwise be allowed. { - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); const req = http.request({ createConnection: common.mustCall(() => clientSide), @@ -29,7 +29,7 @@ const MakeDuplexPair = require('../common/duplexpair'); // Test 2: The same as Test 1 except without the option, to make sure it fails. { - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); const req = http.request({ createConnection: common.mustCall(() => clientSide) @@ -57,7 +57,7 @@ const MakeDuplexPair = require('../common/duplexpair'); server.on('clientError', common.mustNotCall()); - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); serverSide.server = server; server.emit('connection', serverSide); @@ -73,7 +73,7 @@ const MakeDuplexPair = require('../common/duplexpair'); server.on('clientError', common.mustCall()); - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); serverSide.server = server; server.emit('connection', serverSide); diff --git a/test/parallel/test-http-sync-write-error-during-continue.js b/test/parallel/test-http-sync-write-error-during-continue.js index f77026b00b5131..87bbc515833c27 100644 --- a/test/parallel/test-http-sync-write-error-during-continue.js +++ b/test/parallel/test-http-sync-write-error-during-continue.js @@ -2,14 +2,14 @@ const common = require('../common'); const assert = require('assert'); const http = require('http'); -const MakeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); // Regression test for the crash reported in // https://github.com/nodejs/node/issues/15102 (httpParser.finish() is called // during httpParser.execute()): { - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); serverSide.on('data', common.mustCall((data) => { assert.strictEqual(data.toString('utf8'), `\ diff --git a/test/parallel/test-http2-backpressure.js b/test/parallel/test-http2-backpressure.js index 1f9687831eb1a8..40f147924407fe 100644 --- a/test/parallel/test-http2-backpressure.js +++ b/test/parallel/test-http2-backpressure.js @@ -7,7 +7,7 @@ if (!common.hasCrypto) common.skip('missing crypto'); const assert = require('assert'); const http2 = require('http2'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); { let req; @@ -28,7 +28,7 @@ const makeDuplexPair = require('../common/duplexpair'); assert.strictEqual(stream.write('A'.repeat(40)), false); })); - const { clientSide, serverSide } = makeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); server.emit('connection', serverSide); const client = http2.connect('http://localhost:80', { diff --git a/test/parallel/test-http2-generic-streams-sendfile.js b/test/parallel/test-http2-generic-streams-sendfile.js index b752b0fdcb815a..dab5175e93e744 100644 --- a/test/parallel/test-http2-generic-streams-sendfile.js +++ b/test/parallel/test-http2-generic-streams-sendfile.js @@ -5,7 +5,7 @@ if (!common.hasCrypto) const assert = require('assert'); const http2 = require('http2'); const fs = require('fs'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); { const server = http2.createServer(); @@ -13,7 +13,7 @@ const makeDuplexPair = require('../common/duplexpair'); stream.respondWithFile(__filename); })); - const { clientSide, serverSide } = makeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); server.emit('connection', serverSide); const client = http2.connect('http://localhost:80', { diff --git a/test/parallel/test-http2-generic-streams.js b/test/parallel/test-http2-generic-streams.js index d97e86a5ecea55..85affcc8464290 100644 --- a/test/parallel/test-http2-generic-streams.js +++ b/test/parallel/test-http2-generic-streams.js @@ -4,7 +4,7 @@ if (!common.hasCrypto) common.skip('missing crypto'); const assert = require('assert'); const http2 = require('http2'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); { const testData = '

Hello World

'; @@ -17,7 +17,7 @@ const makeDuplexPair = require('../common/duplexpair'); stream.end(testData); })); - const { clientSide, serverSide } = makeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); server.emit('connection', serverSide); const client = http2.connect('http://localhost:80', { diff --git a/test/parallel/test-http2-padding-aligned.js b/test/parallel/test-http2-padding-aligned.js index f687c02a98dc6e..0229985436185f 100644 --- a/test/parallel/test-http2-padding-aligned.js +++ b/test/parallel/test-http2-padding-aligned.js @@ -6,7 +6,7 @@ if (!common.hasCrypto) const assert = require('assert'); const http2 = require('http2'); const { PADDING_STRATEGY_ALIGNED, PADDING_STRATEGY_CALLBACK } = http2.constants; -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); { const testData = '

Hello World.

'; @@ -21,7 +21,7 @@ const makeDuplexPair = require('../common/duplexpair'); stream.end(testData); })); - const { clientSide, serverSide } = makeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); // The lengths of the expected writes... note that this is highly // sensitive to how the internals are implemented. diff --git a/test/parallel/test-http2-perform-server-handshake.js b/test/parallel/test-http2-perform-server-handshake.js index b7fa67ec59d8fa..9cee5926238aab 100644 --- a/test/parallel/test-http2-perform-server-handshake.js +++ b/test/parallel/test-http2-perform-server-handshake.js @@ -8,11 +8,11 @@ if (!common.hasCrypto) const assert = require('assert'); const http2 = require('http2'); const stream = require('stream'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); // Basic test { - const { clientSide, serverSide } = makeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); const client = http2.connect('http://example.com', { createConnection: () => clientSide, diff --git a/test/parallel/test-http2-sensitive-headers.js b/test/parallel/test-http2-sensitive-headers.js index 7d4d775a55d4c2..aadedc1ba831b5 100644 --- a/test/parallel/test-http2-sensitive-headers.js +++ b/test/parallel/test-http2-sensitive-headers.js @@ -4,7 +4,7 @@ if (!common.hasCrypto) common.skip('missing crypto'); const assert = require('assert'); const http2 = require('http2'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); { const testData = '

Hello World

'; @@ -22,7 +22,7 @@ const makeDuplexPair = require('../common/duplexpair'); stream.end(testData); })); - const { clientSide, serverSide } = makeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); server.emit('connection', serverSide); const client = http2.connect('http://localhost:80', { diff --git a/test/parallel/test-http2-session-gc-while-write-scheduled.js b/test/parallel/test-http2-session-gc-while-write-scheduled.js index aef9d9571d5559..62379f7d7ed678 100644 --- a/test/parallel/test-http2-session-gc-while-write-scheduled.js +++ b/test/parallel/test-http2-session-gc-while-write-scheduled.js @@ -5,7 +5,7 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); const http2 = require('http2'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); const tick = require('../common/tick'); // This tests that running garbage collection while an Http2Session has @@ -14,7 +14,7 @@ const tick = require('../common/tick'); { // This creates a session and schedules a write (for the settings frame). let client = http2.connect('http://localhost:80', { - createConnection: common.mustCall(() => makeDuplexPair().clientSide) + createConnection: common.mustCall(() => duplexPair()[0]) }); // First, wait for any nextTicks() and their responses diff --git a/test/parallel/test-http2-session-unref.js b/test/parallel/test-http2-session-unref.js index 8afd659d33baa8..4b41d5cbc2a602 100644 --- a/test/parallel/test-http2-session-unref.js +++ b/test/parallel/test-http2-session-unref.js @@ -8,10 +8,10 @@ if (!common.hasCrypto) common.skip('missing crypto'); const http2 = require('http2'); const Countdown = require('../common/countdown'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); const server = http2.createServer(); -const { clientSide, serverSide } = makeDuplexPair(); +const [ clientSide, serverSide ] = duplexPair(); const counter = new Countdown(3, () => server.unref()); diff --git a/test/parallel/test-http2-write-finishes-after-stream-destroy.js b/test/parallel/test-http2-write-finishes-after-stream-destroy.js index 3b2dd4bcd4e548..ed8833fdb926b1 100644 --- a/test/parallel/test-http2-write-finishes-after-stream-destroy.js +++ b/test/parallel/test-http2-write-finishes-after-stream-destroy.js @@ -5,14 +5,14 @@ if (!common.hasCrypto) common.skip('missing crypto'); const assert = require('assert'); const http2 = require('http2'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); // Make sure the Http2Stream destructor works, since we don't clean the // stream up like we would otherwise do. process.on('exit', global.gc); { - const { clientSide, serverSide } = makeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); let serverSideHttp2Stream; let serverSideHttp2StreamDestroyed = false; diff --git a/test/parallel/test-https-insecure-parse-per-stream.js b/test/parallel/test-https-insecure-parse-per-stream.js index 73e69d056913aa..5b21c9953067d6 100644 --- a/test/parallel/test-https-insecure-parse-per-stream.js +++ b/test/parallel/test-https-insecure-parse-per-stream.js @@ -7,9 +7,8 @@ if (!common.hasCrypto) { const fixtures = require('../common/fixtures'); const assert = require('assert'); const https = require('https'); -const MakeDuplexPair = require('../common/duplexpair'); const tls = require('tls'); -const { finished } = require('stream'); +const { finished, duplexPair } = require('stream'); const certFixture = { key: fixtures.readKey('agent1-key.pem'), @@ -22,7 +21,7 @@ const certFixture = { // Test 1: The server sends an invalid header. { - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); const req = https.request({ rejectUnauthorized: false, @@ -45,7 +44,7 @@ const certFixture = { // Test 2: The same as Test 1 except without the option, to make sure it fails. { - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); const req = https.request({ rejectUnauthorized: false, diff --git a/test/parallel/test-https-max-header-size-per-stream.js b/test/parallel/test-https-max-header-size-per-stream.js index f10fced777c2f4..3929169679ca48 100644 --- a/test/parallel/test-https-max-header-size-per-stream.js +++ b/test/parallel/test-https-max-header-size-per-stream.js @@ -10,8 +10,7 @@ const assert = require('assert'); const https = require('https'); const http = require('http'); const tls = require('tls'); -const MakeDuplexPair = require('../common/duplexpair'); -const { finished } = require('stream'); +const { finished, duplexPair } = require('stream'); const certFixture = { key: fixtures.readKey('agent1-key.pem'), @@ -24,7 +23,7 @@ const certFixture = { // Test 1: The server sends larger headers than what would otherwise be allowed. { - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); const req = https.request({ createConnection: common.mustCall(() => clientSide), @@ -46,7 +45,7 @@ const certFixture = { // Test 2: The same as Test 1 except without the option, to make sure it fails. { - const { clientSide, serverSide } = MakeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); const req = https.request({ createConnection: common.mustCall(() => clientSide) diff --git a/test/parallel/test-inspector-emit-protocol-event.js b/test/parallel/test-inspector-emit-protocol-event.js new file mode 100644 index 00000000000000..1a4e622c78881b --- /dev/null +++ b/test/parallel/test-inspector-emit-protocol-event.js @@ -0,0 +1,85 @@ +// Flags: --inspect=0 --experimental-network-inspection +'use strict'; +const common = require('../common'); + +common.skipIfInspectorDisabled(); + +const inspector = require('node:inspector/promises'); +const assert = require('node:assert'); + +const EXPECTED_EVENTS = { + Network: [ + { + name: 'requestWillBeSent', + params: { + requestId: 'request-id-1', + request: { + url: 'https://nodejs.org/en', + method: 'GET' + }, + timestamp: 1000, + wallTime: 1000, + } + }, + { + name: 'responseReceived', + params: { + requestId: 'request-id-1', + timestamp: 1000, + } + }, + { + name: 'loadingFinished', + params: { + requestId: 'request-id-1', + timestamp: 1000, + } + }, + ] +}; + +// Check that all domains and events are present in the inspector object. +for (const [domain, events] of Object.entries(EXPECTED_EVENTS)) { + if (!(domain in inspector)) { + assert.fail(`Expected domain ${domain} to be present in inspector`); + } + const actualEventNames = Object.keys(inspector[domain]); + const expectedEventNames = events.map((event) => event.name); + assert.deepStrictEqual(actualEventNames, expectedEventNames, `Expected ${domain} to have events ${expectedEventNames}, but got ${actualEventNames}`); +} + +// Check that all events throw when called with a non-object argument. +for (const [domain, events] of Object.entries(EXPECTED_EVENTS)) { + for (const event of events) { + assert.throws(() => inspector[domain][event.name]('params'), { + name: 'TypeError', + code: 'ERR_INVALID_ARG_TYPE', + message: 'The "params" argument must be of type object. Received type string (\'params\')' + }); + } +} + +const runAsyncTest = async () => { + const session = new inspector.Session(); + session.connect(); + + // Check that all events emit the expected parameters. + await session.post('Network.enable'); + for (const [domain, events] of Object.entries(EXPECTED_EVENTS)) { + for (const event of events) { + session.on(`${domain}.${event.name}`, common.mustCall(({ params }) => { + assert.deepStrictEqual(params, event.params); + })); + inspector[domain][event.name](event.params); + } + } + + // Check tht no events are emitted after disabling the domain. + await session.post('Network.disable'); + session.on('Network.requestWillBeSent', common.mustNotCall()); + inspector.Network.requestWillBeSent({}); +}; + +runAsyncTest().then(common.mustCall()).catch((e) => { + assert.fail(e); +}); diff --git a/test/parallel/test-inspector-network-domain.js b/test/parallel/test-inspector-network-domain.js new file mode 100644 index 00000000000000..1dc0d4f65a216e --- /dev/null +++ b/test/parallel/test-inspector-network-domain.js @@ -0,0 +1,120 @@ +// Flags: --inspect=0 --experimental-network-inspection +'use strict'; +const common = require('../common'); + +common.skipIfInspectorDisabled(); + +const assert = require('node:assert'); +const fixtures = require('../common/fixtures'); +const http = require('node:http'); +const https = require('node:https'); +const inspector = require('node:inspector/promises'); + +const session = new inspector.Session(); +session.connect(); + +const httpServer = http.createServer((req, res) => { + const path = req.url; + switch (path) { + case '/hello-world': + res.writeHead(200); + res.end('hello world\n'); + break; + default: + assert(false, `Unexpected path: ${path}`); + } +}); + +const httpsServer = https.createServer({ + key: fixtures.readKey('agent1-key.pem'), + cert: fixtures.readKey('agent1-cert.pem') +}, (req, res) => { + const path = req.url; + switch (path) { + case '/hello-world': + res.writeHead(200); + res.end('hello world\n'); + break; + default: + assert(false, `Unexpected path: ${path}`); + } +}); + +const terminate = () => { + session.disconnect(); + httpServer.close(); + httpsServer.close(); + inspector.close(); +}; + +const testHttpGet = () => new Promise((resolve, reject) => { + session.on('Network.requestWillBeSent', common.mustCall(({ params }) => { + assert.ok(params.requestId.startsWith('node-network-event-')); + assert.strictEqual(params.request.url, 'http://127.0.0.1/hello-world'); + assert.strictEqual(params.request.method, 'GET'); + assert.strictEqual(typeof params.timestamp, 'number'); + assert.strictEqual(typeof params.wallTime, 'number'); + })); + session.on('Network.responseReceived', common.mustCall(({ params }) => { + assert.ok(params.requestId.startsWith('node-network-event-')); + assert.strictEqual(typeof params.timestamp, 'number'); + })); + session.on('Network.loadingFinished', common.mustCall(({ params }) => { + assert.ok(params.requestId.startsWith('node-network-event-')); + assert.strictEqual(typeof params.timestamp, 'number'); + resolve(); + })); + + http.get({ + host: '127.0.0.1', + port: httpServer.address().port, + path: '/hello-world', + }, common.mustCall()); +}); + +const testHttpsGet = () => new Promise((resolve, reject) => { + session.on('Network.requestWillBeSent', common.mustCall(({ params }) => { + assert.ok(params.requestId.startsWith('node-network-event-')); + assert.strictEqual(params.request.url, 'https://127.0.0.1/hello-world'); + assert.strictEqual(params.request.method, 'GET'); + assert.strictEqual(typeof params.timestamp, 'number'); + assert.strictEqual(typeof params.wallTime, 'number'); + })); + session.on('Network.responseReceived', common.mustCall(({ params }) => { + assert.ok(params.requestId.startsWith('node-network-event-')); + assert.strictEqual(typeof params.timestamp, 'number'); + })); + session.on('Network.loadingFinished', common.mustCall(({ params }) => { + assert.ok(params.requestId.startsWith('node-network-event-')); + assert.strictEqual(typeof params.timestamp, 'number'); + resolve(); + })); + + https.get({ + host: '127.0.0.1', + port: httpsServer.address().port, + path: '/hello-world', + rejectUnauthorized: false, + }, common.mustCall()); +}); + +const testNetworkInspection = async () => { + await testHttpGet(); + session.removeAllListeners(); + await testHttpsGet(); + session.removeAllListeners(); +}; + +httpServer.listen(0, () => { + httpsServer.listen(0, async () => { + try { + await session.post('Network.enable'); + await testNetworkInspection(); + await session.post('Network.disable'); + } catch (e) { + assert.fail(e); + } finally { + terminate(); + } + }); +}); diff --git a/test/parallel/test-module-print-timing.mjs b/test/parallel/test-module-print-timing.mjs index 0cb7189d3114af..124ac5e2763e8c 100644 --- a/test/parallel/test-module-print-timing.mjs +++ b/test/parallel/test-module-print-timing.mjs @@ -16,7 +16,7 @@ it('should print the timing information for cjs', () => { }, }, { stdout: '', - stderr: (result) => result.includes('MODULE_TIMER'), + stderr: /MODULE_TIMER/g, }); const firstLine = result.stderr.split('\n').find((line) => line.includes('[url]')); @@ -74,7 +74,7 @@ it('should write tracing & print logs for cjs', async () => { }, }, { stdout: '', - stderr: (result) => result.includes('MODULE_TIMER'), + stderr: /MODULE_TIMER/g, }); const firstLine = result.stderr.split('\n').find((line) => line.includes('[url]')); @@ -89,7 +89,67 @@ it('should write tracing & print logs for cjs', async () => { const outputFileJson = JSON.parse(outputFileContent).traceEvents; const urlTraces = outputFileJson.filter((trace) => trace.name === "require('url')"); + assert.ok(urlTraces.length > 0, 'Not found url traces'); + for (const trace of urlTraces) { assert.strictEqual(trace.ph, expectedMimeTypes.shift()); } }); + +it('should support enable tracing dynamically', async () => { + try { + spawnSyncAndAssert(process.execPath, [ + '--eval', + 'require("trace_events")', + ], { + stdout: '', + stderr: '', + }); + } catch { + // Skip this test if the trace_events module is not available + return; + } + + + const outputFile = tmpdir.resolve('output-dynamic-trace.log'); + const jsScript = ` + const traceEvents = require("trace_events"); + const tracing = traceEvents.createTracing({ categories: ["node.module_timer"] }); + + tracing.enable(); + require("http"); + tracing.disable(); + + require("vm"); + `; + + spawnSyncAndAssert(process.execPath, [ + '--trace-event-file-pattern', + outputFile, + '--eval', + jsScript, + ], { + cwd: tmpdir.path, + env: { + ...process.env, + }, + }, { + stdout: '', + stderr: '', + }); + + const expectedMimeTypes = ['b', 'e']; + const outputFileContent = await readFile(outputFile, 'utf-8'); + + const outputFileJson = JSON.parse(outputFileContent).traceEvents; + const httpTraces = outputFileJson.filter((trace) => trace.name === "require('http')"); + + assert.ok(httpTraces.length > 0, 'Not found http traces'); + + for (const trace of httpTraces) { + assert.strictEqual(trace.ph, expectedMimeTypes.shift()); + } + + const vmTraces = outputFileJson.filter((trace) => trace.name === "require('vm')"); + assert.strictEqual(vmTraces.length, 0); +}); diff --git a/test/parallel/test-node-output-sourcemaps.mjs b/test/parallel/test-node-output-sourcemaps.mjs index d82f4a249cd1d9..e9104db220867f 100644 --- a/test/parallel/test-node-output-sourcemaps.mjs +++ b/test/parallel/test-node-output-sourcemaps.mjs @@ -13,7 +13,7 @@ describe('sourcemaps output', { concurrency: !process.env.TEST_PARALLEL }, () => .replaceAll(/\/(\w)/g, '*$1') .replaceAll('*test*', '*') .replaceAll('*fixtures*source-map*', '*') - .replaceAll(/(\W+).*node:internal\*modules.*/g, '$1*'); + .replaceAll(/(\W+).*node:.*/g, '$1*'); if (common.isWindows) { const currentDeviceLetter = path.parse(process.cwd()).root.substring(0, 1).toLowerCase(); const regex = new RegExp(`${currentDeviceLetter}:/?`, 'gi'); @@ -34,7 +34,9 @@ describe('sourcemaps output', { concurrency: !process.env.TEST_PARALLEL }, () => { name: 'source-map/output/source_map_prepare_stack_trace.js' }, { name: 'source-map/output/source_map_reference_error_tabs.js' }, { name: 'source-map/output/source_map_sourcemapping_url_string.js' }, + { name: 'source-map/output/source_map_throw_async_stack_trace.mjs' }, { name: 'source-map/output/source_map_throw_catch.js' }, + { name: 'source-map/output/source_map_throw_construct.mjs' }, { name: 'source-map/output/source_map_throw_first_tick.js' }, { name: 'source-map/output/source_map_throw_icu.js' }, { name: 'source-map/output/source_map_throw_set_immediate.js' }, diff --git a/test/parallel/test-process-exit-code.js b/test/parallel/test-process-exit-code.js index 51d23c35c5665e..1049f372d7219e 100644 --- a/test/parallel/test-process-exit-code.js +++ b/test/parallel/test-process-exit-code.js @@ -24,7 +24,7 @@ require('../common'); const assert = require('assert'); const debug = require('util').debuglog('test'); -const { getTestCases } = require('../fixtures/process-exit-code-cases'); +const { getTestCases } = require('../common/process-exit-code-cases'); const testCases = getTestCases(false); if (!process.argv[2]) { diff --git a/test/parallel/test-process-versions.js b/test/parallel/test-process-versions.js index bab483a7e2637e..41186c1a1afe08 100644 --- a/test/parallel/test-process-versions.js +++ b/test/parallel/test-process-versions.js @@ -24,6 +24,7 @@ const expected_keys = [ 'ada', 'cjs_module_lexer', 'nbytes', + 'amaro', ]; const hasUndici = process.config.variables.node_builtin_shareable_builtins.includes('deps/undici/undici.js'); @@ -34,6 +35,7 @@ if (hasUndici) { if (common.hasCrypto) { expected_keys.push('openssl'); + expected_keys.push('ncrypto'); } if (common.hasQuic) { @@ -78,6 +80,7 @@ assert.match(process.versions.modules, /^\d+$/); assert.match(process.versions.cjs_module_lexer, commonTemplate); if (common.hasCrypto) { + assert.match(process.versions.ncrypto, commonTemplate); if (process.config.variables.node_shared_openssl) { assert.ok(process.versions.openssl); } else { diff --git a/test/parallel/test-runner-mock-timers.js b/test/parallel/test-runner-mock-timers.js index 6ce6c28c95e326..3e8d2d79ede52b 100644 --- a/test/parallel/test-runner-mock-timers.js +++ b/test/parallel/test-runner-mock-timers.js @@ -257,6 +257,13 @@ describe('Mock Timers Test Suite', () => { assert.strictEqual(fn.mock.callCount(), 0); }); + + it('clearTimeout does not throw on null and undefined', (t) => { + t.mock.timers.enable({ apis: ['setTimeout'] }); + + nodeTimers.clearTimeout(); + nodeTimers.clearTimeout(null); + }); }); describe('setInterval Suite', () => { @@ -305,6 +312,13 @@ describe('Mock Timers Test Suite', () => { assert.strictEqual(fn.mock.callCount(), 0); }); + + it('clearInterval does not throw on null and undefined', (t) => { + t.mock.timers.enable({ apis: ['setInterval'] }); + + nodeTimers.clearInterval(); + nodeTimers.clearInterval(null); + }); }); describe('setImmediate Suite', () => { @@ -372,6 +386,15 @@ describe('Mock Timers Test Suite', () => { }); }); + describe('clearImmediate Suite', () => { + it('clearImmediate does not throw on null and undefined', (t) => { + t.mock.timers.enable({ apis: ['setImmediate'] }); + + nodeTimers.clearImmediate(); + nodeTimers.clearImmediate(null); + }); + }); + describe('timers/promises', () => { describe('setTimeout Suite', () => { it('should advance in time and trigger timers when calling the .tick function multiple times', async (t) => { diff --git a/test/parallel/test-runner-run-files-undefined.mjs b/test/parallel/test-runner-run-files-undefined.mjs new file mode 100644 index 00000000000000..9d08b10a4550cd --- /dev/null +++ b/test/parallel/test-runner-run-files-undefined.mjs @@ -0,0 +1,61 @@ +import * as common from '../common/index.mjs'; +import tmpdir from '../common/tmpdir.js'; +import { describe, it, run, beforeEach } from 'node:test'; +import { dot, spec, tap } from 'node:test/reporters'; +import { fork } from 'node:child_process'; +import assert from 'node:assert'; + +if (common.hasCrypto) { + console.log('1..0 # Skipped: no crypto'); + process.exit(0); +} + +if (process.env.CHILD === 'true') { + describe('require(\'node:test\').run with no files', { concurrency: true }, () => { + beforeEach(() => { + tmpdir.refresh(); + process.chdir(tmpdir.path); + }); + + it('should neither pass or fail', async () => { + const stream = run({ + files: undefined + }).compose(tap); + stream.on('test:fail', common.mustNotCall()); + stream.on('test:pass', common.mustNotCall()); + + // eslint-disable-next-line no-unused-vars + for await (const _ of stream); + }); + + it('can use the spec reporter', async () => { + const stream = run({ + files: undefined + }).compose(spec); + stream.on('test:fail', common.mustNotCall()); + stream.on('test:pass', common.mustNotCall()); + + // eslint-disable-next-line no-unused-vars + for await (const _ of stream); + }); + + it('can use the dot reporter', async () => { + const stream = run({ + files: undefined + }).compose(dot); + stream.on('test:fail', common.mustNotCall()); + stream.on('test:pass', common.mustNotCall()); + + // eslint-disable-next-line no-unused-vars + for await (const _ of stream); + }); + }); +} else if (common.isAIX) { + console.log('1..0 # Skipped: test runner without specifying files fails on AIX'); +} else { + fork(import.meta.filename, [], { + env: { CHILD: 'true' } + }).on('exit', common.mustCall((code) => { + assert.strictEqual(code, 0); + })); +} diff --git a/test/parallel/test-runner-run-watch.mjs b/test/parallel/test-runner-run-watch.mjs new file mode 100644 index 00000000000000..0445637bb6123c --- /dev/null +++ b/test/parallel/test-runner-run-watch.mjs @@ -0,0 +1,175 @@ +// Flags: --expose-internals +import * as common from '../common/index.mjs'; +import { describe, it, beforeEach } from 'node:test'; +import assert from 'node:assert'; +import { spawn } from 'node:child_process'; +import { once } from 'node:events'; +import { writeFileSync, renameSync, unlinkSync, existsSync } from 'node:fs'; +import util from 'internal/util'; +import tmpdir from '../common/tmpdir.js'; +import { join } from 'node:path'; + +if (common.isIBMi) + common.skip('IBMi does not support `fs.watch()`'); + +// This test updates these files repeatedly, +// Reading them from disk is unreliable due to race conditions. +const fixtureContent = { + 'dependency.js': 'module.exports = {};', + 'dependency.mjs': 'export const a = 1;', + 'test.js': ` +const test = require('node:test'); +require('./dependency.js'); +import('./dependency.mjs'); +import('data:text/javascript,'); +test('test has ran');`, +}; + +let fixturePaths; + +function refresh() { + tmpdir.refresh(); + + fixturePaths = Object.keys(fixtureContent) + .reduce((acc, file) => ({ ...acc, [file]: tmpdir.resolve(file) }), {}); + Object.entries(fixtureContent) + .forEach(([file, content]) => writeFileSync(fixturePaths[file], content)); +} + +const runner = join(import.meta.dirname, '..', 'fixtures', 'test-runner-watch.mjs'); + +async function testWatch({ fileToUpdate, file, action = 'update', cwd = tmpdir.path }) { + const ran1 = util.createDeferredPromise(); + const ran2 = util.createDeferredPromise(); + const args = [runner]; + if (file) args.push('--file', file); + const child = spawn(process.execPath, + args, + { encoding: 'utf8', stdio: 'pipe', cwd }); + let stdout = ''; + let currentRun = ''; + const runs = []; + + child.stdout.on('data', (data) => { + stdout += data.toString(); + currentRun += data.toString(); + const testRuns = stdout.match(/# duration_ms\s\d+/g); + if (testRuns?.length >= 1) ran1.resolve(); + if (testRuns?.length >= 2) ran2.resolve(); + }); + + const testUpdate = async () => { + await ran1.promise; + const content = fixtureContent[fileToUpdate]; + const path = fixturePaths[fileToUpdate]; + const interval = setInterval(() => writeFileSync(path, content), common.platformTimeout(1000)); + await ran2.promise; + runs.push(currentRun); + clearInterval(interval); + child.kill(); + await once(child, 'exit'); + for (const run of runs) { + assert.doesNotMatch(run, /run\(\) is being called recursively/); + assert.match(run, /# tests 1/); + assert.match(run, /# pass 1/); + assert.match(run, /# fail 0/); + assert.match(run, /# cancelled 0/); + } + }; + + const testRename = async () => { + await ran1.promise; + const fileToRenamePath = tmpdir.resolve(fileToUpdate); + const newFileNamePath = tmpdir.resolve(`test-renamed-${fileToUpdate}`); + const interval = setInterval(() => renameSync(fileToRenamePath, newFileNamePath), common.platformTimeout(1000)); + await ran2.promise; + runs.push(currentRun); + clearInterval(interval); + child.kill(); + await once(child, 'exit'); + + for (const run of runs) { + assert.doesNotMatch(run, /run\(\) is being called recursively/); + if (action === 'rename2') { + assert.match(run, /MODULE_NOT_FOUND/); + } else { + assert.doesNotMatch(run, /MODULE_NOT_FOUND/); + } + assert.match(run, /# tests 1/); + assert.match(run, /# pass 1/); + assert.match(run, /# fail 0/); + assert.match(run, /# cancelled 0/); + } + }; + + const testDelete = async () => { + await ran1.promise; + const fileToDeletePath = tmpdir.resolve(fileToUpdate); + const interval = setInterval(() => { + if (existsSync(fileToDeletePath)) { + unlinkSync(fileToDeletePath); + } else { + ran2.resolve(); + } + }, common.platformTimeout(1000)); + await ran2.promise; + runs.push(currentRun); + clearInterval(interval); + child.kill(); + await once(child, 'exit'); + + for (const run of runs) { + assert.doesNotMatch(run, /MODULE_NOT_FOUND/); + } + }; + + action === 'update' && await testUpdate(); + action === 'rename' && await testRename(); + action === 'rename2' && await testRename(); + action === 'delete' && await testDelete(); +} + +describe('test runner watch mode', () => { + beforeEach(refresh); + it('should run tests repeatedly', async () => { + await testWatch({ file: 'test.js', fileToUpdate: 'test.js' }); + }); + + it('should run tests with dependency repeatedly', async () => { + await testWatch({ file: 'test.js', fileToUpdate: 'dependency.js' }); + }); + + it('should run tests with ESM dependency', async () => { + await testWatch({ file: 'test.js', fileToUpdate: 'dependency.mjs' }); + }); + + it('should support running tests without a file', async () => { + await testWatch({ fileToUpdate: 'test.js' }); + }); + + it('should support a watched test file rename', async () => { + await testWatch({ fileToUpdate: 'test.js', action: 'rename' }); + }); + + it('should not throw when deleting a watched test file', { skip: common.isAIX }, async () => { + await testWatch({ fileToUpdate: 'test.js', action: 'delete' }); + }); + + it('should run tests with dependency repeatedly in a different cwd', async () => { + await testWatch({ + file: join(tmpdir.path, 'test.js'), + fileToUpdate: 'dependency.js', + cwd: import.meta.dirname, + action: 'rename2' + }); + }); + + it('should handle renames in a different cwd', async () => { + await testWatch({ + file: join(tmpdir.path, 'test.js'), + fileToUpdate: 'test.js', + cwd: import.meta.dirname, + action: 'rename2' + }); + }); +}); diff --git a/test/parallel/test-runner-run.mjs b/test/parallel/test-runner-run.mjs index 54e882c4ecabe3..7a575da9c95275 100644 --- a/test/parallel/test-runner-run.mjs +++ b/test/parallel/test-runner-run.mjs @@ -135,6 +135,7 @@ describe('require(\'node:test\').run', { concurrency: true }, () => { }) .compose(tap) .toArray(); + assert.strictEqual(result[2], 'ok 1 - this should be executed\n'); assert.strictEqual(result[4], '1..1\n'); assert.strictEqual(result[5], '# tests 1\n'); @@ -467,6 +468,19 @@ describe('require(\'node:test\').run', { concurrency: true }, () => { })); }); + it('should only allow array in options.globPatterns', async () => { + [Symbol(), {}, () => {}, 0, 1, 0n, 1n, '', '1', Promise.resolve([]), true, false] + .forEach((globPatterns) => assert.throws(() => run({ globPatterns }), { + code: 'ERR_INVALID_ARG_TYPE' + })); + }); + + it('should not allow files and globPatterns used together', () => { + assert.throws(() => run({ files: ['a.js'], globPatterns: ['*.js'] }), { + code: 'ERR_INVALID_ARG_VALUE' + }); + }); + it('should only allow object as options', () => { [Symbol(), [], () => {}, 0, 1, 0n, 1n, '', '1', true, false] .forEach((options) => assert.throws(() => run(options), { @@ -488,39 +502,6 @@ describe('require(\'node:test\').run', { concurrency: true }, () => { }); }); - it('should run with no files', async () => { - const stream = run({ - files: undefined - }).compose(tap); - stream.on('test:fail', common.mustNotCall()); - stream.on('test:pass', common.mustNotCall()); - - // eslint-disable-next-line no-unused-vars - for await (const _ of stream); - }); - - it('should run with no files and use spec reporter', async () => { - const stream = run({ - files: undefined - }).compose(spec); - stream.on('test:fail', common.mustNotCall()); - stream.on('test:pass', common.mustNotCall()); - - // eslint-disable-next-line no-unused-vars - for await (const _ of stream); - }); - - it('should run with no files and use dot reporter', async () => { - const stream = run({ - files: undefined - }).compose(dot); - stream.on('test:fail', common.mustNotCall()); - stream.on('test:pass', common.mustNotCall()); - - // eslint-disable-next-line no-unused-vars - for await (const _ of stream); - }); - it('should avoid running recursively', async () => { const stream = run({ files: [join(testFixtures, 'recursive_run.js')] }); let stderr = ''; @@ -551,3 +532,13 @@ describe('forceExit', () => { }); }); }); + + +// exitHandler doesn't run until after the tests / after hooks finish. +process.on('exit', () => { + assert.strictEqual(process.listeners('uncaughtException').length, 0); + assert.strictEqual(process.listeners('unhandledRejection').length, 0); + assert.strictEqual(process.listeners('beforeExit').length, 0); + assert.strictEqual(process.listeners('SIGINT').length, 0); + assert.strictEqual(process.listeners('SIGTERM').length, 0); +}); diff --git a/test/parallel/test-runner-snapshot-tests.js b/test/parallel/test-runner-snapshot-tests.js index d3abf356821d56..e00019ef49d4f6 100644 --- a/test/parallel/test-runner-snapshot-tests.js +++ b/test/parallel/test-runner-snapshot-tests.js @@ -20,37 +20,38 @@ tmpdir.refresh(); suite('SnapshotManager', () => { test('uses default snapshot naming scheme', (t) => { - const manager = new SnapshotManager(__filename, false); - manager.resolveSnapshotFile(); - t.assert.strictEqual(manager.snapshotFile, `${__filename}.snapshot`); + const manager = new SnapshotManager(false); + const file = manager.resolveSnapshotFile(__filename); + t.assert.strictEqual(file.snapshotFile, `${__filename}.snapshot`); }); test('generates snapshot IDs based on provided name', (t) => { - const manager = new SnapshotManager(__filename, false); - - t.assert.strictEqual(manager.nextId('foo'), 'foo 1'); - t.assert.strictEqual(manager.nextId('foo'), 'foo 2'); - t.assert.strictEqual(manager.nextId('bar'), 'bar 1'); - t.assert.strictEqual(manager.nextId('baz'), 'baz 1'); - t.assert.strictEqual(manager.nextId('foo'), 'foo 3'); - t.assert.strictEqual(manager.nextId('foo`'), 'foo` 1'); - t.assert.strictEqual(manager.nextId('foo\\'), 'foo\\ 1'); - t.assert.strictEqual(manager.nextId('foo`${x}`'), 'foo`${x}` 1'); + const manager = new SnapshotManager(false); + const file = manager.resolveSnapshotFile(__filename); + + t.assert.strictEqual(file.nextId('foo'), 'foo 1'); + t.assert.strictEqual(file.nextId('foo'), 'foo 2'); + t.assert.strictEqual(file.nextId('bar'), 'bar 1'); + t.assert.strictEqual(file.nextId('baz'), 'baz 1'); + t.assert.strictEqual(file.nextId('foo'), 'foo 3'); + t.assert.strictEqual(file.nextId('foo`'), 'foo` 1'); + t.assert.strictEqual(file.nextId('foo\\'), 'foo\\ 1'); + t.assert.strictEqual(file.nextId('foo`${x}`'), 'foo`${x}` 1'); }); test('throws if snapshot file does not have exports', (t) => { const fixture = fixtures.path( 'test-runner', 'snapshots', 'malformed-exports.js' ); - const manager = new SnapshotManager(fixture, false); + const manager = new SnapshotManager(false); + const file = manager.resolveSnapshotFile(fixture); t.assert.throws(() => { - manager.resolveSnapshotFile(); - manager.readSnapshotFile(); + file.readFile(); }, (err) => { t.assert.strictEqual(err.code, 'ERR_INVALID_STATE'); t.assert.match(err.message, /Cannot read snapshot/); - t.assert.strictEqual(err.filename, manager.snapshotFile); + t.assert.strictEqual(err.filename, file.snapshotFile); t.assert.match(err.cause.message, /Malformed snapshot file/); return true; }); @@ -60,16 +61,16 @@ suite('SnapshotManager', () => { const fixture = fixtures.path( 'test-runner', 'snapshots', 'this-file-should-not-exist.js' ); - const manager = new SnapshotManager(fixture, false); + const manager = new SnapshotManager(false); + const file = manager.resolveSnapshotFile(fixture); t.assert.throws(() => { - manager.resolveSnapshotFile(); - manager.readSnapshotFile(); + file.readFile(); }, /Missing snapshots can be generated by rerunning the command/); }); test('throws if serialization cannot generate a string', (t) => { - const manager = new SnapshotManager(__filename, false); + const manager = new SnapshotManager(false); const cause = new Error('boom'); const input = { foo: 1, @@ -90,7 +91,7 @@ suite('SnapshotManager', () => { }); test('serializes values using provided functions', (t) => { - const manager = new SnapshotManager(__filename, false); + const manager = new SnapshotManager(false); const output = manager.serialize({ foo: 1 }, [ (value) => { return JSON.stringify(value); }, (value) => { return value + '424242'; }, @@ -100,14 +101,14 @@ suite('SnapshotManager', () => { }); test('serialized values get cast to string', (t) => { - const manager = new SnapshotManager(__filename, false); + const manager = new SnapshotManager(false); const output = manager.serialize(5, []); t.assert.strictEqual(output, '\n5\n'); }); test('serialized values get escaped', (t) => { - const manager = new SnapshotManager(__filename, false); + const manager = new SnapshotManager(false); const output = manager.serialize('fo\\o`${x}`', []); t.assert.strictEqual(output, '\nfo\\\\o\\`\\${x}\\`\n'); @@ -115,53 +116,56 @@ suite('SnapshotManager', () => { test('reads individual snapshots from snapshot file', (t) => { const fixture = fixtures.path('test-runner', 'snapshots', 'simple.js'); - const manager = new SnapshotManager(fixture, false); - manager.resolveSnapshotFile(); - manager.readSnapshotFile(); - const snapshot = manager.getSnapshot('foo 1'); + const manager = new SnapshotManager(false); + const file = manager.resolveSnapshotFile(fixture); + file.readFile(); + const snapshot = file.getSnapshot('foo 1'); t.assert.strictEqual(snapshot, '\n{\n "bar": 1,\n "baz": 2\n}\n'); }); test('snapshot file is not read in update mode', (t) => { const fixture = fixtures.path('test-runner', 'snapshots', 'simple.js'); - const manager = new SnapshotManager(fixture, true); - manager.readSnapshotFile(); + const manager = new SnapshotManager(true); + const file = manager.resolveSnapshotFile(fixture); + file.readFile(); t.assert.throws(() => { - manager.getSnapshot('foo 1'); + file.getSnapshot('foo 1'); }, /Snapshot 'foo 1' not found/); }); test('throws if requested snapshot does not exist in file', (t) => { const fixture = fixtures.path('test-runner', 'snapshots', 'simple.js'); - const manager = new SnapshotManager(fixture, false); + const manager = new SnapshotManager(false); + const file = manager.resolveSnapshotFile(fixture); t.assert.throws(() => { - manager.getSnapshot('does not exist 1'); + file.getSnapshot('does not exist 1'); }, (err) => { t.assert.strictEqual(err.code, 'ERR_INVALID_STATE'); t.assert.match(err.message, /Snapshot 'does not exist 1' not found/); t.assert.strictEqual(err.snapshot, 'does not exist 1'); - t.assert.strictEqual(err.filename, manager.snapshotFile); + t.assert.strictEqual(err.filename, file.snapshotFile); return true; }); }); test('snapshot IDs are escaped when stored', (t) => { const fixture = fixtures.path('test-runner', 'snapshots', 'simple.js'); - const manager = new SnapshotManager(fixture, false); + const manager = new SnapshotManager(false); + const file = manager.resolveSnapshotFile(fixture); - manager.setSnapshot('foo`${x}` 1', 'test'); - t.assert.strictEqual(manager.getSnapshot('foo\\`\\${x}\\` 1'), 'test'); + file.setSnapshot('foo`${x}` 1', 'test'); + t.assert.strictEqual(file.getSnapshot('foo\\`\\${x}\\` 1'), 'test'); }); test('throws if snapshot file cannot be resolved', (t) => { - const manager = new SnapshotManager(null, false); + const manager = new SnapshotManager(false); const assertion = manager.createAssert(); t.assert.throws(() => { - assertion('foo'); + Reflect.apply(assertion, { filePath: null }, ['foo']); }, (err) => { t.assert.strictEqual(err.code, 'ERR_INVALID_STATE'); t.assert.match(err.message, /Invalid snapshot filename/); @@ -170,54 +174,59 @@ suite('SnapshotManager', () => { }); }); - test('writes the specified snapshot file', (t) => { - const testFile = tmpdir.resolve('test1.js'); - const manager = new SnapshotManager(testFile, true); - manager.resolveSnapshotFile(); - manager.setSnapshot('foo 1', 'foo value'); - t.assert.strictEqual(fs.existsSync(manager.snapshotFile), false); - manager.writeSnapshotFile(); - t.assert.strictEqual(fs.existsSync(manager.snapshotFile), true); + test('writes the specified snapshot files', (t) => { + const testFile1 = tmpdir.resolve('test1.js'); + const testFile2 = tmpdir.resolve('test2.js'); + const manager = new SnapshotManager(true); + const file1 = manager.resolveSnapshotFile(testFile1); + const file2 = manager.resolveSnapshotFile(testFile2); + file1.setSnapshot('foo 1', 'foo 1 value'); + file2.setSnapshot('foo 2', 'foo 2 value'); + t.assert.strictEqual(fs.existsSync(file1.snapshotFile), false); + t.assert.strictEqual(fs.existsSync(file2.snapshotFile), false); + manager.writeSnapshotFiles(); + t.assert.strictEqual(fs.existsSync(file1.snapshotFile), true); + t.assert.strictEqual(fs.existsSync(file2.snapshotFile), true); }); test('creates snapshot directory if it does not exist', (t) => { const testFile = tmpdir.resolve('foo/bar/baz/test2.js'); - const manager = new SnapshotManager(testFile, true); - manager.resolveSnapshotFile(); - manager.setSnapshot('foo 1', 'foo value'); - t.assert.strictEqual(fs.existsSync(manager.snapshotFile), false); - manager.writeSnapshotFile(); - t.assert.strictEqual(fs.existsSync(manager.snapshotFile), true); + const manager = new SnapshotManager(true); + const file = manager.resolveSnapshotFile(testFile); + file.setSnapshot('foo 1', 'foo value'); + t.assert.strictEqual(fs.existsSync(file.snapshotFile), false); + manager.writeSnapshotFiles(); + t.assert.strictEqual(fs.existsSync(file.snapshotFile), true); }); - test('does not write snapshot file in read mode', (t) => { + test('does not write snapshot files in read mode', (t) => { const testFile = tmpdir.resolve('test3.js'); - const manager = new SnapshotManager(testFile, false); - manager.resolveSnapshotFile(); - manager.setSnapshot('foo 1', 'foo value'); - t.assert.strictEqual(fs.existsSync(manager.snapshotFile), false); - manager.writeSnapshotFile(); - t.assert.strictEqual(fs.existsSync(manager.snapshotFile), false); + const manager = new SnapshotManager(false); + const file = manager.resolveSnapshotFile(testFile); + file.setSnapshot('foo 1', 'foo value'); + t.assert.strictEqual(fs.existsSync(file.snapshotFile), false); + manager.writeSnapshotFiles(); + t.assert.strictEqual(fs.existsSync(file.snapshotFile), false); }); - test('throws if snapshot file cannot be written', (t) => { + test('throws if snapshot files cannot be written', (t) => { const testFile = tmpdir.resolve('test4.js'); const error = new Error('boom'); - const manager = new SnapshotManager(testFile, true); - manager.resolveSnapshotFile(); - manager.snapshots['foo 1'] = { toString() { throw error; } }; - t.assert.strictEqual(fs.existsSync(manager.snapshotFile), false); + const manager = new SnapshotManager(true); + const file = manager.resolveSnapshotFile(testFile); + file.snapshots['foo 1'] = { toString() { throw error; } }; + t.assert.strictEqual(fs.existsSync(file.snapshotFile), false); t.assert.throws(() => { - manager.writeSnapshotFile(); + manager.writeSnapshotFiles(); }, (err) => { t.assert.strictEqual(err.code, 'ERR_INVALID_STATE'); t.assert.match(err.message, /Cannot write snapshot file/); - t.assert.strictEqual(err.filename, manager.snapshotFile); + t.assert.strictEqual(err.filename, file.snapshotFile); t.assert.strictEqual(err.cause, error); return true; }); - t.assert.strictEqual(fs.existsSync(manager.snapshotFile), false); + t.assert.strictEqual(fs.existsSync(file.snapshotFile), false); }); }); @@ -254,9 +263,9 @@ suite('setResolveSnapshotPath()', () => { }); snapshot.setResolveSnapshotPath(() => { return 'foobarbaz'; }); - const manager = new SnapshotManager(__filename, false); - manager.resolveSnapshotFile(); - t.assert.strictEqual(manager.snapshotFile, 'foobarbaz'); + const manager = new SnapshotManager(false); + const file = manager.resolveSnapshotFile(__filename); + t.assert.strictEqual(file.snapshotFile, 'foobarbaz'); }); }); @@ -276,7 +285,7 @@ suite('setDefaultSnapshotSerializers()', () => { }); snapshot.setDefaultSnapshotSerializers([() => { return 'foobarbaz'; }]); - const manager = new SnapshotManager(__filename, false); + const manager = new SnapshotManager(false); const output = manager.serialize({ foo: 1 }); t.assert.strictEqual(output, '\nfoobarbaz\n'); }); @@ -296,9 +305,9 @@ test('t.assert.snapshot()', async (t) => { t.assert.strictEqual(child.code, 1); t.assert.strictEqual(child.signal, null); - t.assert.match(child.stdout, /# tests 4/); + t.assert.match(child.stdout, /# tests 5/); t.assert.match(child.stdout, /# pass 0/); - t.assert.match(child.stdout, /# fail 4/); + t.assert.match(child.stdout, /# fail 5/); t.assert.match(child.stdout, /Missing snapshots/); }); @@ -311,8 +320,8 @@ test('t.assert.snapshot()', async (t) => { t.assert.strictEqual(child.code, 0); t.assert.strictEqual(child.signal, null); - t.assert.match(child.stdout, /tests 4/); - t.assert.match(child.stdout, /pass 4/); + t.assert.match(child.stdout, /tests 5/); + t.assert.match(child.stdout, /pass 5/); t.assert.match(child.stdout, /fail 0/); }); @@ -325,8 +334,8 @@ test('t.assert.snapshot()', async (t) => { t.assert.strictEqual(child.code, 0); t.assert.strictEqual(child.signal, null); - t.assert.match(child.stdout, /tests 4/); - t.assert.match(child.stdout, /pass 4/); + t.assert.match(child.stdout, /tests 5/); + t.assert.match(child.stdout, /pass 5/); t.assert.match(child.stdout, /fail 0/); }); }); diff --git a/test/parallel/test-runner-test-filepath.js b/test/parallel/test-runner-test-filepath.js new file mode 100644 index 00000000000000..46dd47d7cb6636 --- /dev/null +++ b/test/parallel/test-runner-test-filepath.js @@ -0,0 +1,52 @@ +'use strict'; +require('../common'); +const tmpdir = require('../common/tmpdir'); +const { strictEqual } = require('node:assert'); +const { writeFileSync } = require('node:fs'); +const { suite, test } = require('node:test'); + +tmpdir.refresh(); + +suite('suite', (t) => { + strictEqual(t.filePath, __filename); + + test('test', (t) => { + strictEqual(t.filePath, __filename); + + t.test('subtest', (t) => { + strictEqual(t.filePath, __filename); + + t.test('subsubtest', (t) => { + strictEqual(t.filePath, __filename); + }); + }); + }); +}); + +test((t) => { + strictEqual(t.filePath, __filename); +}); + +const importedTestFile = tmpdir.resolve('temp.js'); +writeFileSync(importedTestFile, ` + 'use strict'; + const { strictEqual } = require('node:assert'); + const { suite, test } = require('node:test'); + + suite('imported suite', (t) => { + strictEqual(t.filePath, ${JSON.stringify(__filename)}); + + test('imported test', (t) => { + strictEqual(t.filePath, ${JSON.stringify(__filename)}); + + t.test('imported subtest', (t) => { + strictEqual(t.filePath, ${JSON.stringify(__filename)}); + + t.test('imported subsubtest', (t) => { + strictEqual(t.filePath, ${JSON.stringify(__filename)}); + }); + }); + }); + }); +`); +require(importedTestFile); diff --git a/test/parallel/test-runner-watch-mode.mjs b/test/parallel/test-runner-watch-mode.mjs index 4af48ea409ddbb..a55f404a4f7010 100644 --- a/test/parallel/test-runner-watch-mode.mjs +++ b/test/parallel/test-runner-watch-mode.mjs @@ -1,17 +1,17 @@ // Flags: --expose-internals import * as common from '../common/index.mjs'; -import { describe, it } from 'node:test'; +import { describe, it, beforeEach } from 'node:test'; +import { once } from 'node:events'; import assert from 'node:assert'; import { spawn } from 'node:child_process'; import { writeFileSync, renameSync, unlinkSync, existsSync } from 'node:fs'; import util from 'internal/util'; import tmpdir from '../common/tmpdir.js'; - if (common.isIBMi) common.skip('IBMi does not support `fs.watch()`'); -tmpdir.refresh(); +let fixturePaths; // This test updates these files repeatedly, // Reading them from disk is unreliable due to race conditions. @@ -25,10 +25,14 @@ import('./dependency.mjs'); import('data:text/javascript,'); test('test has ran');`, }; -const fixturePaths = Object.keys(fixtureContent) - .reduce((acc, file) => ({ ...acc, [file]: tmpdir.resolve(file) }), {}); -Object.entries(fixtureContent) - .forEach(([file, content]) => writeFileSync(fixturePaths[file], content)); + +function refresh() { + tmpdir.refresh(); + fixturePaths = Object.keys(fixtureContent) + .reduce((acc, file) => ({ ...acc, [file]: tmpdir.resolve(file) }), {}); + Object.entries(fixtureContent) + .forEach(([file, content]) => writeFileSync(fixturePaths[file], content)); +} async function testWatch({ fileToUpdate, file, action = 'update' }) { const ran1 = util.createDeferredPromise(); @@ -57,6 +61,8 @@ async function testWatch({ fileToUpdate, file, action = 'update' }) { runs.push(currentRun); clearInterval(interval); child.kill(); + await once(child, 'exit'); + for (const run of runs) { assert.match(run, /# tests 1/); assert.match(run, /# pass 1/); @@ -74,6 +80,7 @@ async function testWatch({ fileToUpdate, file, action = 'update' }) { runs.push(currentRun); clearInterval(interval); child.kill(); + await once(child, 'exit'); for (const run of runs) { assert.match(run, /# tests 1/); @@ -97,6 +104,7 @@ async function testWatch({ fileToUpdate, file, action = 'update' }) { runs.push(currentRun); clearInterval(interval); child.kill(); + await once(child, 'exit'); for (const run of runs) { assert.doesNotMatch(run, /MODULE_NOT_FOUND/); @@ -109,6 +117,7 @@ async function testWatch({ fileToUpdate, file, action = 'update' }) { } describe('test runner watch mode', () => { + beforeEach(refresh); it('should run tests repeatedly', async () => { await testWatch({ file: 'test.js', fileToUpdate: 'test.js' }); }); @@ -129,7 +138,7 @@ describe('test runner watch mode', () => { await testWatch({ fileToUpdate: 'test.js', action: 'rename' }); }); - it('should not throw when delete a watched test file', async () => { + it('should not throw when delete a watched test file', { skip: common.isAIX }, async () => { await testWatch({ fileToUpdate: 'test.js', action: 'delete' }); }); }); diff --git a/test/parallel/test-sqlite.js b/test/parallel/test-sqlite.js index 99c8b7ee72a5c4..3d899063f9c967 100644 --- a/test/parallel/test-sqlite.js +++ b/test/parallel/test-sqlite.js @@ -219,7 +219,9 @@ suite('StatementSync() constructor', () => { suite('StatementSync.prototype.get()', () => { test('executes a query and returns undefined on no results', (t) => { const db = new DatabaseSync(nextDb()); - const stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)'); + let stmt = db.prepare('CREATE TABLE storage(key TEXT, val TEXT)'); + t.assert.strictEqual(stmt.get(), undefined); + stmt = db.prepare('SELECT * FROM storage'); t.assert.strictEqual(stmt.get(), undefined); }); @@ -388,6 +390,22 @@ suite('StatementSync.prototype.setReadBigInts()', () => { message: /The "readBigInts" argument must be a boolean/, }); }); + + test('BigInt is required for reading large integers', (t) => { + const db = new DatabaseSync(nextDb()); + const bad = db.prepare(`SELECT ${Number.MAX_SAFE_INTEGER} + 1`); + t.assert.throws(() => { + bad.get(); + }, { + code: 'ERR_OUT_OF_RANGE', + message: /^The value of column 0 is too large.*: 9007199254740992$/, + }); + const good = db.prepare(`SELECT ${Number.MAX_SAFE_INTEGER} + 1`); + good.setReadBigInts(true); + t.assert.deepStrictEqual(good.get(), { + [`${Number.MAX_SAFE_INTEGER} + 1`]: 2n ** 53n, + }); + }); }); suite('StatementSync.prototype.setAllowBareNamedParameters()', () => { diff --git a/test/parallel/test-stream-duplexpair.js b/test/parallel/test-stream-duplexpair.js new file mode 100644 index 00000000000000..3e1b3044ddb73c --- /dev/null +++ b/test/parallel/test-stream-duplexpair.js @@ -0,0 +1,74 @@ +'use strict'; + +const common = require('../common'); +const assert = require('assert'); +const { Duplex, duplexPair } = require('stream'); + +{ + const pair = duplexPair(); + + assert(pair[0] instanceof Duplex); + assert(pair[1] instanceof Duplex); + assert.notStrictEqual(pair[0], pair[1]); +} + +{ + // Verify that the iterable for array assignment works + const [ clientSide, serverSide ] = duplexPair(); + assert(clientSide instanceof Duplex); + assert(serverSide instanceof Duplex); + clientSide.on( + 'data', + common.mustCall((d) => assert.strictEqual(`${d}`, 'foo')) + ); + clientSide.on('end', common.mustNotCall()); + serverSide.write('foo'); +} + +{ + const [ clientSide, serverSide ] = duplexPair(); + assert(clientSide instanceof Duplex); + assert(serverSide instanceof Duplex); + serverSide.on( + 'data', + common.mustCall((d) => assert.strictEqual(`${d}`, 'foo')) + ); + serverSide.on('end', common.mustCall()); + clientSide.end('foo'); +} + +{ + const [ serverSide, clientSide ] = duplexPair(); + serverSide.cork(); + serverSide.write('abc'); + serverSide.write('12'); + serverSide.end('\n'); + serverSide.uncork(); + let characters = ''; + clientSide.on('readable', function() { + for (let segment; (segment = this.read()) !== null;) + characters += segment; + }); + clientSide.on('end', common.mustCall(function() { + assert.strictEqual(characters, 'abc12\n'); + })); +} + +// Test the case where the the _write never calls [kCallback] +// because a zero-size push doesn't trigger a _read +{ + const [ serverSide, clientSide ] = duplexPair(); + serverSide.write(''); + serverSide.write('12'); + serverSide.write(''); + serverSide.write(''); + serverSide.end('\n'); + let characters = ''; + clientSide.on('readable', function() { + for (let segment; (segment = this.read()) !== null;) + characters += segment; + }); + clientSide.on('end', common.mustCall(function() { + assert.strictEqual(characters, '12\n'); + })); +} diff --git a/test/parallel/test-timers-immediate-queue.js b/test/parallel/test-timers-immediate-queue.js index dd793eead03438..8b433ddedbf416 100644 --- a/test/parallel/test-timers-immediate-queue.js +++ b/test/parallel/test-timers-immediate-queue.js @@ -52,6 +52,5 @@ for (let i = 0; i < QUEUE; i++) setImmediate(run); process.on('exit', function() { - console.log('hit', hit); assert.strictEqual(hit, QUEUE); }); diff --git a/test/parallel/test-timer-immediate.js b/test/parallel/test-timers-process-tampering.js similarity index 51% rename from test/parallel/test-timer-immediate.js rename to test/parallel/test-timers-process-tampering.js index b0f52db1b713d3..766cc9f3560c82 100644 --- a/test/parallel/test-timer-immediate.js +++ b/test/parallel/test-timers-process-tampering.js @@ -1,3 +1,6 @@ +// Check that setImmediate works even if process is tampered with. +// This is a regression test for https://github.com/nodejs/node/issues/17681. + 'use strict'; const common = require('../common'); global.process = {}; // Boom! diff --git a/test/parallel/test-timers.js b/test/parallel/test-timers.js index e04c1f3f184946..11c6e106e85760 100644 --- a/test/parallel/test-timers.js +++ b/test/parallel/test-timers.js @@ -79,3 +79,8 @@ setTimeout(common.mustCall(() => { // Test 10 ms timeout separately. setTimeout(common.mustCall(), 10); setInterval(common.mustCall(function() { clearInterval(this); }), 10); + +// Test no timeout separately +setTimeout(common.mustCall()); +// eslint-disable-next-line no-restricted-syntax +setInterval(common.mustCall(function() { clearInterval(this); })); diff --git a/test/parallel/test-tls-destroy-stream.js b/test/parallel/test-tls-destroy-stream.js index a49e985a7e0204..7af85856093183 100644 --- a/test/parallel/test-tls-destroy-stream.js +++ b/test/parallel/test-tls-destroy-stream.js @@ -4,7 +4,7 @@ const common = require('../common'); if (!common.hasCrypto) common.skip('missing crypto'); const fixtures = require('../common/fixtures'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); const net = require('net'); const assert = require('assert'); const tls = require('tls'); @@ -41,7 +41,7 @@ const server = net.createServer((conn) => { conn.on('error', common.mustNotCall()); // Assume that we want to use data to determine what to do with connections. conn.once('data', common.mustCall((chunk) => { - const { clientSide, serverSide } = makeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); serverSide.on('close', common.mustCall(() => { conn.destroy(); })); diff --git a/test/parallel/test-tls-error-servername.js b/test/parallel/test-tls-error-servername.js index 12e6f89e60fc0f..597b7f29a4064c 100644 --- a/test/parallel/test-tls-error-servername.js +++ b/test/parallel/test-tls-error-servername.js @@ -10,8 +10,8 @@ if (!common.hasCrypto) const assert = require('assert'); const { connect, TLSSocket } = require('tls'); -const makeDuplexPair = require('../common/duplexpair'); -const { clientSide, serverSide } = makeDuplexPair(); +const { duplexPair } = require('stream'); +const [ clientSide, serverSide ] = duplexPair(); const key = fixtures.readKey('agent1-key.pem'); const cert = fixtures.readKey('agent1-cert.pem'); diff --git a/test/parallel/test-tls-generic-stream.js b/test/parallel/test-tls-generic-stream.js index d4e5427acae110..8be72d7252718e 100644 --- a/test/parallel/test-tls-generic-stream.js +++ b/test/parallel/test-tls-generic-stream.js @@ -4,7 +4,7 @@ if (!common.hasCrypto) common.skip('missing crypto'); const fixtures = require('../common/fixtures'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); const assert = require('assert'); const { TLSSocket, connect } = require('tls'); @@ -12,7 +12,7 @@ const key = fixtures.readKey('agent1-key.pem'); const cert = fixtures.readKey('agent1-cert.pem'); const ca = fixtures.readKey('ca1-cert.pem'); -const { clientSide, serverSide } = makeDuplexPair(); +const [ clientSide, serverSide ] = duplexPair(); const clientTLS = connect({ socket: clientSide, diff --git a/test/parallel/test-tls-socket-snicallback-without-server.js b/test/parallel/test-tls-socket-snicallback-without-server.js index 3ef28b95702552..9ad5d554c81c39 100644 --- a/test/parallel/test-tls-socket-snicallback-without-server.js +++ b/test/parallel/test-tls-socket-snicallback-without-server.js @@ -10,9 +10,9 @@ if (!common.hasCrypto) const assert = require('assert'); const tls = require('tls'); const fixtures = require('../common/fixtures'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); -const { clientSide, serverSide } = makeDuplexPair(); +const [ clientSide, serverSide ] = duplexPair(); new tls.TLSSocket(serverSide, { isServer: true, SNICallback: common.mustCall((servername, cb) => { diff --git a/test/parallel/test-tls-streamwrap-buffersize.js b/test/parallel/test-tls-streamwrap-buffersize.js index 0e0a49883a5a08..399c8b1c8cf272 100644 --- a/test/parallel/test-tls-streamwrap-buffersize.js +++ b/test/parallel/test-tls-streamwrap-buffersize.js @@ -4,7 +4,7 @@ if (!common.hasCrypto) common.skip('missing crypto'); const assert = require('assert'); const fixtures = require('../common/fixtures'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); const tls = require('tls'); const net = require('net'); @@ -15,7 +15,7 @@ const net = require('net'); const iter = 10; function createDuplex(port) { - const { clientSide, serverSide } = makeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); return new Promise((resolve, reject) => { const socket = net.connect({ diff --git a/test/parallel/test-tls-transport-destroy-after-own-gc.js b/test/parallel/test-tls-transport-destroy-after-own-gc.js index 819aa0a03d6cb4..17c494ca0b79d1 100644 --- a/test/parallel/test-tls-transport-destroy-after-own-gc.js +++ b/test/parallel/test-tls-transport-destroy-after-own-gc.js @@ -10,9 +10,9 @@ if (!common.hasCrypto) common.skip('missing crypto'); const { TLSSocket } = require('tls'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); -let { clientSide } = makeDuplexPair(); +let [ clientSide ] = duplexPair(); let clientTLS = new TLSSocket(clientSide, { isServer: false }); let clientTLSHandle = clientTLS._handle; // eslint-disable-line no-unused-vars diff --git a/test/parallel/test-trace-events-get-category-enabled-buffer.js b/test/parallel/test-trace-events-get-category-enabled-buffer.js new file mode 100644 index 00000000000000..3017b8e6dc87d7 --- /dev/null +++ b/test/parallel/test-trace-events-get-category-enabled-buffer.js @@ -0,0 +1,43 @@ +'use strict'; +// Flags: --expose-internals + +const common = require('../common'); +const { it } = require('node:test'); + +try { + require('trace_events'); +} catch { + common.skip('missing trace events'); +} + +const { createTracing, getEnabledCategories } = require('trace_events'); +const assert = require('assert'); + +const binding = require('internal/test/binding'); +const getCategoryEnabledBuffer = binding.internalBinding('trace_events').getCategoryEnabledBuffer; + +it('should track enabled/disabled categories', () => { + const random = Math.random().toString().slice(2); + const category = `node.${random}`; + + const buffer = getCategoryEnabledBuffer(category); + + const tracing = createTracing({ + categories: [category], + }); + + assert.ok(buffer[0] === 0, `the buffer[0] should start with value 0, got: ${buffer[0]}`); + + tracing.enable(); + + let currentCategories = getEnabledCategories(); + + assert.ok(currentCategories.includes(category), `the getEnabledCategories should include ${category}, got: ${currentCategories}`); + assert.ok(buffer[0] > 0, `the buffer[0] should be greater than 0, got: ${buffer[0]}`); + + tracing.disable(); + + currentCategories = getEnabledCategories(); + assert.ok(currentCategories === undefined, `the getEnabledCategories should return undefined, got: ${currentCategories}`); + assert.ok(buffer[0] === 0, `the buffer[0] should be 0, got: ${buffer[0]}`); +}); diff --git a/test/parallel/test-worker-exit-code.js b/test/parallel/test-worker-exit-code.js index bfa3df924bd71c..738a8b038e8285 100644 --- a/test/parallel/test-worker-exit-code.js +++ b/test/parallel/test-worker-exit-code.js @@ -8,7 +8,7 @@ const assert = require('assert'); const worker = require('worker_threads'); const { Worker, parentPort } = worker; -const { getTestCases } = require('../fixtures/process-exit-code-cases'); +const { getTestCases } = require('../common/process-exit-code-cases'); const testCases = getTestCases(true); // Do not use isMainThread so that this test itself can be run inside a Worker. diff --git a/test/parallel/test-worker-http2-stream-terminate.js b/test/parallel/test-worker-http2-stream-terminate.js index 370961bec27923..128a79c3186d2e 100644 --- a/test/parallel/test-worker-http2-stream-terminate.js +++ b/test/parallel/test-worker-http2-stream-terminate.js @@ -4,7 +4,7 @@ if (!common.hasCrypto) common.skip('missing crypto'); const assert = require('assert'); const http2 = require('http2'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); const { parentPort, Worker } = require('worker_threads'); // This test ensures that workers can be terminated without error while @@ -46,7 +46,7 @@ if (!process.env.HAS_STARTED_WORKER) { stream.end(''); }); - const { clientSide, serverSide } = makeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); server.emit('connection', serverSide); const client = http2.connect('http://localhost:80', { diff --git a/test/parallel/test-worker-terminate-http2-respond-with-file.js b/test/parallel/test-worker-terminate-http2-respond-with-file.js index 8fa8602330fcfe..9c80d68a46c335 100644 --- a/test/parallel/test-worker-terminate-http2-respond-with-file.js +++ b/test/parallel/test-worker-terminate-http2-respond-with-file.js @@ -4,7 +4,7 @@ if (!common.hasCrypto) common.skip('missing crypto'); const assert = require('assert'); const http2 = require('http2'); -const makeDuplexPair = require('../common/duplexpair'); +const { duplexPair } = require('stream'); const { Worker, isMainThread } = require('worker_threads'); // This is a variant of test-http2-generic-streams-sendfile for checking @@ -20,7 +20,7 @@ if (isMainThread) { stream.respondWithFile(process.execPath); // Use a large-ish file. })); - const { clientSide, serverSide } = makeDuplexPair(); + const [ clientSide, serverSide ] = duplexPair(); server.emit('connection', serverSide); const client = http2.connect('http://localhost:80', { diff --git a/tools/bootstrap/README.md b/tools/bootstrap/README.md index 2f323331b4b0c3..ed0cc57bb11043 100644 --- a/tools/bootstrap/README.md +++ b/tools/bootstrap/README.md @@ -1,3 +1,2 @@ -See the main project -[BUILDING.md](../../BUILDING.md#option-2-automated-install-with-boxstarter) -for details on how to use this script. +Refer to [BUILDING.md](../../BUILDING.md#option-2-automated-install-with-boxstarter) for +instructions on how to build Node.js with boxstarter. diff --git a/tools/build_addons.py b/tools/build_addons.py index db948ba7b908e8..b8e36078d236cb 100755 --- a/tools/build_addons.py +++ b/tools/build_addons.py @@ -66,6 +66,7 @@ def node_gyp_rebuild(test_dir): print(stdout.decode()) if stderr: print(stderr.decode()) + return return_code except Exception as e: print(f'Unexpected error when building addon in {test_dir}. Error: {e}') @@ -86,7 +87,8 @@ def node_gyp_rebuild(test_dir): test_dirs.append(full_path) with ThreadPoolExecutor() as executor: - executor.map(node_gyp_rebuild, test_dirs) + codes = executor.map(node_gyp_rebuild, test_dirs) + return 0 if all(code == 0 for code in codes) else 1 def get_default_out_dir(args): default_out_dir = os.path.join('out', args.config) @@ -131,17 +133,19 @@ def main(): if not args.out_dir: args.out_dir = get_default_out_dir(args) + exit_code = 1 if args.headers_dir: - rebuild_addons(args) + exit_code = rebuild_addons(args) else: # When --headers-dir is not specified, generate headers into a temp dir and # build with the new headers. try: args.headers_dir = tempfile.mkdtemp() generate_headers(args.headers_dir, unknown_args) - rebuild_addons(args) + exit_code = rebuild_addons(args) finally: shutil.rmtree(args.headers_dir) + return exit_code if __name__ == '__main__': - main() + sys.exit(main()) diff --git a/tools/dep_updaters/update-amaro.sh b/tools/dep_updaters/update-amaro.sh new file mode 100755 index 00000000000000..0169e9304bc0a4 --- /dev/null +++ b/tools/dep_updaters/update-amaro.sh @@ -0,0 +1,83 @@ +#!/bin/sh + +# Shell script to update amaro in the source tree to the latest release. + +# This script must be in the tools directory when it runs because it uses the +# script source file path to determine directories to work in. + +set -ex + +BASE_DIR=$(cd "$(dirname "$0")/../.." && pwd) +[ -z "$NODE" ] && NODE="$BASE_DIR/out/Release/node" +[ -x "$NODE" ] || NODE=$(command -v node) +DEPS_DIR="$BASE_DIR/deps" +NPM="$DEPS_DIR/npm/bin/npm-cli.js" + +# shellcheck disable=SC1091 +. "$BASE_DIR/tools/dep_updaters/utils.sh" + +NEW_VERSION=$("$NODE" "$NPM" view amaro dist-tags.latest) + +CURRENT_VERSION=$("$NODE" -p "require('./deps/amaro/package.json').version") + +# This function exit with 0 if new version and current version are the same +compare_dependency_version "amaro" "$NEW_VERSION" "$CURRENT_VERSION" + +cd "$( dirname "$0" )/../.." || exit + +echo "Making temporary workspace..." + +WORKSPACE=$(mktemp -d 2> /dev/null || mktemp -d -t 'tmp') + +cleanup () { + EXIT_CODE=$? + [ -d "$WORKSPACE" ] && rm -rf "$WORKSPACE" + exit $EXIT_CODE +} + +trap cleanup INT TERM EXIT + +cd "$WORKSPACE" + +echo "Fetching amaro source archive..." + +"$NODE" "$NPM" pack "amaro@$NEW_VERSION" + +amaro_TGZ="amaro-$NEW_VERSION.tgz" + +log_and_verify_sha256sum "amaro" "$amaro_TGZ" + +cp ./* "$DEPS_DIR/amaro/LICENSE" + +rm -r "$DEPS_DIR/amaro"/* + +tar -xf "$amaro_TGZ" + +cd package + +rm -rf node_modules + +mv ./* "$DEPS_DIR/amaro" + +# update version information in src/undici_version.h +cat > "$ROOT/src/amaro_version.h" <; + function cpSyncCheckPaths(src: StringOrBuffer, dest: StringOrBuffer, dereference: boolean, recursive: boolean): void; + function fchmod(fd: number, mode: number, req: FSReqCallback): void; function fchmod(fd: number, mode: number): void; function fchmod(fd: number, mode: number, usePromises: typeof kUsePromises): Promise; @@ -255,6 +257,7 @@ export interface FsBinding { chown: typeof InternalFSBinding.chown; close: typeof InternalFSBinding.close; copyFile: typeof InternalFSBinding.copyFile; + cpSyncCheckPaths: typeof InternalFSBinding.cpSyncCheckPaths; fchmod: typeof InternalFSBinding.fchmod; fchown: typeof InternalFSBinding.fchown; fdatasync: typeof InternalFSBinding.fdatasync; diff --git a/typings/internalBinding/fs_dir.d.ts b/typings/internalBinding/fs_dir.d.ts index 7e0eb1246c0c35..87084fd9f6d07b 100644 --- a/typings/internalBinding/fs_dir.d.ts +++ b/typings/internalBinding/fs_dir.d.ts @@ -1,4 +1,4 @@ -import {InternalFSBinding, ReadFileContext} from './fs'; +import { InternalFSBinding } from './fs'; declare namespace InternalFSDirBinding { import FSReqCallback = InternalFSBinding.FSReqCallback; diff --git a/typings/internalBinding/quic.d.ts b/typings/internalBinding/quic.d.ts index d95c34c9da041a..41acfba0bd438e 100644 --- a/typings/internalBinding/quic.d.ts +++ b/typings/internalBinding/quic.d.ts @@ -2,7 +2,7 @@ interface QuicCallbacks { onEndpointClose: (context: number, status: number) => void; onSessionNew: (session: Session) => void; onSessionClose: (type: number, code: bigint, reason?: string) => void; - onSessionDatagram: (datagram: Uint8Array, early: boolean) => void;); + onSessionDatagram: (datagram: Uint8Array, early: boolean) => void; onSessionDatagramStatus: (id: bigint, status: string) => void; onSessionHandshake: (sni: string, alpn: string, diff --git a/unofficial.gni b/unofficial.gni index 006ba413c68f07..c3b311e4a7f544 100644 --- a/unofficial.gni +++ b/unofficial.gni @@ -178,6 +178,7 @@ template("node_gn_build") { deps += [ "//third_party/icu" ] } if (node_use_openssl) { + deps += [ "deps/ncrypto" ] public_deps += [ "deps/openssl" ] sources += gypi_values.node_crypto_sources } @@ -339,6 +340,7 @@ template("node_gn_build") { sources = gypi_values.node_cctest_sources if (node_use_openssl) { + deps += [ "deps/ncrypto" ] sources += gypi_values.node_cctest_openssl_sources } if (node_enable_inspector) { diff --git a/vcbuild.bat b/vcbuild.bat index 5853c74c9e5dfb..428577c5c3d1e9 100644 --- a/vcbuild.bat +++ b/vcbuild.bat @@ -281,6 +281,14 @@ goto exit :msbuild-found +@rem Visual Studio v17.10 has a bug that causes the build to fail. +@rem Check if the version is v17.10 and exit if it is. +echo %VSCMD_VER% | findstr /b /c:"17.10" >nul +if %errorlevel% neq 1 ( + echo Node.js doesn't compile with Visual Studio 17.10 Please use a different version. + goto exit +) + @rem check if the clang-cl build is requested if not defined clang_cl goto clang-skip @rem x64 is hard coded as it is used for both cross and native compilation.